@reltio/remotes 1.4.1387 → 1.4.1389

package/7584.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"7584.js","mappings":"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","sources":["webpack://@reltio/remotes/../../node_modules/@material-ui/icons/AddCircle.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/DragIndicator.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/Edit.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/KeyboardArrowLeft.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/KeyboardArrowRight.js","webpack://@reltio/remotes/../../node_modules/frontend-collective-react-dnd-scrollzone/lib/index.js","webpack://@reltio/remotes/../../node_modules/frontend-collective-react-dnd-scrollzone/lib/util.js","webpack://@reltio/remotes/../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://@reltio/remotes/../../node_modules/react-display-name/lib/getDisplayName.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/utils/CellSizeAndPositionManager.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/utils/ScalingCellSizeAndPositionManager.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/utils/maxElementSize.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/utils/createCallbackMemoizer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/utils/updateScrollIndexHelper.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/node_modules/dom-helpers/esm/canUseDOM.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/node_modules/dom-helpers/esm/scrollbarSize.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/utils/animationFrame.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/Grid.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/utils/requestAnimationTimeout.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/defaultOverscanIndicesGetter.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/defaultCellRangeRenderer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Grid/accessibilityOverscanIndicesGetter.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/ArrowKeyStepper/types.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/ArrowKeyStepper/ArrowKeyStepper.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/AutoSizer/AutoSizer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/vendor/detectElementResize.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurerCache.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/CollectionView.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/types.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/Section.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/SectionManager.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/utils/getUpdatedOffsetForIndex.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/Collection.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Collection/utils/calculateSizeAndPositionData.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/ColumnSizer/ColumnSizer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/InfiniteLoader/InfiniteLoader.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/List/types.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/List/List.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/vendor/binarySearchBounds.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/vendor/intervalTree.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Masonry/PositionCache.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Masonry/Masonry.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/MultiGrid/CellMeasurerCacheDecorator.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/MultiGrid/MultiGrid.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/defaultHeaderRowRenderer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/ScrollSync/ScrollSync.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/SortDirection.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/SortIndicator.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/defaultHeaderRenderer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/defaultRowRenderer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/Column.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/Table.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/defaultCellDataGetter.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/Table/defaultCellRenderer.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/WindowScroller/utils/onScroll.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/WindowScroller/utils/dimensions.js","webpack://@reltio/remotes/../../node_modules/react-virtualized/dist/es/WindowScroller/WindowScroller.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z\"\n}), 'AddCircle');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M11 18c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm-2-8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0-6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 4c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z\"\n}), 'DragIndicator');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34a.9959.9959 0 00-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z\"\n}), 'Edit');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M15.41 16.59L10.83 12l4.58-4.59L14 6l-6 6 6 6 1.41-1.41z\"\n}), 'KeyboardArrowLeft');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z\"\n}), 'KeyboardArrowRight');\n\nexports.default = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createHorizontalStrength = createHorizontalStrength;\nexports.createVerticalStrength = createVerticalStrength;\nexports.createScrollingComponent = createScrollingComponent;\nexports.default = createScrollingComponentWithConsumer;\nexports.defaultVerticalStrength = exports.defaultHorizontalStrength = void 0;\n\nvar _react = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = require(\"react-dom\");\n\nvar _lodash = _interopRequireDefault(require(\"lodash.throttle\"));\n\nvar _raf = _interopRequireDefault(require(\"raf\"));\n\nvar _reactDisplayName = _interopRequireDefault(require(\"react-display-name\"));\n\nvar _reactDnd = require(\"react-dnd\");\n\nvar _hoistNonReactStatics = _interopRequireDefault(require(\"hoist-non-react-statics\"));\n\nvar _util = require(\"./util\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar DEFAULT_BUFFER = 150;\n\nfunction createHorizontalStrength(_buffer) {\n  return function defaultHorizontalStrength(_ref, point) {\n    var x = _ref.x,\n        w = _ref.w,\n        y = _ref.y,\n        h = _ref.h;\n    var buffer = Math.min(w / 2, _buffer);\n    var inRange = point.x >= x && point.x <= x + w;\n    var inBox = inRange && point.y >= y && point.y <= y + h;\n\n    if (inBox) {\n      if (point.x < x + buffer) {\n        return (point.x - x - buffer) / buffer;\n      }\n\n      if (point.x > x + w - buffer) {\n        return -(x + w - point.x - buffer) / buffer;\n      }\n    }\n\n    return 0;\n  };\n}\n\nfunction createVerticalStrength(_buffer) {\n  return function defaultVerticalStrength(_ref2, point) {\n    var y = _ref2.y,\n        h = _ref2.h,\n        x = _ref2.x,\n        w = _ref2.w;\n    var buffer = Math.min(h / 2, _buffer);\n    var inRange = point.y >= y && point.y <= y + h;\n    var inBox = inRange && point.x >= x && point.x <= x + w;\n\n    if (inBox) {\n      if (point.y < y + buffer) {\n        return (point.y - y - buffer) / buffer;\n      }\n\n      if (point.y > y + h - buffer) {\n        return -(y + h - point.y - buffer) / buffer;\n      }\n    }\n\n    return 0;\n  };\n}\n\nvar defaultHorizontalStrength = createHorizontalStrength(DEFAULT_BUFFER);\nexports.defaultHorizontalStrength = defaultHorizontalStrength;\nvar defaultVerticalStrength = createVerticalStrength(DEFAULT_BUFFER);\nexports.defaultVerticalStrength = defaultVerticalStrength;\n\nfunction createScrollingComponent(WrappedComponent) {\n  var ScrollingComponent =\n  /*#__PURE__*/\n  function (_Component) {\n    _inherits(ScrollingComponent, _Component);\n\n    // Update scaleX and scaleY every 100ms or so\n    // and start scrolling if necessary\n    function ScrollingComponent(props, ctx) {\n      var _this;\n\n      _classCallCheck(this, ScrollingComponent);\n\n      _this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollingComponent).call(this, props, ctx));\n\n      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), \"updateScrolling\", (0, _lodash.default)(function (evt) {\n        var _this$container$getBo = _this.container.getBoundingClientRect(),\n            x = _this$container$getBo.left,\n            y = _this$container$getBo.top,\n            w = _this$container$getBo.width,\n            h = _this$container$getBo.height;\n\n        var box = {\n          x: x,\n          y: y,\n          w: w,\n          h: h\n        };\n        var coords = (0, _util.getCoords)(evt); // calculate strength\n\n        var _this$props = _this.props,\n            horizontalStrength = _this$props.horizontalStrength,\n            verticalStrength = _this$props.verticalStrength;\n        _this.scaleX = horizontalStrength(box, coords);\n        _this.scaleY = verticalStrength(box, coords); // start scrolling if we need to\n\n        if (!_this.frame && (_this.scaleX || _this.scaleY)) {\n          _this.startScrolling();\n        }\n      }, 100, {\n        trailing: false\n      }));\n\n      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), \"handleEvent\", function (evt) {\n        if (_this.dragging && !_this.attached) {\n          _this.attach();\n\n          _this.updateScrolling(evt);\n        }\n      });\n\n      _this.wrappedInstance = _react.default.createRef();\n      _this.scaleX = 0;\n      _this.scaleY = 0;\n      _this.frame = null;\n      _this.attached = false;\n      _this.dragging = false;\n      return _this;\n    }\n\n    _createClass(ScrollingComponent, [{\n      key: \"componentDidMount\",\n      value: function componentDidMount() {\n        var _this2 = this;\n\n        // eslint-disable-next-line react/no-find-dom-node\n        this.container = (0, _reactDom.findDOMNode)(this.wrappedInstance.current);\n\n        if (this.container && typeof this.container.addEventListener === 'function') {\n          this.container.addEventListener('dragover', this.handleEvent);\n        } // touchmove events don't seem to work across siblings, so we unfortunately\n        // have to attach the listeners to the body\n\n\n        window.document.body.addEventListener('touchmove', this.handleEvent);\n        var dragDropManager = this.props.dragDropManager;\n        this.clearMonitorSubscription = dragDropManager.getMonitor().subscribeToStateChange(function () {\n          return _this2.handleMonitorChange();\n        });\n      }\n    }, {\n      key: \"componentWillUnmount\",\n      value: function componentWillUnmount() {\n        if (this.container && typeof this.container.removeEventListener === 'function') {\n          this.container.removeEventListener('dragover', this.handleEvent);\n        }\n\n        window.document.body.removeEventListener('touchmove', this.handleEvent);\n        this.clearMonitorSubscription();\n        this.stopScrolling();\n      }\n    }, {\n      key: \"handleMonitorChange\",\n      value: function handleMonitorChange() {\n        var dragDropManager = this.props.dragDropManager;\n        var isDragging = dragDropManager.getMonitor().isDragging();\n\n        if (!this.dragging && isDragging) {\n          this.dragging = true;\n        } else if (this.dragging && !isDragging) {\n          this.dragging = false;\n          this.stopScrolling();\n        }\n      }\n    }, {\n      key: \"attach\",\n      value: function attach() {\n        this.attached = true;\n        window.document.body.addEventListener('dragover', this.updateScrolling);\n        window.document.body.addEventListener('touchmove', this.updateScrolling);\n      }\n    }, {\n      key: \"detach\",\n      value: function detach() {\n        this.attached = false;\n        window.document.body.removeEventListener('dragover', this.updateScrolling);\n        window.document.body.removeEventListener('touchmove', this.updateScrolling);\n      }\n    }, {\n      key: \"startScrolling\",\n      value: function startScrolling() {\n        var _this3 = this;\n\n        var i = 0;\n\n        var tick = function tick() {\n          var scaleX = _this3.scaleX,\n              scaleY = _this3.scaleY,\n              container = _this3.container;\n          var _this3$props = _this3.props,\n              strengthMultiplier = _this3$props.strengthMultiplier,\n              onScrollChange = _this3$props.onScrollChange; // stop scrolling if there's nothing to do\n\n          if (strengthMultiplier === 0 || scaleX + scaleY === 0) {\n            _this3.stopScrolling();\n\n            return;\n          } // there's a bug in safari where it seems like we can't get\n          // mousemove events from a container that also emits a scroll\n          // event that same frame. So we double the strengthMultiplier and only adjust\n          // the scroll position at 30fps\n\n\n          i += 1;\n\n          if (i % 2) {\n            var scrollLeft = container.scrollLeft,\n                scrollTop = container.scrollTop,\n                scrollWidth = container.scrollWidth,\n                scrollHeight = container.scrollHeight,\n                clientWidth = container.clientWidth,\n                clientHeight = container.clientHeight;\n            var newLeft = scaleX ? container.scrollLeft = (0, _util.intBetween)(0, scrollWidth - clientWidth, scrollLeft + scaleX * strengthMultiplier) : scrollLeft;\n            var newTop = scaleY ? container.scrollTop = (0, _util.intBetween)(0, scrollHeight - clientHeight, scrollTop + scaleY * strengthMultiplier) : scrollTop;\n            onScrollChange(newLeft, newTop);\n          }\n\n          _this3.frame = (0, _raf.default)(tick);\n        };\n\n        tick();\n      }\n    }, {\n      key: \"stopScrolling\",\n      value: function stopScrolling() {\n        this.detach();\n        this.scaleX = 0;\n        this.scaleY = 0;\n\n        if (this.frame) {\n          _raf.default.cancel(this.frame);\n\n          this.frame = null;\n        }\n      }\n    }, {\n      key: \"render\",\n      value: function render() {\n        var _this$props2 = this.props,\n            strengthMultiplier = _this$props2.strengthMultiplier,\n            verticalStrength = _this$props2.verticalStrength,\n            horizontalStrength = _this$props2.horizontalStrength,\n            onScrollChange = _this$props2.onScrollChange,\n            props = _objectWithoutProperties(_this$props2, [\"strengthMultiplier\", \"verticalStrength\", \"horizontalStrength\", \"onScrollChange\"]);\n\n        return _react.default.createElement(WrappedComponent, _extends({\n          ref: this.wrappedInstance\n        }, props));\n      }\n    }]);\n\n    return ScrollingComponent;\n  }(_react.Component);\n\n  _defineProperty(ScrollingComponent, \"displayName\", \"Scrolling(\".concat((0, _reactDisplayName.default)(WrappedComponent), \")\"));\n\n  _defineProperty(ScrollingComponent, \"propTypes\", {\n    // eslint-disable-next-line react/forbid-prop-types\n    dragDropManager: _propTypes.default.object.isRequired,\n    onScrollChange: _propTypes.default.func,\n    verticalStrength: _propTypes.default.func,\n    horizontalStrength: _propTypes.default.func,\n    strengthMultiplier: _propTypes.default.number\n  });\n\n  _defineProperty(ScrollingComponent, \"defaultProps\", {\n    onScrollChange: _util.noop,\n    verticalStrength: defaultVerticalStrength,\n    horizontalStrength: defaultHorizontalStrength,\n    strengthMultiplier: 30\n  });\n\n  return (0, _hoistNonReactStatics.default)(ScrollingComponent, WrappedComponent);\n}\n\nfunction createScrollingComponentWithConsumer(WrappedComponent) {\n  var ScrollingComponent = createScrollingComponent(WrappedComponent);\n  return function (props) {\n    return _react.default.createElement(_reactDnd.DragDropContextConsumer, null, function (_ref3) {\n      var dragDropManager = _ref3.dragDropManager;\n      return dragDropManager === undefined ? null : _react.default.createElement(ScrollingComponent, _extends({}, props, {\n        dragDropManager: dragDropManager\n      }));\n    });\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.noop = noop;\nexports.intBetween = intBetween;\nexports.getCoords = getCoords;\n\nfunction noop() {}\n\nfunction intBetween(min, max, val) {\n  return Math.floor(Math.min(max, Math.max(min, val)));\n}\n\nfunction getCoords(evt) {\n  if (evt.type === 'touchmove') {\n    return {\n      x: evt.changedTouches[0].clientX,\n      y: evt.changedTouches[0].clientY\n    };\n  }\n\n  return {\n    x: evt.clientX,\n    y: evt.clientY\n  };\n}","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getDisplayName;\nfunction getDisplayName(Component) {\n  return Component.displayName || Component.name || (typeof Component === 'string' && Component.length > 0 ? Component : 'Unknown');\n}","/**\n * Helper method that determines when to recalculate row or column metadata.\n */\nexport default function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) {\n  var cellCount = _ref.cellCount,\n      cellSize = _ref.cellSize,\n      computeMetadataCallback = _ref.computeMetadataCallback,\n      computeMetadataCallbackProps = _ref.computeMetadataCallbackProps,\n      nextCellsCount = _ref.nextCellsCount,\n      nextCellSize = _ref.nextCellSize,\n      nextScrollToIndex = _ref.nextScrollToIndex,\n      scrollToIndex = _ref.scrollToIndex,\n      updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex;\n\n  // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.\n  // In that event users should use the manual recompute methods to inform of changes.\n  if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {\n    computeMetadataCallback(computeMetadataCallbackProps); // Updated cell metadata may have hidden the previous scrolled-to item.\n    // In this case we should also update the scrollTop to ensure it stays visible.\n\n    if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {\n      updateScrollOffsetForScrollToIndex();\n    }\n  }\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\n/**\n * Just-in-time calculates and caches size and position information for a collection of cells.\n */\nvar CellSizeAndPositionManager =\n/*#__PURE__*/\nfunction () {\n  // Cache of size and position data for cells, mapped by cell index.\n  // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex\n  // Measurements for cells up to this index can be trusted; cells afterward should be estimated.\n  // Used in deferred mode to track which cells have been queued for measurement.\n  function CellSizeAndPositionManager(_ref) {\n    var cellCount = _ref.cellCount,\n        cellSizeGetter = _ref.cellSizeGetter,\n        estimatedCellSize = _ref.estimatedCellSize;\n\n    _classCallCheck(this, CellSizeAndPositionManager);\n\n    _defineProperty(this, \"_cellSizeAndPositionData\", {});\n\n    _defineProperty(this, \"_lastMeasuredIndex\", -1);\n\n    _defineProperty(this, \"_lastBatchedIndex\", -1);\n\n    _defineProperty(this, \"_cellCount\", void 0);\n\n    _defineProperty(this, \"_cellSizeGetter\", void 0);\n\n    _defineProperty(this, \"_estimatedCellSize\", void 0);\n\n    this._cellSizeGetter = cellSizeGetter;\n    this._cellCount = cellCount;\n    this._estimatedCellSize = estimatedCellSize;\n  }\n\n  _createClass(CellSizeAndPositionManager, [{\n    key: \"areOffsetsAdjusted\",\n    value: function areOffsetsAdjusted() {\n      return false;\n    }\n  }, {\n    key: \"configure\",\n    value: function configure(_ref2) {\n      var cellCount = _ref2.cellCount,\n          estimatedCellSize = _ref2.estimatedCellSize,\n          cellSizeGetter = _ref2.cellSizeGetter;\n      this._cellCount = cellCount;\n      this._estimatedCellSize = estimatedCellSize;\n      this._cellSizeGetter = cellSizeGetter;\n    }\n  }, {\n    key: \"getCellCount\",\n    value: function getCellCount() {\n      return this._cellCount;\n    }\n  }, {\n    key: \"getEstimatedCellSize\",\n    value: function getEstimatedCellSize() {\n      return this._estimatedCellSize;\n    }\n  }, {\n    key: \"getLastMeasuredIndex\",\n    value: function getLastMeasuredIndex() {\n      return this._lastMeasuredIndex;\n    }\n  }, {\n    key: \"getOffsetAdjustment\",\n    value: function getOffsetAdjustment() {\n      return 0;\n    }\n    /**\n     * This method returns the size and position for the cell at the specified index.\n     * It just-in-time calculates (or used cached values) for cells leading up to the index.\n     */\n\n  }, {\n    key: \"getSizeAndPositionOfCell\",\n    value: function getSizeAndPositionOfCell(index) {\n      if (index < 0 || index >= this._cellCount) {\n        throw Error(\"Requested index \".concat(index, \" is outside of range 0..\").concat(this._cellCount));\n      }\n\n      if (index > this._lastMeasuredIndex) {\n        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n        var offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n\n        for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {\n          var size = this._cellSizeGetter({\n            index: i\n          }); // undefined or NaN probably means a logic error in the size getter.\n          // null means we're using CellMeasurer and haven't yet measured a given index.\n\n\n          if (size === undefined || isNaN(size)) {\n            throw Error(\"Invalid size returned for cell \".concat(i, \" of value \").concat(size));\n          } else if (size === null) {\n            this._cellSizeAndPositionData[i] = {\n              offset: offset,\n              size: 0\n            };\n            this._lastBatchedIndex = index;\n          } else {\n            this._cellSizeAndPositionData[i] = {\n              offset: offset,\n              size: size\n            };\n            offset += size;\n            this._lastMeasuredIndex = index;\n          }\n        }\n      }\n\n      return this._cellSizeAndPositionData[index];\n    }\n  }, {\n    key: \"getSizeAndPositionOfLastMeasuredCell\",\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {\n        offset: 0,\n        size: 0\n      };\n    }\n    /**\n     * Total size of all cells being measured.\n     * This value will be completely estimated initially.\n     * As cells are measured, the estimate will be updated.\n     */\n\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n      var totalSizeOfMeasuredCells = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n      var numUnmeasuredCells = this._cellCount - this._lastMeasuredIndex - 1;\n      var totalSizeOfUnmeasuredCells = numUnmeasuredCells * this._estimatedCellSize;\n      return totalSizeOfMeasuredCells + totalSizeOfUnmeasuredCells;\n    }\n    /**\n     * Determines a new offset that ensures a certain cell is visible, given the current offset.\n     * If the cell is already visible then the current offset will be returned.\n     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n     *\n     * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n     * @param containerSize Size (width or height) of the container viewport\n     * @param currentOffset Container's current (x or y) offset\n     * @param totalSize Total size (width or height) of all cells\n     * @return Offset to use to ensure the specified cell is visible\n     */\n\n  }, {\n    key: \"getUpdatedOffsetForIndex\",\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align,\n          align = _ref3$align === void 0 ? 'auto' : _ref3$align,\n          containerSize = _ref3.containerSize,\n          currentOffset = _ref3.currentOffset,\n          targetIndex = _ref3.targetIndex;\n\n      if (containerSize <= 0) {\n        return 0;\n      }\n\n      var datum = this.getSizeAndPositionOfCell(targetIndex);\n      var maxOffset = datum.offset;\n      var minOffset = maxOffset - containerSize + datum.size;\n      var idealOffset;\n\n      switch (align) {\n        case 'start':\n          idealOffset = maxOffset;\n          break;\n\n        case 'end':\n          idealOffset = minOffset;\n          break;\n\n        case 'center':\n          idealOffset = maxOffset - (containerSize - datum.size) / 2;\n          break;\n\n        default:\n          idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));\n          break;\n      }\n\n      var totalSize = this.getTotalSize();\n      return Math.max(0, Math.min(totalSize - containerSize, idealOffset));\n    }\n  }, {\n    key: \"getVisibleCellRange\",\n    value: function getVisibleCellRange(params) {\n      var containerSize = params.containerSize,\n          offset = params.offset;\n      var totalSize = this.getTotalSize();\n\n      if (totalSize === 0) {\n        return {};\n      }\n\n      var maxOffset = offset + containerSize;\n\n      var start = this._findNearestCell(offset);\n\n      var datum = this.getSizeAndPositionOfCell(start);\n      offset = datum.offset + datum.size;\n      var stop = start;\n\n      while (offset < maxOffset && stop < this._cellCount - 1) {\n        stop++;\n        offset += this.getSizeAndPositionOfCell(stop).size;\n      }\n\n      return {\n        start: start,\n        stop: stop\n      };\n    }\n    /**\n     * Clear all cached values for cells after the specified index.\n     * This method should be called for any cell that has changed its size.\n     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.\n     */\n\n  }, {\n    key: \"resetCell\",\n    value: function resetCell(index) {\n      this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);\n    }\n  }, {\n    key: \"_binarySearch\",\n    value: function _binarySearch(high, low, offset) {\n      while (low <= high) {\n        var middle = low + Math.floor((high - low) / 2);\n        var currentOffset = this.getSizeAndPositionOfCell(middle).offset;\n\n        if (currentOffset === offset) {\n          return middle;\n        } else if (currentOffset < offset) {\n          low = middle + 1;\n        } else if (currentOffset > offset) {\n          high = middle - 1;\n        }\n      }\n\n      if (low > 0) {\n        return low - 1;\n      } else {\n        return 0;\n      }\n    }\n  }, {\n    key: \"_exponentialSearch\",\n    value: function _exponentialSearch(index, offset) {\n      var interval = 1;\n\n      while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {\n        index += interval;\n        interval *= 2;\n      }\n\n      return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);\n    }\n    /**\n     * Searches for the cell (index) nearest the specified offset.\n     *\n     * If no exact match is found the next lowest cell index will be returned.\n     * This allows partially visible cells (with offsets just before/above the fold) to be visible.\n     */\n\n  }, {\n    key: \"_findNearestCell\",\n    value: function _findNearestCell(offset) {\n      if (isNaN(offset)) {\n        throw Error(\"Invalid offset \".concat(offset, \" specified\"));\n      } // Our search algorithms find the nearest match at or below the specified offset.\n      // So make sure the offset is at least 0 or no match will be found.\n\n\n      offset = Math.max(0, offset);\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n      var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);\n\n      if (lastMeasuredCellSizeAndPosition.offset >= offset) {\n        // If we've already measured cells within this range just use a binary search as it's faster.\n        return this._binarySearch(lastMeasuredIndex, 0, offset);\n      } else {\n        // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.\n        // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would.\n        // The overall complexity for this approach is O(log n).\n        return this._exponentialSearch(lastMeasuredIndex, offset);\n      }\n    }\n  }]);\n\n  return CellSizeAndPositionManager;\n}();\n\nexport { CellSizeAndPositionManager as default };\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"../types\";\nimport { bpfrpt_proptype_VisibleCellRange } from \"../types\";","import _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport CellSizeAndPositionManager from './CellSizeAndPositionManager';\nimport { getMaxElementSize } from './maxElementSize.js';\n\n/**\n * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.\n */\nvar ScalingCellSizeAndPositionManager =\n/*#__PURE__*/\nfunction () {\n  function ScalingCellSizeAndPositionManager(_ref) {\n    var _ref$maxScrollSize = _ref.maxScrollSize,\n        maxScrollSize = _ref$maxScrollSize === void 0 ? getMaxElementSize() : _ref$maxScrollSize,\n        params = _objectWithoutProperties(_ref, [\"maxScrollSize\"]);\n\n    _classCallCheck(this, ScalingCellSizeAndPositionManager);\n\n    _defineProperty(this, \"_cellSizeAndPositionManager\", void 0);\n\n    _defineProperty(this, \"_maxScrollSize\", void 0);\n\n    // Favor composition over inheritance to simplify IE10 support\n    this._cellSizeAndPositionManager = new CellSizeAndPositionManager(params);\n    this._maxScrollSize = maxScrollSize;\n  }\n\n  _createClass(ScalingCellSizeAndPositionManager, [{\n    key: \"areOffsetsAdjusted\",\n    value: function areOffsetsAdjusted() {\n      return this._cellSizeAndPositionManager.getTotalSize() > this._maxScrollSize;\n    }\n  }, {\n    key: \"configure\",\n    value: function configure(params) {\n      this._cellSizeAndPositionManager.configure(params);\n    }\n  }, {\n    key: \"getCellCount\",\n    value: function getCellCount() {\n      return this._cellSizeAndPositionManager.getCellCount();\n    }\n  }, {\n    key: \"getEstimatedCellSize\",\n    value: function getEstimatedCellSize() {\n      return this._cellSizeAndPositionManager.getEstimatedCellSize();\n    }\n  }, {\n    key: \"getLastMeasuredIndex\",\n    value: function getLastMeasuredIndex() {\n      return this._cellSizeAndPositionManager.getLastMeasuredIndex();\n    }\n    /**\n     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.\n     * The offset passed to this function is scaled (safe) as well.\n     */\n\n  }, {\n    key: \"getOffsetAdjustment\",\n    value: function getOffsetAdjustment(_ref2) {\n      var containerSize = _ref2.containerSize,\n          offset = _ref2.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      var offsetPercentage = this._getOffsetPercentage({\n        containerSize: containerSize,\n        offset: offset,\n        totalSize: safeTotalSize\n      });\n\n      return Math.round(offsetPercentage * (safeTotalSize - totalSize));\n    }\n  }, {\n    key: \"getSizeAndPositionOfCell\",\n    value: function getSizeAndPositionOfCell(index) {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);\n    }\n  }, {\n    key: \"getSizeAndPositionOfLastMeasuredCell\",\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();\n    }\n    /** See CellSizeAndPositionManager#getTotalSize */\n\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());\n    }\n    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */\n\n  }, {\n    key: \"getUpdatedOffsetForIndex\",\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align,\n          align = _ref3$align === void 0 ? 'auto' : _ref3$align,\n          containerSize = _ref3.containerSize,\n          currentOffset = _ref3.currentOffset,\n          targetIndex = _ref3.targetIndex;\n      currentOffset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: currentOffset\n      });\n\n      var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({\n        align: align,\n        containerSize: containerSize,\n        currentOffset: currentOffset,\n        targetIndex: targetIndex\n      });\n\n      return this._offsetToSafeOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n    /** See CellSizeAndPositionManager#getVisibleCellRange */\n\n  }, {\n    key: \"getVisibleCellRange\",\n    value: function getVisibleCellRange(_ref4) {\n      var containerSize = _ref4.containerSize,\n          offset = _ref4.offset;\n      offset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n      return this._cellSizeAndPositionManager.getVisibleCellRange({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n  }, {\n    key: \"resetCell\",\n    value: function resetCell(index) {\n      this._cellSizeAndPositionManager.resetCell(index);\n    }\n  }, {\n    key: \"_getOffsetPercentage\",\n    value: function _getOffsetPercentage(_ref5) {\n      var containerSize = _ref5.containerSize,\n          offset = _ref5.offset,\n          totalSize = _ref5.totalSize;\n      return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);\n    }\n  }, {\n    key: \"_offsetToSafeOffset\",\n    value: function _offsetToSafeOffset(_ref6) {\n      var containerSize = _ref6.containerSize,\n          offset = _ref6.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: totalSize\n        });\n\n        return Math.round(offsetPercentage * (safeTotalSize - containerSize));\n      }\n    }\n  }, {\n    key: \"_safeOffsetToOffset\",\n    value: function _safeOffsetToOffset(_ref7) {\n      var containerSize = _ref7.containerSize,\n          offset = _ref7.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: safeTotalSize\n        });\n\n        return Math.round(offsetPercentage * (totalSize - containerSize));\n      }\n    }\n  }]);\n\n  return ScalingCellSizeAndPositionManager;\n}();\n\nexport { ScalingCellSizeAndPositionManager as default };\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"../types\";\nimport { bpfrpt_proptype_VisibleCellRange } from \"../types\";","var DEFAULT_MAX_ELEMENT_SIZE = 1500000;\nvar CHROME_MAX_ELEMENT_SIZE = 1.67771e7;\n\nvar isBrowser = function isBrowser() {\n  return typeof window !== 'undefined';\n};\n\nvar isChrome = function isChrome() {\n  return !!window.chrome;\n};\n\nexport var getMaxElementSize = function getMaxElementSize() {\n  if (isBrowser()) {\n    if (isChrome()) {\n      return CHROME_MAX_ELEMENT_SIZE;\n    }\n  }\n\n  return DEFAULT_MAX_ELEMENT_SIZE;\n};","/**\n * Helper utility that updates the specified callback whenever any of the specified indices have changed.\n */\nexport default function createCallbackMemoizer() {\n  var requireAllKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n  var cachedIndices = {};\n  return function (_ref) {\n    var callback = _ref.callback,\n        indices = _ref.indices;\n    var keys = Object.keys(indices);\n    var allInitialized = !requireAllKeys || keys.every(function (key) {\n      var value = indices[key];\n      return Array.isArray(value) ? value.length > 0 : value >= 0;\n    });\n    var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) {\n      var cachedValue = cachedIndices[key];\n      var value = indices[key];\n      return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value;\n    });\n    cachedIndices = indices;\n\n    if (allInitialized && indexChanged) {\n      callback(indices);\n    }\n  };\n}","import ScalingCellSizeAndPositionManager from './ScalingCellSizeAndPositionManager.js';\n/**\n * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.\n * This function also ensures that the scroll ofset isn't past the last column/row of cells.\n */\n\nexport default function updateScrollIndexHelper(_ref) {\n  var cellSize = _ref.cellSize,\n      cellSizeAndPositionManager = _ref.cellSizeAndPositionManager,\n      previousCellsCount = _ref.previousCellsCount,\n      previousCellSize = _ref.previousCellSize,\n      previousScrollToAlignment = _ref.previousScrollToAlignment,\n      previousScrollToIndex = _ref.previousScrollToIndex,\n      previousSize = _ref.previousSize,\n      scrollOffset = _ref.scrollOffset,\n      scrollToAlignment = _ref.scrollToAlignment,\n      scrollToIndex = _ref.scrollToIndex,\n      size = _ref.size,\n      sizeJustIncreasedFromZero = _ref.sizeJustIncreasedFromZero,\n      updateScrollIndexCallback = _ref.updateScrollIndexCallback;\n  var cellCount = cellSizeAndPositionManager.getCellCount();\n  var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount;\n  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,\n  // We should ensure that the scroll target is visible.\n\n  if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) {\n    updateScrollIndexCallback(scrollToIndex); // If we don't have a selected item but list size or number of children have decreased,\n    // Make sure we aren't scrolled too far past the current content.\n  } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) {\n    // We need to ensure that the current scroll offset is still within the collection's range.\n    // To do this, we don't need to measure everything; CellMeasurer would perform poorly.\n    // Just check to make sure we're still okay.\n    // Only adjust the scroll position if we've scrolled below the last set of rows.\n    if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) {\n      updateScrollIndexCallback(cellCount - 1);\n    }\n  }\n}\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSize } from \"../types\";","export default !!(typeof window !== 'undefined' && window.document && window.document.createElement);","import canUseDOM from './canUseDOM';\nvar size;\nexport default function scrollbarSize(recalc) {\n  if (!size && size !== 0 || recalc) {\n    if (canUseDOM) {\n      var scrollDiv = document.createElement('div');\n      scrollDiv.style.position = 'absolute';\n      scrollDiv.style.top = '-9999px';\n      scrollDiv.style.width = '50px';\n      scrollDiv.style.height = '50px';\n      scrollDiv.style.overflow = 'scroll';\n      document.body.appendChild(scrollDiv);\n      size = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n      document.body.removeChild(scrollDiv);\n    }\n  }\n\n  return size;\n}","// Properly handle server-side rendering.\nvar win;\n\nif (typeof window !== 'undefined') {\n  win = window;\n} else if (typeof self !== 'undefined') {\n  win = self;\n} else {\n  win = {};\n} // requestAnimationFrame() shim by Paul Irish\n// http://paulirish.com/2011/requestanimationframe-for-smart-animating/\n\n\nvar request = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || function (callback) {\n  return win.setTimeout(callback, 1000 / 60);\n};\n\nvar cancel = win.cancelAnimationFrame || win.webkitCancelAnimationFrame || win.mozCancelAnimationFrame || win.oCancelAnimationFrame || win.msCancelAnimationFrame || function (id) {\n  win.clearTimeout(id);\n};\n\nexport var raf = request;\nexport var caf = cancel;","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport clsx from 'clsx';\nimport calculateSizeAndPositionDataAndUpdateScrollOffset from './utils/calculateSizeAndPositionDataAndUpdateScrollOffset';\nimport ScalingCellSizeAndPositionManager from './utils/ScalingCellSizeAndPositionManager';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\nimport defaultOverscanIndicesGetter, { SCROLL_DIRECTION_BACKWARD, SCROLL_DIRECTION_FORWARD } from './defaultOverscanIndicesGetter';\nimport updateScrollIndexHelper from './utils/updateScrollIndexHelper';\nimport defaultCellRangeRenderer from './defaultCellRangeRenderer';\nimport scrollbarSize from 'dom-helpers/scrollbarSize';\nimport { polyfill } from 'react-lifecycles-compat';\nimport { requestAnimationTimeout, cancelAnimationTimeout } from '../utils/requestAnimationTimeout';\n/**\n * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nexport var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\n\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n\nvar renderNull = function renderNull() {\n  return null;\n};\n\n/**\n * Renders tabular data with virtualization along the vertical and horizontal axes.\n * Row heights and column widths must be known ahead of time and specified as properties.\n */\nvar Grid = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Grid, _React$PureComponent);\n\n  // Invokes onSectionRendered callback only when start/stop row or column indices change\n  function Grid(props) {\n    var _this;\n\n    _classCallCheck(this, Grid);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Grid).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"_onGridRenderedMemoizer\", createCallbackMemoizer());\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollMemoizer\", createCallbackMemoizer(false));\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateColumnIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateRowIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_recomputeScrollLeftFlag\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_recomputeScrollTopFlag\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_horizontalScrollBarSize\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_verticalScrollBarSize\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_scrollbarPresenceChanged\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_scrollingContainer\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_childrenToDisplay\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStartIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStopIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStartIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStopIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedColumnStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedColumnStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedRowStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedRowStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_initialScrollTop\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_initialScrollLeft\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_disablePointerEventsTimeoutId\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_styleCache\", {});\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellCache\", {});\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceScrollEndedCallback\", function () {\n      _this._disablePointerEventsTimeoutId = null; // isScrolling is used to determine if we reset styleCache\n\n      _this.setState({\n        isScrolling: false,\n        needToResetStyleCache: false\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_invokeOnGridRenderedHelper\", function () {\n      var onSectionRendered = _this.props.onSectionRendered;\n\n      _this._onGridRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          columnOverscanStartIndex: _this._columnStartIndex,\n          columnOverscanStopIndex: _this._columnStopIndex,\n          columnStartIndex: _this._renderedColumnStartIndex,\n          columnStopIndex: _this._renderedColumnStopIndex,\n          rowOverscanStartIndex: _this._rowStartIndex,\n          rowOverscanStopIndex: _this._rowStopIndex,\n          rowStartIndex: _this._renderedRowStartIndex,\n          rowStopIndex: _this._renderedRowStopIndex\n        }\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target === _this._scrollingContainer) {\n        _this.handleScrollEvent(event.target);\n      }\n    });\n\n    var columnSizeAndPositionManager = new ScalingCellSizeAndPositionManager({\n      cellCount: props.columnCount,\n      cellSizeGetter: function cellSizeGetter(params) {\n        return Grid._wrapSizeGetter(props.columnWidth)(params);\n      },\n      estimatedCellSize: Grid._getEstimatedColumnSize(props)\n    });\n    var rowSizeAndPositionManager = new ScalingCellSizeAndPositionManager({\n      cellCount: props.rowCount,\n      cellSizeGetter: function cellSizeGetter(params) {\n        return Grid._wrapSizeGetter(props.rowHeight)(params);\n      },\n      estimatedCellSize: Grid._getEstimatedRowSize(props)\n    });\n    _this.state = {\n      instanceProps: {\n        columnSizeAndPositionManager: columnSizeAndPositionManager,\n        rowSizeAndPositionManager: rowSizeAndPositionManager,\n        prevColumnWidth: props.columnWidth,\n        prevRowHeight: props.rowHeight,\n        prevColumnCount: props.columnCount,\n        prevRowCount: props.rowCount,\n        prevIsScrolling: props.isScrolling === true,\n        prevScrollToColumn: props.scrollToColumn,\n        prevScrollToRow: props.scrollToRow,\n        scrollbarSize: 0,\n        scrollbarSizeMeasured: false\n      },\n      isScrolling: false,\n      scrollDirectionHorizontal: SCROLL_DIRECTION_FORWARD,\n      scrollDirectionVertical: SCROLL_DIRECTION_FORWARD,\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollPositionChangeReason: null,\n      needToResetStyleCache: false\n    };\n\n    if (props.scrollToRow > 0) {\n      _this._initialScrollTop = _this._getCalculatedScrollTop(props, _this.state);\n    }\n\n    if (props.scrollToColumn > 0) {\n      _this._initialScrollLeft = _this._getCalculatedScrollLeft(props, _this.state);\n    }\n\n    return _this;\n  }\n  /**\n   * Gets offsets for a given cell and alignment.\n   */\n\n\n  _createClass(Grid, [{\n    key: \"getOffsetForCell\",\n    value: function getOffsetForCell() {\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref$alignment = _ref.alignment,\n          alignment = _ref$alignment === void 0 ? this.props.scrollToAlignment : _ref$alignment,\n          _ref$columnIndex = _ref.columnIndex,\n          columnIndex = _ref$columnIndex === void 0 ? this.props.scrollToColumn : _ref$columnIndex,\n          _ref$rowIndex = _ref.rowIndex,\n          rowIndex = _ref$rowIndex === void 0 ? this.props.scrollToRow : _ref$rowIndex;\n\n      var offsetProps = _objectSpread({}, this.props, {\n        scrollToAlignment: alignment,\n        scrollToColumn: columnIndex,\n        scrollToRow: rowIndex\n      });\n\n      return {\n        scrollLeft: this._getCalculatedScrollLeft(offsetProps),\n        scrollTop: this._getCalculatedScrollTop(offsetProps)\n      };\n    }\n    /**\n     * Gets estimated total rows' height.\n     */\n\n  }, {\n    key: \"getTotalRowsHeight\",\n    value: function getTotalRowsHeight() {\n      return this.state.instanceProps.rowSizeAndPositionManager.getTotalSize();\n    }\n    /**\n     * Gets estimated total columns' width.\n     */\n\n  }, {\n    key: \"getTotalColumnsWidth\",\n    value: function getTotalColumnsWidth() {\n      return this.state.instanceProps.columnSizeAndPositionManager.getTotalSize();\n    }\n    /**\n     * This method handles a scroll event originating from an external scroll control.\n     * It's an advanced method and should probably not be used unless you're implementing a custom scroll-bar solution.\n     */\n\n  }, {\n    key: \"handleScrollEvent\",\n    value: function handleScrollEvent(_ref2) {\n      var _ref2$scrollLeft = _ref2.scrollLeft,\n          scrollLeftParam = _ref2$scrollLeft === void 0 ? 0 : _ref2$scrollLeft,\n          _ref2$scrollTop = _ref2.scrollTop,\n          scrollTopParam = _ref2$scrollTop === void 0 ? 0 : _ref2$scrollTop;\n\n      // On iOS, we can arrive at negative offsets by swiping past the start.\n      // To prevent flicker here, we make playing in the negative offset zone cause nothing to happen.\n      if (scrollTopParam < 0) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      this._debounceScrollEnded();\n\n      var _this$props = this.props,\n          autoHeight = _this$props.autoHeight,\n          autoWidth = _this$props.autoWidth,\n          height = _this$props.height,\n          width = _this$props.width;\n      var instanceProps = this.state.instanceProps; // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.\n\n      var scrollbarSize = instanceProps.scrollbarSize;\n      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n      var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n      var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), scrollLeftParam);\n      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), scrollTopParam); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {\n        // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling.\n        // Don't change direction for an axis unless scroll offset has changed.\n        var scrollDirectionHorizontal = scrollLeft !== this.state.scrollLeft ? scrollLeft > this.state.scrollLeft ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionHorizontal;\n        var scrollDirectionVertical = scrollTop !== this.state.scrollTop ? scrollTop > this.state.scrollTop ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionVertical;\n        var newState = {\n          isScrolling: true,\n          scrollDirectionHorizontal: scrollDirectionHorizontal,\n          scrollDirectionVertical: scrollDirectionVertical,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.OBSERVED\n        };\n\n        if (!autoHeight) {\n          newState.scrollTop = scrollTop;\n        }\n\n        if (!autoWidth) {\n          newState.scrollLeft = scrollLeft;\n        }\n\n        newState.needToResetStyleCache = false;\n        this.setState(newState);\n      }\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        totalColumnsWidth: totalColumnsWidth,\n        totalRowsHeight: totalRowsHeight\n      });\n    }\n    /**\n     * Invalidate Grid size and recompute visible cells.\n     * This is a deferred wrapper for recomputeGridSize().\n     * It sets a flag to be evaluated on cDM/cDU to avoid unnecessary renders.\n     * This method is intended for advanced use-cases like CellMeasurer.\n     */\n    // @TODO (bvaughn) Add automated test coverage for this.\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref3) {\n      var columnIndex = _ref3.columnIndex,\n          rowIndex = _ref3.rowIndex;\n      this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;\n      this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;\n    }\n    /**\n     * Pre-measure all columns and rows in a Grid.\n     * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured.\n     * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one).\n     */\n\n  }, {\n    key: \"measureAllCells\",\n    value: function measureAllCells() {\n      var _this$props2 = this.props,\n          columnCount = _this$props2.columnCount,\n          rowCount = _this$props2.rowCount;\n      var instanceProps = this.state.instanceProps;\n      instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);\n      instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);\n    }\n    /**\n     * Forced recompute of row heights and column widths.\n     * This function should be called if dynamic column or row sizes have changed but nothing else has.\n     * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes.\n     */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref4$columnIndex = _ref4.columnIndex,\n          columnIndex = _ref4$columnIndex === void 0 ? 0 : _ref4$columnIndex,\n          _ref4$rowIndex = _ref4.rowIndex,\n          rowIndex = _ref4$rowIndex === void 0 ? 0 : _ref4$rowIndex;\n\n      var _this$props3 = this.props,\n          scrollToColumn = _this$props3.scrollToColumn,\n          scrollToRow = _this$props3.scrollToRow;\n      var instanceProps = this.state.instanceProps;\n      instanceProps.columnSizeAndPositionManager.resetCell(columnIndex);\n      instanceProps.rowSizeAndPositionManager.resetCell(rowIndex); // Cell sizes may be determined by a function property.\n      // In this case the cDU handler can't know if they changed.\n      // Store this flag to let the next cDU pass know it needs to recompute the scroll offset.\n\n      this._recomputeScrollLeftFlag = scrollToColumn >= 0 && (this.state.scrollDirectionHorizontal === SCROLL_DIRECTION_FORWARD ? columnIndex <= scrollToColumn : columnIndex >= scrollToColumn);\n      this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === SCROLL_DIRECTION_FORWARD ? rowIndex <= scrollToRow : rowIndex >= scrollToRow); // Clear cell cache in case we are scrolling;\n      // Invalid row heights likely mean invalid cached content as well.\n\n      this._styleCache = {};\n      this._cellCache = {};\n      this.forceUpdate();\n    }\n    /**\n     * Ensure column and row are visible.\n     */\n\n  }, {\n    key: \"scrollToCell\",\n    value: function scrollToCell(_ref5) {\n      var columnIndex = _ref5.columnIndex,\n          rowIndex = _ref5.rowIndex;\n      var columnCount = this.props.columnCount;\n      var props = this.props; // Don't adjust scroll offset for single-column grids (eg List, Table).\n      // This can cause a funky scroll offset because of the vertical scrollbar width.\n\n      if (columnCount > 1 && columnIndex !== undefined) {\n        this._updateScrollLeftForScrollToColumn(_objectSpread({}, props, {\n          scrollToColumn: columnIndex\n        }));\n      }\n\n      if (rowIndex !== undefined) {\n        this._updateScrollTopForScrollToRow(_objectSpread({}, props, {\n          scrollToRow: rowIndex\n        }));\n      }\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props4 = this.props,\n          getScrollbarSize = _this$props4.getScrollbarSize,\n          height = _this$props4.height,\n          scrollLeft = _this$props4.scrollLeft,\n          scrollToColumn = _this$props4.scrollToColumn,\n          scrollTop = _this$props4.scrollTop,\n          scrollToRow = _this$props4.scrollToRow,\n          width = _this$props4.width;\n      var instanceProps = this.state.instanceProps; // Reset initial offsets to be ignored in browser\n\n      this._initialScrollTop = 0;\n      this._initialScrollLeft = 0; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.\n      // We must do this at the start of the method as we may calculate and update scroll position below.\n\n      this._handleInvalidatedGridSize(); // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n\n      if (!instanceProps.scrollbarSizeMeasured) {\n        this.setState(function (prevState) {\n          var stateUpdate = _objectSpread({}, prevState, {\n            needToResetStyleCache: false\n          });\n\n          stateUpdate.instanceProps.scrollbarSize = getScrollbarSize();\n          stateUpdate.instanceProps.scrollbarSizeMeasured = true;\n          return stateUpdate;\n        });\n      }\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0 || typeof scrollTop === 'number' && scrollTop >= 0) {\n        var stateUpdate = Grid._getScrollToPositionStateUpdate({\n          prevState: this.state,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n\n        if (stateUpdate) {\n          stateUpdate.needToResetStyleCache = false;\n          this.setState(stateUpdate);\n        }\n      } // refs don't work in `react-test-renderer`\n\n\n      if (this._scrollingContainer) {\n        // setting the ref's scrollLeft and scrollTop.\n        // Somehow in MultiGrid the main grid doesn't trigger a update on mount.\n        if (this._scrollingContainer.scrollLeft !== this.state.scrollLeft) {\n          this._scrollingContainer.scrollLeft = this.state.scrollLeft;\n        }\n\n        if (this._scrollingContainer.scrollTop !== this.state.scrollTop) {\n          this._scrollingContainer.scrollTop = this.state.scrollTop;\n        }\n      } // Don't update scroll offset if the size is 0; we don't render any cells in this case.\n      // Setting a state may cause us to later thing we've updated the offce when we haven't.\n\n\n      var sizeIsBiggerThanZero = height > 0 && width > 0;\n\n      if (scrollToColumn >= 0 && sizeIsBiggerThanZero) {\n        this._updateScrollLeftForScrollToColumn();\n      }\n\n      if (scrollToRow >= 0 && sizeIsBiggerThanZero) {\n        this._updateScrollTopForScrollToRow();\n      } // Update onRowsRendered callback\n\n\n      this._invokeOnGridRenderedHelper(); // Initialize onScroll callback\n\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalColumnsWidth: instanceProps.columnSizeAndPositionManager.getTotalSize(),\n        totalRowsHeight: instanceProps.rowSizeAndPositionManager.getTotalSize()\n      });\n\n      this._maybeCallOnScrollbarPresenceChange();\n    }\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) New scroll-to-cell props have been set\n     */\n\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this2 = this;\n\n      var _this$props5 = this.props,\n          autoHeight = _this$props5.autoHeight,\n          autoWidth = _this$props5.autoWidth,\n          columnCount = _this$props5.columnCount,\n          height = _this$props5.height,\n          rowCount = _this$props5.rowCount,\n          scrollToAlignment = _this$props5.scrollToAlignment,\n          scrollToColumn = _this$props5.scrollToColumn,\n          scrollToRow = _this$props5.scrollToRow,\n          width = _this$props5.width;\n      var _this$state = this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollPositionChangeReason = _this$state.scrollPositionChangeReason,\n          scrollTop = _this$state.scrollTop,\n          instanceProps = _this$state.instanceProps; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.\n      // We must do this at the start of the method as we may calculate and update scroll position below.\n\n      this._handleInvalidatedGridSize(); // Handle edge case where column or row count has only just increased over 0.\n      // In this case we may have to restore a previously-specified scroll offset.\n      // For more info see bvaughn/react-virtualized/issues/218\n\n\n      var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0; // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // 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).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        // @TRICKY :autoHeight and :autoWidth properties instructs Grid to leave :scrollTop and :scrollLeft management to an external HOC (eg WindowScroller).\n        // In this case we should avoid checking scrollingContainer.scrollTop and scrollingContainer.scrollLeft since it forces layout/flow.\n        if (!autoWidth && scrollLeft >= 0 && (scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n\n        if (!autoHeight && scrollTop >= 0 && (scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      } // Special case where the previous size was 0:\n      // In this case we don't show any windowed cells at all.\n      // So we should always recalculate offset afterwards.\n\n\n      var sizeJustIncreasedFromZero = (prevProps.width === 0 || prevProps.height === 0) && height > 0 && width > 0; // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it\n      // @TODO Do we also need this check or can the one in componentWillUpdate() suffice?\n\n      if (this._recomputeScrollLeftFlag) {\n        this._recomputeScrollLeftFlag = false;\n\n        this._updateScrollLeftForScrollToColumn(this.props);\n      } else {\n        updateScrollIndexHelper({\n          cellSizeAndPositionManager: instanceProps.columnSizeAndPositionManager,\n          previousCellsCount: prevProps.columnCount,\n          previousCellSize: prevProps.columnWidth,\n          previousScrollToAlignment: prevProps.scrollToAlignment,\n          previousScrollToIndex: prevProps.scrollToColumn,\n          previousSize: prevProps.width,\n          scrollOffset: scrollLeft,\n          scrollToAlignment: scrollToAlignment,\n          scrollToIndex: scrollToColumn,\n          size: width,\n          sizeJustIncreasedFromZero: sizeJustIncreasedFromZero,\n          updateScrollIndexCallback: function updateScrollIndexCallback() {\n            return _this2._updateScrollLeftForScrollToColumn(_this2.props);\n          }\n        });\n      }\n\n      if (this._recomputeScrollTopFlag) {\n        this._recomputeScrollTopFlag = false;\n\n        this._updateScrollTopForScrollToRow(this.props);\n      } else {\n        updateScrollIndexHelper({\n          cellSizeAndPositionManager: instanceProps.rowSizeAndPositionManager,\n          previousCellsCount: prevProps.rowCount,\n          previousCellSize: prevProps.rowHeight,\n          previousScrollToAlignment: prevProps.scrollToAlignment,\n          previousScrollToIndex: prevProps.scrollToRow,\n          previousSize: prevProps.height,\n          scrollOffset: scrollTop,\n          scrollToAlignment: scrollToAlignment,\n          scrollToIndex: scrollToRow,\n          size: height,\n          sizeJustIncreasedFromZero: sizeJustIncreasedFromZero,\n          updateScrollIndexCallback: function updateScrollIndexCallback() {\n            return _this2._updateScrollTopForScrollToRow(_this2.props);\n          }\n        });\n      } // Update onRowsRendered callback if start/stop indices have changed\n\n\n      this._invokeOnGridRenderedHelper(); // Changes to :scrollLeft or :scrollTop should also notify :onScroll listeners\n\n\n      if (scrollLeft !== prevState.scrollLeft || scrollTop !== prevState.scrollTop) {\n        var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n        var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n\n        this._invokeOnScrollMemoizer({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          totalColumnsWidth: totalColumnsWidth,\n          totalRowsHeight: totalRowsHeight\n        });\n      }\n\n      this._maybeCallOnScrollbarPresenceChange();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        cancelAnimationTimeout(this._disablePointerEventsTimeoutId);\n      }\n    }\n    /**\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props6 = this.props,\n          autoContainerWidth = _this$props6.autoContainerWidth,\n          autoHeight = _this$props6.autoHeight,\n          autoWidth = _this$props6.autoWidth,\n          className = _this$props6.className,\n          containerProps = _this$props6.containerProps,\n          containerRole = _this$props6.containerRole,\n          containerStyle = _this$props6.containerStyle,\n          height = _this$props6.height,\n          id = _this$props6.id,\n          noContentRenderer = _this$props6.noContentRenderer,\n          role = _this$props6.role,\n          style = _this$props6.style,\n          tabIndex = _this$props6.tabIndex,\n          width = _this$props6.width;\n      var _this$state2 = this.state,\n          instanceProps = _this$state2.instanceProps,\n          needToResetStyleCache = _this$state2.needToResetStyleCache;\n\n      var isScrolling = this._isScrolling();\n\n      var gridStyle = {\n        boxSizing: 'border-box',\n        direction: 'ltr',\n        height: autoHeight ? 'auto' : height,\n        position: 'relative',\n        width: autoWidth ? 'auto' : width,\n        WebkitOverflowScrolling: 'touch',\n        willChange: 'transform'\n      };\n\n      if (needToResetStyleCache) {\n        this._styleCache = {};\n      } // calculate _styleCache here\n      // if state.isScrolling (not from _isScrolling) then reset\n\n\n      if (!this.state.isScrolling) {\n        this._resetStyleCache();\n      } // calculate children to render here\n\n\n      this._calculateChildrenToRender(this.props, this.state);\n\n      var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize(); // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n\n      var verticalScrollBarSize = totalRowsHeight > height ? instanceProps.scrollbarSize : 0;\n      var horizontalScrollBarSize = totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;\n\n      if (horizontalScrollBarSize !== this._horizontalScrollBarSize || verticalScrollBarSize !== this._verticalScrollBarSize) {\n        this._horizontalScrollBarSize = horizontalScrollBarSize;\n        this._verticalScrollBarSize = verticalScrollBarSize;\n        this._scrollbarPresenceChanged = true;\n      } // Also explicitly init styles to 'auto' if scrollbars are required.\n      // This works around an obscure edge case where external CSS styles have not yet been loaded,\n      // But an initial scroll index of offset is set as an external prop.\n      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.\n      // This was originally reported via clauderic/react-infinite-calendar/issues/23\n\n\n      gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';\n      gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';\n      var childrenToDisplay = this._childrenToDisplay;\n      var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0;\n      return React.createElement(\"div\", _extends({\n        ref: this._setScrollingContainerRef\n      }, containerProps, {\n        \"aria-label\": this.props['aria-label'],\n        \"aria-readonly\": this.props['aria-readonly'],\n        className: clsx('ReactVirtualized__Grid', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: role,\n        style: _objectSpread({}, gridStyle, {}, style),\n        tabIndex: tabIndex\n      }), childrenToDisplay.length > 0 && React.createElement(\"div\", {\n        className: \"ReactVirtualized__Grid__innerScrollContainer\",\n        role: containerRole,\n        style: _objectSpread({\n          width: autoContainerWidth ? 'auto' : totalColumnsWidth,\n          height: totalRowsHeight,\n          maxWidth: totalColumnsWidth,\n          maxHeight: totalRowsHeight,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          position: 'relative'\n        }, containerStyle)\n      }, childrenToDisplay), showNoContentRenderer && noContentRenderer());\n    }\n    /* ---------------------------- Helper methods ---------------------------- */\n\n  }, {\n    key: \"_calculateChildrenToRender\",\n    value: function _calculateChildrenToRender() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      var cellRenderer = props.cellRenderer,\n          cellRangeRenderer = props.cellRangeRenderer,\n          columnCount = props.columnCount,\n          deferredMeasurementCache = props.deferredMeasurementCache,\n          height = props.height,\n          overscanColumnCount = props.overscanColumnCount,\n          overscanIndicesGetter = props.overscanIndicesGetter,\n          overscanRowCount = props.overscanRowCount,\n          rowCount = props.rowCount,\n          width = props.width,\n          isScrollingOptOut = props.isScrollingOptOut;\n      var scrollDirectionHorizontal = state.scrollDirectionHorizontal,\n          scrollDirectionVertical = state.scrollDirectionVertical,\n          instanceProps = state.instanceProps;\n      var scrollTop = this._initialScrollTop > 0 ? this._initialScrollTop : state.scrollTop;\n      var scrollLeft = this._initialScrollLeft > 0 ? this._initialScrollLeft : state.scrollLeft;\n\n      var isScrolling = this._isScrolling(props, state);\n\n      this._childrenToDisplay = []; // Render only enough columns and rows to cover the visible area of the grid.\n\n      if (height > 0 && width > 0) {\n        var visibleColumnIndices = instanceProps.columnSizeAndPositionManager.getVisibleCellRange({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var visibleRowIndices = instanceProps.rowSizeAndPositionManager.getVisibleCellRange({\n          containerSize: height,\n          offset: scrollTop\n        });\n        var horizontalOffsetAdjustment = instanceProps.columnSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var verticalOffsetAdjustment = instanceProps.rowSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: height,\n          offset: scrollTop\n        }); // Store for _invokeOnGridRenderedHelper()\n\n        this._renderedColumnStartIndex = visibleColumnIndices.start;\n        this._renderedColumnStopIndex = visibleColumnIndices.stop;\n        this._renderedRowStartIndex = visibleRowIndices.start;\n        this._renderedRowStopIndex = visibleRowIndices.stop;\n        var overscanColumnIndices = overscanIndicesGetter({\n          direction: 'horizontal',\n          cellCount: columnCount,\n          overscanCellsCount: overscanColumnCount,\n          scrollDirection: scrollDirectionHorizontal,\n          startIndex: typeof visibleColumnIndices.start === 'number' ? visibleColumnIndices.start : 0,\n          stopIndex: typeof visibleColumnIndices.stop === 'number' ? visibleColumnIndices.stop : -1\n        });\n        var overscanRowIndices = overscanIndicesGetter({\n          direction: 'vertical',\n          cellCount: rowCount,\n          overscanCellsCount: overscanRowCount,\n          scrollDirection: scrollDirectionVertical,\n          startIndex: typeof visibleRowIndices.start === 'number' ? visibleRowIndices.start : 0,\n          stopIndex: typeof visibleRowIndices.stop === 'number' ? visibleRowIndices.stop : -1\n        }); // Store for _invokeOnGridRenderedHelper()\n\n        var columnStartIndex = overscanColumnIndices.overscanStartIndex;\n        var columnStopIndex = overscanColumnIndices.overscanStopIndex;\n        var rowStartIndex = overscanRowIndices.overscanStartIndex;\n        var rowStopIndex = overscanRowIndices.overscanStopIndex; // Advanced use-cases (eg CellMeasurer) require batched measurements to determine accurate sizes.\n\n        if (deferredMeasurementCache) {\n          // If rows have a dynamic height, scan the rows we are about to render.\n          // If any have not yet been measured, then we need to render all columns initially,\n          // Because the height of the row is equal to the tallest cell within that row,\n          // (And so we can't know the height without measuring all column-cells first).\n          if (!deferredMeasurementCache.hasFixedHeight()) {\n            for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {\n              if (!deferredMeasurementCache.has(rowIndex, 0)) {\n                columnStartIndex = 0;\n                columnStopIndex = columnCount - 1;\n                break;\n              }\n            }\n          } // If columns have a dynamic width, scan the columns we are about to render.\n          // If any have not yet been measured, then we need to render all rows initially,\n          // Because the width of the column is equal to the widest cell within that column,\n          // (And so we can't know the width without measuring all row-cells first).\n\n\n          if (!deferredMeasurementCache.hasFixedWidth()) {\n            for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {\n              if (!deferredMeasurementCache.has(0, columnIndex)) {\n                rowStartIndex = 0;\n                rowStopIndex = rowCount - 1;\n                break;\n              }\n            }\n          }\n        }\n\n        this._childrenToDisplay = cellRangeRenderer({\n          cellCache: this._cellCache,\n          cellRenderer: cellRenderer,\n          columnSizeAndPositionManager: instanceProps.columnSizeAndPositionManager,\n          columnStartIndex: columnStartIndex,\n          columnStopIndex: columnStopIndex,\n          deferredMeasurementCache: deferredMeasurementCache,\n          horizontalOffsetAdjustment: horizontalOffsetAdjustment,\n          isScrolling: isScrolling,\n          isScrollingOptOut: isScrollingOptOut,\n          parent: this,\n          rowSizeAndPositionManager: instanceProps.rowSizeAndPositionManager,\n          rowStartIndex: rowStartIndex,\n          rowStopIndex: rowStopIndex,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          styleCache: this._styleCache,\n          verticalOffsetAdjustment: verticalOffsetAdjustment,\n          visibleColumnIndices: visibleColumnIndices,\n          visibleRowIndices: visibleRowIndices\n        }); // update the indices\n\n        this._columnStartIndex = columnStartIndex;\n        this._columnStopIndex = columnStopIndex;\n        this._rowStartIndex = rowStartIndex;\n        this._rowStopIndex = rowStopIndex;\n      }\n    }\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Grid.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: \"_debounceScrollEnded\",\n    value: function _debounceScrollEnded() {\n      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;\n\n      if (this._disablePointerEventsTimeoutId) {\n        cancelAnimationTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = requestAnimationTimeout(this._debounceScrollEndedCallback, scrollingResetTimeInterval);\n    }\n  }, {\n    key: \"_handleInvalidatedGridSize\",\n\n    /**\n     * Check for batched CellMeasurer size invalidations.\n     * This will occur the first time one or more previously unmeasured cells are rendered.\n     */\n    value: function _handleInvalidatedGridSize() {\n      if (typeof this._deferredInvalidateColumnIndex === 'number' && typeof this._deferredInvalidateRowIndex === 'number') {\n        var columnIndex = this._deferredInvalidateColumnIndex;\n        var rowIndex = this._deferredInvalidateRowIndex;\n        this._deferredInvalidateColumnIndex = null;\n        this._deferredInvalidateRowIndex = null;\n        this.recomputeGridSize({\n          columnIndex: columnIndex,\n          rowIndex: rowIndex\n        });\n      }\n    }\n  }, {\n    key: \"_invokeOnScrollMemoizer\",\n    value: function _invokeOnScrollMemoizer(_ref6) {\n      var _this3 = this;\n\n      var scrollLeft = _ref6.scrollLeft,\n          scrollTop = _ref6.scrollTop,\n          totalColumnsWidth = _ref6.totalColumnsWidth,\n          totalRowsHeight = _ref6.totalRowsHeight;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref7) {\n          var scrollLeft = _ref7.scrollLeft,\n              scrollTop = _ref7.scrollTop;\n          var _this3$props = _this3.props,\n              height = _this3$props.height,\n              onScroll = _this3$props.onScroll,\n              width = _this3$props.width;\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalRowsHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalColumnsWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n  }, {\n    key: \"_isScrolling\",\n    value: function _isScrolling() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      // If isScrolling is defined in props, use it to override the value in state\n      // This is a performance optimization for WindowScroller + Grid\n      return Object.hasOwnProperty.call(props, 'isScrolling') ? Boolean(props.isScrolling) : Boolean(state.isScrolling);\n    }\n  }, {\n    key: \"_maybeCallOnScrollbarPresenceChange\",\n    value: function _maybeCallOnScrollbarPresenceChange() {\n      if (this._scrollbarPresenceChanged) {\n        var onScrollbarPresenceChange = this.props.onScrollbarPresenceChange;\n        this._scrollbarPresenceChanged = false;\n        onScrollbarPresenceChange({\n          horizontal: this._horizontalScrollBarSize > 0,\n          size: this.state.instanceProps.scrollbarSize,\n          vertical: this._verticalScrollBarSize > 0\n        });\n      }\n    }\n  }, {\n    key: \"scrollToPosition\",\n\n    /**\n     * Scroll to the specified offset(s).\n     * Useful for animating position changes.\n     */\n    value: function scrollToPosition(_ref8) {\n      var scrollLeft = _ref8.scrollLeft,\n          scrollTop = _ref8.scrollTop;\n\n      var stateUpdate = Grid._getScrollToPositionStateUpdate({\n        prevState: this.state,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      });\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }, {\n    key: \"_getCalculatedScrollLeft\",\n    value: function _getCalculatedScrollLeft() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      return Grid._getCalculatedScrollLeft(props, state);\n    }\n  }, {\n    key: \"_updateScrollLeftForScrollToColumn\",\n    value: function _updateScrollLeftForScrollToColumn() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n\n      var stateUpdate = Grid._getScrollLeftForScrollToColumnStateUpdate(props, state);\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }, {\n    key: \"_getCalculatedScrollTop\",\n    value: function _getCalculatedScrollTop() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      return Grid._getCalculatedScrollTop(props, state);\n    }\n  }, {\n    key: \"_resetStyleCache\",\n    value: function _resetStyleCache() {\n      var styleCache = this._styleCache;\n      var cellCache = this._cellCache;\n      var isScrollingOptOut = this.props.isScrollingOptOut; // Reset cell and style caches once scrolling stops.\n      // This makes Grid simpler to use (since cells commonly change).\n      // And it keeps the caches from growing too large.\n      // Performance is most sensitive when a user is scrolling.\n      // Don't clear visible cells from cellCache if isScrollingOptOut is specified.\n      // This keeps the cellCache to a resonable size.\n\n      this._cellCache = {};\n      this._styleCache = {}; // Copy over the visible cell styles so avoid unnecessary re-render.\n\n      for (var rowIndex = this._rowStartIndex; rowIndex <= this._rowStopIndex; rowIndex++) {\n        for (var columnIndex = this._columnStartIndex; columnIndex <= this._columnStopIndex; columnIndex++) {\n          var key = \"\".concat(rowIndex, \"-\").concat(columnIndex);\n          this._styleCache[key] = styleCache[key];\n\n          if (isScrollingOptOut) {\n            this._cellCache[key] = cellCache[key];\n          }\n        }\n      }\n    }\n  }, {\n    key: \"_updateScrollTopForScrollToRow\",\n    value: function _updateScrollTopForScrollToRow() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n\n      var stateUpdate = Grid._getScrollTopForScrollToRowStateUpdate(props, state);\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      var newState = {};\n\n      if (nextProps.columnCount === 0 && prevState.scrollLeft !== 0 || nextProps.rowCount === 0 && prevState.scrollTop !== 0) {\n        newState.scrollLeft = 0;\n        newState.scrollTop = 0; // only use scroll{Left,Top} from props if scrollTo{Column,Row} isn't specified\n        // scrollTo{Column,Row} should override scroll{Left,Top}\n      } else if (nextProps.scrollLeft !== prevState.scrollLeft && nextProps.scrollToColumn < 0 || nextProps.scrollTop !== prevState.scrollTop && nextProps.scrollToRow < 0) {\n        Object.assign(newState, Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: nextProps.scrollLeft,\n          scrollTop: nextProps.scrollTop\n        }));\n      }\n\n      var instanceProps = prevState.instanceProps; // Initially we should not clearStyleCache\n\n      newState.needToResetStyleCache = false;\n\n      if (nextProps.columnWidth !== instanceProps.prevColumnWidth || nextProps.rowHeight !== instanceProps.prevRowHeight) {\n        // Reset cache. set it to {} in render\n        newState.needToResetStyleCache = true;\n      }\n\n      instanceProps.columnSizeAndPositionManager.configure({\n        cellCount: nextProps.columnCount,\n        estimatedCellSize: Grid._getEstimatedColumnSize(nextProps),\n        cellSizeGetter: Grid._wrapSizeGetter(nextProps.columnWidth)\n      });\n      instanceProps.rowSizeAndPositionManager.configure({\n        cellCount: nextProps.rowCount,\n        estimatedCellSize: Grid._getEstimatedRowSize(nextProps),\n        cellSizeGetter: Grid._wrapSizeGetter(nextProps.rowHeight)\n      });\n\n      if (instanceProps.prevColumnCount === 0 || instanceProps.prevRowCount === 0) {\n        instanceProps.prevColumnCount = 0;\n        instanceProps.prevRowCount = 0;\n      } // If scrolling is controlled outside this component, clear cache when scrolling stops\n\n\n      if (nextProps.autoHeight && nextProps.isScrolling === false && instanceProps.prevIsScrolling === true) {\n        Object.assign(newState, {\n          isScrolling: false\n        });\n      }\n\n      var maybeStateA;\n      var maybeStateB;\n      calculateSizeAndPositionDataAndUpdateScrollOffset({\n        cellCount: instanceProps.prevColumnCount,\n        cellSize: typeof instanceProps.prevColumnWidth === 'number' ? instanceProps.prevColumnWidth : null,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return instanceProps.columnSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.columnCount,\n        nextCellSize: typeof nextProps.columnWidth === 'number' ? nextProps.columnWidth : null,\n        nextScrollToIndex: nextProps.scrollToColumn,\n        scrollToIndex: instanceProps.prevScrollToColumn,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          maybeStateA = Grid._getScrollLeftForScrollToColumnStateUpdate(nextProps, prevState);\n        }\n      });\n      calculateSizeAndPositionDataAndUpdateScrollOffset({\n        cellCount: instanceProps.prevRowCount,\n        cellSize: typeof instanceProps.prevRowHeight === 'number' ? instanceProps.prevRowHeight : null,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return instanceProps.rowSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.rowCount,\n        nextCellSize: typeof nextProps.rowHeight === 'number' ? nextProps.rowHeight : null,\n        nextScrollToIndex: nextProps.scrollToRow,\n        scrollToIndex: instanceProps.prevScrollToRow,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          maybeStateB = Grid._getScrollTopForScrollToRowStateUpdate(nextProps, prevState);\n        }\n      });\n      instanceProps.prevColumnCount = nextProps.columnCount;\n      instanceProps.prevColumnWidth = nextProps.columnWidth;\n      instanceProps.prevIsScrolling = nextProps.isScrolling === true;\n      instanceProps.prevRowCount = nextProps.rowCount;\n      instanceProps.prevRowHeight = nextProps.rowHeight;\n      instanceProps.prevScrollToColumn = nextProps.scrollToColumn;\n      instanceProps.prevScrollToRow = nextProps.scrollToRow; // getting scrollBarSize (moved from componentWillMount)\n\n      instanceProps.scrollbarSize = nextProps.getScrollbarSize();\n\n      if (instanceProps.scrollbarSize === undefined) {\n        instanceProps.scrollbarSizeMeasured = false;\n        instanceProps.scrollbarSize = 0;\n      } else {\n        instanceProps.scrollbarSizeMeasured = true;\n      }\n\n      newState.instanceProps = instanceProps;\n      return _objectSpread({}, newState, {}, maybeStateA, {}, maybeStateB);\n    }\n  }, {\n    key: \"_getEstimatedColumnSize\",\n    value: function _getEstimatedColumnSize(props) {\n      return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize;\n    }\n  }, {\n    key: \"_getEstimatedRowSize\",\n    value: function _getEstimatedRowSize(props) {\n      return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize;\n    }\n  }, {\n    key: \"_getScrollToPositionStateUpdate\",\n\n    /**\n     * Get the updated state after scrolling to\n     * scrollLeft and scrollTop\n     */\n    value: function _getScrollToPositionStateUpdate(_ref9) {\n      var prevState = _ref9.prevState,\n          scrollLeft = _ref9.scrollLeft,\n          scrollTop = _ref9.scrollTop;\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0) {\n        newState.scrollDirectionHorizontal = scrollLeft > prevState.scrollLeft ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD;\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (typeof scrollTop === 'number' && scrollTop >= 0) {\n        newState.scrollDirectionVertical = scrollTop > prevState.scrollTop ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD;\n        newState.scrollTop = scrollTop;\n      }\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft || typeof scrollTop === 'number' && scrollTop >= 0 && scrollTop !== prevState.scrollTop) {\n        return newState;\n      }\n\n      return {};\n    }\n  }, {\n    key: \"_wrapSizeGetter\",\n    value: function _wrapSizeGetter(value) {\n      return typeof value === 'function' ? value : function () {\n        return value;\n      };\n    }\n  }, {\n    key: \"_getCalculatedScrollLeft\",\n    value: function _getCalculatedScrollLeft(nextProps, prevState) {\n      var columnCount = nextProps.columnCount,\n          height = nextProps.height,\n          scrollToAlignment = nextProps.scrollToAlignment,\n          scrollToColumn = nextProps.scrollToColumn,\n          width = nextProps.width;\n      var scrollLeft = prevState.scrollLeft,\n          instanceProps = prevState.instanceProps;\n\n      if (columnCount > 0) {\n        var finalColumn = columnCount - 1;\n        var targetIndex = scrollToColumn < 0 ? finalColumn : Math.min(finalColumn, scrollToColumn);\n        var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n        var scrollBarSize = instanceProps.scrollbarSizeMeasured && totalRowsHeight > height ? instanceProps.scrollbarSize : 0;\n        return instanceProps.columnSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: width - scrollBarSize,\n          currentOffset: scrollLeft,\n          targetIndex: targetIndex\n        });\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"_getScrollLeftForScrollToColumnStateUpdate\",\n    value: function _getScrollLeftForScrollToColumnStateUpdate(nextProps, prevState) {\n      var scrollLeft = prevState.scrollLeft;\n\n      var calculatedScrollLeft = Grid._getCalculatedScrollLeft(nextProps, prevState);\n\n      if (typeof calculatedScrollLeft === 'number' && calculatedScrollLeft >= 0 && scrollLeft !== calculatedScrollLeft) {\n        return Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: calculatedScrollLeft,\n          scrollTop: -1\n        });\n      }\n\n      return {};\n    }\n  }, {\n    key: \"_getCalculatedScrollTop\",\n    value: function _getCalculatedScrollTop(nextProps, prevState) {\n      var height = nextProps.height,\n          rowCount = nextProps.rowCount,\n          scrollToAlignment = nextProps.scrollToAlignment,\n          scrollToRow = nextProps.scrollToRow,\n          width = nextProps.width;\n      var scrollTop = prevState.scrollTop,\n          instanceProps = prevState.instanceProps;\n\n      if (rowCount > 0) {\n        var finalRow = rowCount - 1;\n        var targetIndex = scrollToRow < 0 ? finalRow : Math.min(finalRow, scrollToRow);\n        var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n        var scrollBarSize = instanceProps.scrollbarSizeMeasured && totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;\n        return instanceProps.rowSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: height - scrollBarSize,\n          currentOffset: scrollTop,\n          targetIndex: targetIndex\n        });\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"_getScrollTopForScrollToRowStateUpdate\",\n    value: function _getScrollTopForScrollToRowStateUpdate(nextProps, prevState) {\n      var scrollTop = prevState.scrollTop;\n\n      var calculatedScrollTop = Grid._getCalculatedScrollTop(nextProps, prevState);\n\n      if (typeof calculatedScrollTop === 'number' && calculatedScrollTop >= 0 && scrollTop !== calculatedScrollTop) {\n        return Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: -1,\n          scrollTop: calculatedScrollTop\n        });\n      }\n\n      return {};\n    }\n  }]);\n\n  return Grid;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": PropTypes.string.isRequired,\n  \"aria-readonly\": PropTypes.bool,\n\n  /**\n   * Set the width of the inner scrollable container to 'auto'.\n   * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar.\n   */\n  \"autoContainerWidth\": PropTypes.bool.isRequired,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height of rows can stretch the window.\n   * Intended for use with WindowScroller\n   */\n  \"autoHeight\": PropTypes.bool.isRequired,\n\n  /**\n   * Removes fixed width from the scrollingContainer so that the total width of rows can stretch the window.\n   * Intended for use with WindowScroller\n   */\n  \"autoWidth\": PropTypes.bool.isRequired,\n\n  /** Responsible for rendering a cell given an row and column index.  */\n  \"cellRenderer\": function cellRenderer() {\n    return (typeof bpfrpt_proptype_CellRenderer === \"function\" ? bpfrpt_proptype_CellRenderer.isRequired ? bpfrpt_proptype_CellRenderer.isRequired : bpfrpt_proptype_CellRenderer : PropTypes.shape(bpfrpt_proptype_CellRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Responsible for rendering a group of cells given their index ranges.  */\n  \"cellRangeRenderer\": function cellRangeRenderer() {\n    return (typeof bpfrpt_proptype_CellRangeRenderer === \"function\" ? bpfrpt_proptype_CellRangeRenderer.isRequired ? bpfrpt_proptype_CellRangeRenderer.isRequired : bpfrpt_proptype_CellRangeRenderer : PropTypes.shape(bpfrpt_proptype_CellRangeRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Optional custom CSS class name to attach to root Grid element.  */\n  \"className\": PropTypes.string,\n\n  /** Number of columns in grid.  */\n  \"columnCount\": PropTypes.number.isRequired,\n\n  /** Either a fixed column width (number) or a function that returns the width of a column given its index.  */\n  \"columnWidth\": function columnWidth() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Unfiltered props for the Grid container. */\n  \"containerProps\": PropTypes.object,\n\n  /** ARIA role for the cell-container.  */\n  \"containerRole\": PropTypes.string.isRequired,\n\n  /** Optional inline style applied to inner cell-container */\n  \"containerStyle\": PropTypes.object.isRequired,\n\n  /**\n   * If CellMeasurer is used to measure this Grid's children, this should be a pointer to its CellMeasurerCache.\n   * A shared CellMeasurerCache reference enables Grid and CellMeasurer to share measurement data.\n   */\n  \"deferredMeasurementCache\": PropTypes.object,\n\n  /**\n   * Used to estimate the total width of a Grid before all of its columns have actually been measured.\n   * The estimated total width is adjusted as columns are rendered.\n   */\n  \"estimatedColumnSize\": PropTypes.number.isRequired,\n\n  /**\n   * Used to estimate the total height of a Grid before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  \"estimatedRowSize\": PropTypes.number.isRequired,\n\n  /** Exposed for testing purposes only.  */\n  \"getScrollbarSize\": PropTypes.func.isRequired,\n\n  /** Height of Grid; this property determines the number of visible (vs virtualized) rows.  */\n  \"height\": PropTypes.number.isRequired,\n\n  /** Optional custom id to attach to root Grid element.  */\n  \"id\": PropTypes.string,\n\n  /**\n   * Override internal is-scrolling state tracking.\n   * This property is primarily intended for use with the WindowScroller component.\n   */\n  \"isScrolling\": PropTypes.bool,\n\n  /**\n   * Opt-out of isScrolling param passed to cellRangeRenderer.\n   * To avoid the extra render when scroll stops.\n   */\n  \"isScrollingOptOut\": PropTypes.bool.isRequired,\n\n  /** Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0.  */\n  \"noContentRenderer\": function noContentRenderer() {\n    return (typeof bpfrpt_proptype_NoContentRenderer === \"function\" ? bpfrpt_proptype_NoContentRenderer.isRequired ? bpfrpt_proptype_NoContentRenderer.isRequired : bpfrpt_proptype_NoContentRenderer : PropTypes.shape(bpfrpt_proptype_NoContentRenderer).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /**\n   * Called whenever a horizontal or vertical scrollbar is added or removed.\n   * This prop is not intended for end-user use;\n   * It is used by MultiGrid to support fixed-row/fixed-column scroll syncing.\n   */\n  \"onScrollbarPresenceChange\": PropTypes.func.isRequired,\n\n  /** Callback invoked with information about the section of the Grid that was just rendered.  */\n  \"onSectionRendered\": PropTypes.func.isRequired,\n\n  /**\n   * Number of columns to render before/after the visible section of the grid.\n   * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  \"overscanColumnCount\": PropTypes.number.isRequired,\n\n  /**\n   * Calculates the number of cells to overscan before and after a specified range.\n   * This function ensures that overscanning doesn't exceed the available cells.\n   */\n  \"overscanIndicesGetter\": function overscanIndicesGetter() {\n    return (typeof bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? bpfrpt_proptype_OverscanIndicesGetter.isRequired ? bpfrpt_proptype_OverscanIndicesGetter.isRequired : bpfrpt_proptype_OverscanIndicesGetter : PropTypes.shape(bpfrpt_proptype_OverscanIndicesGetter).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Number of rows to render above/below the visible section of the grid.\n   * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  \"overscanRowCount\": PropTypes.number.isRequired,\n\n  /** ARIA role for the grid element.  */\n  \"role\": PropTypes.string.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * Should implement the following interface: ({ index: number }): number\n   */\n  \"rowHeight\": function rowHeight() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in grid.  */\n  \"rowCount\": PropTypes.number.isRequired,\n\n  /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n\n  /** Horizontal offset. */\n  \"scrollLeft\": PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  \"scrollToAlignment\": function scrollToAlignment() {\n    return (typeof bpfrpt_proptype_Alignment === \"function\" ? bpfrpt_proptype_Alignment.isRequired ? bpfrpt_proptype_Alignment.isRequired : bpfrpt_proptype_Alignment : PropTypes.shape(bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Column index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToColumn\": PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": PropTypes.number,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToRow\": PropTypes.number.isRequired,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": PropTypes.number,\n\n  /** Width of Grid; this property determines the number of visible (vs virtualized) columns.  */\n  \"width\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(Grid, \"defaultProps\", {\n  'aria-label': 'grid',\n  'aria-readonly': true,\n  autoContainerWidth: false,\n  autoHeight: false,\n  autoWidth: false,\n  cellRangeRenderer: defaultCellRangeRenderer,\n  containerRole: 'rowgroup',\n  containerStyle: {},\n  estimatedColumnSize: 100,\n  estimatedRowSize: 30,\n  getScrollbarSize: scrollbarSize,\n  noContentRenderer: renderNull,\n  onScroll: function onScroll() {},\n  onScrollbarPresenceChange: function onScrollbarPresenceChange() {},\n  onSectionRendered: function onSectionRendered() {},\n  overscanColumnCount: 0,\n  overscanIndicesGetter: defaultOverscanIndicesGetter,\n  overscanRowCount: 10,\n  role: 'grid',\n  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,\n  scrollToAlignment: 'auto',\n  scrollToColumn: -1,\n  scrollToRow: -1,\n  style: {},\n  tabIndex: 0,\n  isScrollingOptOut: false\n});\n\npolyfill(Grid);\nexport default Grid;\nimport { bpfrpt_proptype_CellRenderer } from \"./types\";\nimport { bpfrpt_proptype_CellRangeRenderer } from \"./types\";\nimport { bpfrpt_proptype_CellPosition } from \"./types\";\nimport { bpfrpt_proptype_CellSize } from \"./types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"./types\";\nimport { bpfrpt_proptype_NoContentRenderer } from \"./types\";\nimport { bpfrpt_proptype_Scroll } from \"./types\";\nimport { bpfrpt_proptype_ScrollbarPresenceChange } from \"./types\";\nimport { bpfrpt_proptype_RenderedSection } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndicesGetter } from \"./types\";\nimport { bpfrpt_proptype_Alignment } from \"./types\";\nimport { bpfrpt_proptype_CellCache } from \"./types\";\nimport { bpfrpt_proptype_StyleCache } from \"./types\";\nimport { bpfrpt_proptype_AnimationTimeoutId } from \"../utils/requestAnimationTimeout\";\nimport PropTypes from \"prop-types\";","import { caf, raf } from './animationFrame';\nvar bpfrpt_proptype_AnimationTimeoutId = process.env.NODE_ENV === 'production' ? null : {\n  \"id\": PropTypes.number.isRequired\n};\nexport var cancelAnimationTimeout = function cancelAnimationTimeout(frame) {\n  return caf(frame.id);\n};\n/**\n * Recursively calls requestAnimationFrame until a specified delay has been met or exceeded.\n * When the delay time has been reached the function you're timing out will be called.\n *\n * Credit: Joe Lambert (https://gist.github.com/joelambert/1002116#file-requesttimeout-js)\n */\n\nexport var requestAnimationTimeout = function requestAnimationTimeout(callback, delay) {\n  var start; // wait for end of processing current event handler, because event handler may be long\n\n  Promise.resolve().then(function () {\n    start = Date.now();\n  });\n\n  var timeout = function timeout() {\n    if (Date.now() - start >= delay) {\n      callback.call();\n    } else {\n      frame.id = raf(timeout);\n    }\n  };\n\n  var frame = {\n    id: raf(timeout)\n  };\n  return frame;\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_AnimationTimeoutId };","export var SCROLL_DIRECTION_BACKWARD = -1;\nexport var SCROLL_DIRECTION_FORWARD = 1;\nexport var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexport var SCROLL_DIRECTION_VERTICAL = 'vertical';\n/**\n * Calculates the number of cells to overscan before and after a specified range.\n * This function ensures that overscanning doesn't exceed the available cells.\n */\n\nexport default function defaultOverscanIndicesGetter(_ref) {\n  var cellCount = _ref.cellCount,\n      overscanCellsCount = _ref.overscanCellsCount,\n      scrollDirection = _ref.scrollDirection,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n\n  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {\n    return {\n      overscanStartIndex: Math.max(0, startIndex),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)\n    };\n  } else {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex)\n    };\n  }\n}\nimport { bpfrpt_proptype_OverscanIndicesGetterParams } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndices } from \"./types\";","/**\n * Default implementation of cellRangeRenderer used by Grid.\n * This renderer supports cell-caching while the user is scrolling.\n */\nexport default function defaultCellRangeRenderer(_ref) {\n  var cellCache = _ref.cellCache,\n      cellRenderer = _ref.cellRenderer,\n      columnSizeAndPositionManager = _ref.columnSizeAndPositionManager,\n      columnStartIndex = _ref.columnStartIndex,\n      columnStopIndex = _ref.columnStopIndex,\n      deferredMeasurementCache = _ref.deferredMeasurementCache,\n      horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment,\n      isScrolling = _ref.isScrolling,\n      isScrollingOptOut = _ref.isScrollingOptOut,\n      parent = _ref.parent,\n      rowSizeAndPositionManager = _ref.rowSizeAndPositionManager,\n      rowStartIndex = _ref.rowStartIndex,\n      rowStopIndex = _ref.rowStopIndex,\n      styleCache = _ref.styleCache,\n      verticalOffsetAdjustment = _ref.verticalOffsetAdjustment,\n      visibleColumnIndices = _ref.visibleColumnIndices,\n      visibleRowIndices = _ref.visibleRowIndices;\n  var renderedCells = []; // Browsers have native size limits for elements (eg Chrome 33M pixels, IE 1.5M pixes).\n  // User cannot scroll beyond these size limitations.\n  // In order to work around this, ScalingCellSizeAndPositionManager compresses offsets.\n  // We should never cache styles for compressed offsets though as this can lead to bugs.\n  // See issue #576 for more.\n\n  var areOffsetsAdjusted = columnSizeAndPositionManager.areOffsetsAdjusted() || rowSizeAndPositionManager.areOffsetsAdjusted();\n  var canCacheStyle = !isScrolling && !areOffsetsAdjusted;\n\n  for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {\n    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);\n\n    for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {\n      var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);\n      var isVisible = columnIndex >= visibleColumnIndices.start && columnIndex <= visibleColumnIndices.stop && rowIndex >= visibleRowIndices.start && rowIndex <= visibleRowIndices.stop;\n      var key = \"\".concat(rowIndex, \"-\").concat(columnIndex);\n      var style = void 0; // Cache style objects so shallow-compare doesn't re-render unnecessarily.\n\n      if (canCacheStyle && styleCache[key]) {\n        style = styleCache[key];\n      } else {\n        // In deferred mode, cells will be initially rendered before we know their size.\n        // Don't interfere with CellMeasurer's measurements by setting an invalid size.\n        if (deferredMeasurementCache && !deferredMeasurementCache.has(rowIndex, columnIndex)) {\n          // Position not-yet-measured cells at top/left 0,0,\n          // And give them width/height of 'auto' so they can grow larger than the parent Grid if necessary.\n          // Positioning them further to the right/bottom influences their measured size.\n          style = {\n            height: 'auto',\n            left: 0,\n            position: 'absolute',\n            top: 0,\n            width: 'auto'\n          };\n        } else {\n          style = {\n            height: rowDatum.size,\n            left: columnDatum.offset + horizontalOffsetAdjustment,\n            position: 'absolute',\n            top: rowDatum.offset + verticalOffsetAdjustment,\n            width: columnDatum.size\n          };\n          styleCache[key] = style;\n        }\n      }\n\n      var cellRendererParams = {\n        columnIndex: columnIndex,\n        isScrolling: isScrolling,\n        isVisible: isVisible,\n        key: key,\n        parent: parent,\n        rowIndex: rowIndex,\n        style: style\n      };\n      var renderedCell = void 0; // Avoid re-creating cells while scrolling.\n      // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n      // If a scroll is in progress- cache and reuse cells.\n      // This cache will be thrown away once scrolling completes.\n      // However if we are scaling scroll positions and sizes, we should also avoid caching.\n      // This is because the offset changes slightly as scroll position changes and caching leads to stale values.\n      // For more info refer to issue #395\n      //\n      // If isScrollingOptOut is specified, we always cache cells.\n      // For more info refer to issue #1028\n\n      if ((isScrollingOptOut || isScrolling) && !horizontalOffsetAdjustment && !verticalOffsetAdjustment) {\n        if (!cellCache[key]) {\n          cellCache[key] = cellRenderer(cellRendererParams);\n        }\n\n        renderedCell = cellCache[key]; // If the user is no longer scrolling, don't cache cells.\n        // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.\n      } else {\n        renderedCell = cellRenderer(cellRendererParams);\n      }\n\n      if (renderedCell == null || renderedCell === false) {\n        continue;\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        warnAboutMissingStyle(parent, renderedCell);\n      }\n\n      renderedCells.push(renderedCell);\n    }\n  }\n\n  return renderedCells;\n}\n\nfunction warnAboutMissingStyle(parent, renderedCell) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (renderedCell) {\n      // If the direct child is a CellMeasurer, then we should check its child\n      // See issue #611\n      if (renderedCell.type && renderedCell.type.__internalCellMeasurerFlag) {\n        renderedCell = renderedCell.props.children;\n      }\n\n      if (renderedCell && renderedCell.props && renderedCell.props.style === undefined && parent.__warnedAboutMissingStyle !== true) {\n        parent.__warnedAboutMissingStyle = true;\n        console.warn('Rendered cell should include style property for positioning.');\n      }\n    }\n  }\n}\n\nimport { bpfrpt_proptype_CellRangeRendererParams } from \"./types\";","export var SCROLL_DIRECTION_BACKWARD = -1;\nexport var SCROLL_DIRECTION_FORWARD = 1;\nexport var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexport var SCROLL_DIRECTION_VERTICAL = 'vertical';\n/**\n * Calculates the number of cells to overscan before and after a specified range.\n * This function ensures that overscanning doesn't exceed the available cells.\n */\n\nexport default function defaultOverscanIndicesGetter(_ref) {\n  var cellCount = _ref.cellCount,\n      overscanCellsCount = _ref.overscanCellsCount,\n      scrollDirection = _ref.scrollDirection,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n  // Make sure we render at least 1 cell extra before and after (except near boundaries)\n  // This is necessary in order to support keyboard navigation (TAB/SHIFT+TAB) in some cases\n  // For more info see issues #625\n  overscanCellsCount = Math.max(1, overscanCellsCount);\n\n  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - 1),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)\n    };\n  } else {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + 1)\n    };\n  }\n}\nimport { bpfrpt_proptype_OverscanIndicesGetterParams } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndices } from \"./types\";","var bpfrpt_proptype_ScrollIndices = process.env.NODE_ENV === 'production' ? null : {\n  \"scrollToColumn\": PropTypes.number.isRequired,\n  \"scrollToRow\": PropTypes.number.isRequired\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_ScrollIndices };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\n/**\n * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.\n */\n\nvar ArrowKeyStepper = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ArrowKeyStepper, _React$PureComponent);\n\n  function ArrowKeyStepper() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, ArrowKeyStepper);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ArrowKeyStepper)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      scrollToColumn: 0,\n      scrollToRow: 0,\n      instanceProps: {\n        prevScrollToColumn: 0,\n        prevScrollToRow: 0\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onKeyDown\", function (event) {\n      var _this$props = _this.props,\n          columnCount = _this$props.columnCount,\n          disabled = _this$props.disabled,\n          mode = _this$props.mode,\n          rowCount = _this$props.rowCount;\n\n      if (disabled) {\n        return;\n      }\n\n      var _this$_getScrollState = _this._getScrollState(),\n          scrollToColumnPrevious = _this$_getScrollState.scrollToColumn,\n          scrollToRowPrevious = _this$_getScrollState.scrollToRow;\n\n      var _this$_getScrollState2 = _this._getScrollState(),\n          scrollToColumn = _this$_getScrollState2.scrollToColumn,\n          scrollToRow = _this$_getScrollState2.scrollToRow; // The above cases all prevent default event event behavior.\n      // This is to keep the grid from scrolling after the snap-to update.\n\n\n      switch (event.key) {\n        case 'ArrowDown':\n          scrollToRow = mode === 'cells' ? Math.min(scrollToRow + 1, rowCount - 1) : Math.min(_this._rowStopIndex + 1, rowCount - 1);\n          break;\n\n        case 'ArrowLeft':\n          scrollToColumn = mode === 'cells' ? Math.max(scrollToColumn - 1, 0) : Math.max(_this._columnStartIndex - 1, 0);\n          break;\n\n        case 'ArrowRight':\n          scrollToColumn = mode === 'cells' ? Math.min(scrollToColumn + 1, columnCount - 1) : Math.min(_this._columnStopIndex + 1, columnCount - 1);\n          break;\n\n        case 'ArrowUp':\n          scrollToRow = mode === 'cells' ? Math.max(scrollToRow - 1, 0) : Math.max(_this._rowStartIndex - 1, 0);\n          break;\n      }\n\n      if (scrollToColumn !== scrollToColumnPrevious || scrollToRow !== scrollToRowPrevious) {\n        event.preventDefault();\n\n        _this._updateScrollState({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRendered\", function (_ref) {\n      var columnStartIndex = _ref.columnStartIndex,\n          columnStopIndex = _ref.columnStopIndex,\n          rowStartIndex = _ref.rowStartIndex,\n          rowStopIndex = _ref.rowStopIndex;\n      _this._columnStartIndex = columnStartIndex;\n      _this._columnStopIndex = columnStopIndex;\n      _this._rowStartIndex = rowStartIndex;\n      _this._rowStopIndex = rowStopIndex;\n    });\n\n    return _this;\n  }\n\n  _createClass(ArrowKeyStepper, [{\n    key: \"setScrollIndexes\",\n    value: function setScrollIndexes(_ref2) {\n      var scrollToColumn = _ref2.scrollToColumn,\n          scrollToRow = _ref2.scrollToRow;\n      this.setState({\n        scrollToRow: scrollToRow,\n        scrollToColumn: scrollToColumn\n      });\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          className = _this$props2.className,\n          children = _this$props2.children;\n\n      var _this$_getScrollState3 = this._getScrollState(),\n          scrollToColumn = _this$_getScrollState3.scrollToColumn,\n          scrollToRow = _this$_getScrollState3.scrollToRow;\n\n      return React.createElement(\"div\", {\n        className: className,\n        onKeyDown: this._onKeyDown\n      }, children({\n        onSectionRendered: this._onSectionRendered,\n        scrollToColumn: scrollToColumn,\n        scrollToRow: scrollToRow\n      }));\n    }\n  }, {\n    key: \"_getScrollState\",\n    value: function _getScrollState() {\n      return this.props.isControlled ? this.props : this.state;\n    }\n  }, {\n    key: \"_updateScrollState\",\n    value: function _updateScrollState(_ref3) {\n      var scrollToColumn = _ref3.scrollToColumn,\n          scrollToRow = _ref3.scrollToRow;\n      var _this$props3 = this.props,\n          isControlled = _this$props3.isControlled,\n          onScrollToChange = _this$props3.onScrollToChange;\n\n      if (typeof onScrollToChange === 'function') {\n        onScrollToChange({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n\n      if (!isControlled) {\n        this.setState({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.isControlled) {\n        return {};\n      }\n\n      if (nextProps.scrollToColumn !== prevState.instanceProps.prevScrollToColumn || nextProps.scrollToRow !== prevState.instanceProps.prevScrollToRow) {\n        return _objectSpread({}, prevState, {\n          scrollToColumn: nextProps.scrollToColumn,\n          scrollToRow: nextProps.scrollToRow,\n          instanceProps: {\n            prevScrollToColumn: nextProps.scrollToColumn,\n            prevScrollToRow: nextProps.scrollToRow\n          }\n        });\n      }\n\n      return {};\n    }\n  }]);\n\n  return ArrowKeyStepper;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"children\": PropTypes.func.isRequired,\n  \"className\": PropTypes.string,\n  \"columnCount\": PropTypes.number.isRequired,\n  \"disabled\": PropTypes.bool.isRequired,\n  \"isControlled\": PropTypes.bool.isRequired,\n  \"mode\": PropTypes.oneOf([\"cells\", \"edges\"]).isRequired,\n  \"onScrollToChange\": PropTypes.func,\n  \"rowCount\": PropTypes.number.isRequired,\n  \"scrollToColumn\": PropTypes.number.isRequired,\n  \"scrollToRow\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(ArrowKeyStepper, \"defaultProps\", {\n  disabled: false,\n  isControlled: false,\n  mode: 'edges',\n  scrollToColumn: 0,\n  scrollToRow: 0\n});\n\npolyfill(ArrowKeyStepper);\nexport default ArrowKeyStepper;\nimport { bpfrpt_proptype_RenderedSection } from \"../Grid\";\nimport { bpfrpt_proptype_ScrollIndices } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport createDetectElementResize from '../vendor/detectElementResize';\nvar AutoSizer = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inherits(AutoSizer, _React$Component);\n\n  function AutoSizer() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, AutoSizer);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AutoSizer)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      height: _this.props.defaultHeight || 0,\n      width: _this.props.defaultWidth || 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_parentNode\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_autoSizer\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_window\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_detectElementResize\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onResize\", function () {\n      var _this$props = _this.props,\n          disableHeight = _this$props.disableHeight,\n          disableWidth = _this$props.disableWidth,\n          onResize = _this$props.onResize;\n\n      if (_this._parentNode) {\n        // Guard against AutoSizer component being removed from the DOM immediately after being added.\n        // This can result in invalid style values which can result in NaN values if we don't handle them.\n        // See issue #150 for more context.\n        var height = _this._parentNode.offsetHeight || 0;\n        var width = _this._parentNode.offsetWidth || 0;\n        var win = _this._window || window;\n        var style = win.getComputedStyle(_this._parentNode) || {};\n        var paddingLeft = parseInt(style.paddingLeft, 10) || 0;\n        var paddingRight = parseInt(style.paddingRight, 10) || 0;\n        var paddingTop = parseInt(style.paddingTop, 10) || 0;\n        var paddingBottom = parseInt(style.paddingBottom, 10) || 0;\n        var newHeight = height - paddingTop - paddingBottom;\n        var newWidth = width - paddingLeft - paddingRight;\n\n        if (!disableHeight && _this.state.height !== newHeight || !disableWidth && _this.state.width !== newWidth) {\n          _this.setState({\n            height: height - paddingTop - paddingBottom,\n            width: width - paddingLeft - paddingRight\n          });\n\n          onResize({\n            height: height,\n            width: width\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setRef\", function (autoSizer) {\n      _this._autoSizer = autoSizer;\n    });\n\n    return _this;\n  }\n\n  _createClass(AutoSizer, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var nonce = this.props.nonce;\n\n      if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {\n        // Delay access of parentNode until mount.\n        // This handles edge-cases where the component has already been unmounted before its ref has been set,\n        // As well as libraries like react-lite which have a slightly different lifecycle.\n        this._parentNode = this._autoSizer.parentNode;\n        this._window = this._autoSizer.parentNode.ownerDocument.defaultView; // Defer requiring resize handler in order to support server-side rendering.\n        // See issue #41\n\n        this._detectElementResize = createDetectElementResize(nonce, this._window);\n\n        this._detectElementResize.addResizeListener(this._parentNode, this._onResize);\n\n        this._onResize();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._detectElementResize && this._parentNode) {\n        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          children = _this$props2.children,\n          className = _this$props2.className,\n          disableHeight = _this$props2.disableHeight,\n          disableWidth = _this$props2.disableWidth,\n          style = _this$props2.style;\n      var _this$state = this.state,\n          height = _this$state.height,\n          width = _this$state.width; // Outer div should not force width/height since that may prevent containers from shrinking.\n      // Inner component should overflow and use calculated width/height.\n      // See issue #68 for more information.\n\n      var outerStyle = {\n        overflow: 'visible'\n      };\n      var childParams = {};\n\n      if (!disableHeight) {\n        outerStyle.height = 0;\n        childParams.height = height;\n      }\n\n      if (!disableWidth) {\n        outerStyle.width = 0;\n        childParams.width = width;\n      }\n      /**\n       * TODO: Avoid rendering children before the initial measurements have been collected.\n       * At best this would just be wasting cycles.\n       * Add this check into version 10 though as it could break too many ref callbacks in version 9.\n       * Note that if default width/height props were provided this would still work with SSR.\n      if (\n        height !== 0 &&\n        width !== 0\n      ) {\n        child = children({ height, width })\n      }\n      */\n\n\n      return React.createElement(\"div\", {\n        className: className,\n        ref: this._setRef,\n        style: _objectSpread({}, outerStyle, {}, style)\n      }, children(childParams));\n    }\n  }]);\n\n  return AutoSizer;\n}(React.Component), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  /** Function responsible for rendering children.*/\n  \"children\": PropTypes.func.isRequired,\n\n  /** Optional custom CSS class name to attach to root AutoSizer element.  */\n  \"className\": PropTypes.string,\n\n  /** Default height to use for initial render; useful for SSR */\n  \"defaultHeight\": PropTypes.number,\n\n  /** Default width to use for initial render; useful for SSR */\n  \"defaultWidth\": PropTypes.number,\n\n  /** Disable dynamic :height property */\n  \"disableHeight\": PropTypes.bool.isRequired,\n\n  /** Disable dynamic :width property */\n  \"disableWidth\": PropTypes.bool.isRequired,\n\n  /** Nonce of the inlined stylesheet for Content Security Policy */\n  \"nonce\": PropTypes.string,\n\n  /** Callback to be invoked on-resize */\n  \"onResize\": PropTypes.func.isRequired,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object\n}), _temp);\n\n_defineProperty(AutoSizer, \"defaultProps\", {\n  onResize: function onResize() {},\n  disableHeight: false,\n  disableWidth: false,\n  style: {}\n});\n\nexport { AutoSizer as default };\nimport PropTypes from \"prop-types\";","/**\n * Detect Element Resize.\n * https://github.com/sdecima/javascript-detect-element-resize\n * Sebastian Decima\n *\n * Forked from version 0.5.3; includes the following modifications:\n * 1) Guard against unsafe 'window' and 'document' references (to support SSR).\n * 2) Defer initialization code via a top-level function wrapper (to support SSR).\n * 3) Avoid unnecessary reflows by not measuring size for scroll events bubbling from children.\n * 4) Add nonce for style element.\n * 5) Added support for injecting custom window object\n **/\nexport default function createDetectElementResize(nonce, hostWindow) {\n  // Check `document` and `window` in case of server-side rendering\n  var _window;\n\n  if (typeof hostWindow !== 'undefined') {\n    _window = hostWindow;\n  } else if (typeof window !== 'undefined') {\n    _window = window;\n  } else if (typeof self !== 'undefined') {\n    _window = self;\n  } else {\n    _window = global;\n  }\n\n  var attachEvent = typeof _window.document !== 'undefined' && _window.document.attachEvent;\n\n  if (!attachEvent) {\n    var requestFrame = function () {\n      var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) {\n        return _window.setTimeout(fn, 20);\n      };\n\n      return function (fn) {\n        return raf(fn);\n      };\n    }();\n\n    var cancelFrame = function () {\n      var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout;\n      return function (id) {\n        return cancel(id);\n      };\n    }();\n\n    var resetTriggers = function resetTriggers(element) {\n      var triggers = element.__resizeTriggers__,\n          expand = triggers.firstElementChild,\n          contract = triggers.lastElementChild,\n          expandChild = expand.firstElementChild;\n      contract.scrollLeft = contract.scrollWidth;\n      contract.scrollTop = contract.scrollHeight;\n      expandChild.style.width = expand.offsetWidth + 1 + 'px';\n      expandChild.style.height = expand.offsetHeight + 1 + 'px';\n      expand.scrollLeft = expand.scrollWidth;\n      expand.scrollTop = expand.scrollHeight;\n    };\n\n    var checkTriggers = function checkTriggers(element) {\n      return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height;\n    };\n\n    var scrollListener = function scrollListener(e) {\n      // Don't measure (which forces) reflow for scrolls that happen inside of children!\n      if (e.target.className && typeof e.target.className.indexOf === 'function' && e.target.className.indexOf('contract-trigger') < 0 && e.target.className.indexOf('expand-trigger') < 0) {\n        return;\n      }\n\n      var element = this;\n      resetTriggers(this);\n\n      if (this.__resizeRAF__) {\n        cancelFrame(this.__resizeRAF__);\n      }\n\n      this.__resizeRAF__ = requestFrame(function () {\n        if (checkTriggers(element)) {\n          element.__resizeLast__.width = element.offsetWidth;\n          element.__resizeLast__.height = element.offsetHeight;\n\n          element.__resizeListeners__.forEach(function (fn) {\n            fn.call(element, e);\n          });\n        }\n      });\n    };\n    /* Detect CSS Animations support to detect element display/re-attach */\n\n\n    var animation = false,\n        keyframeprefix = '',\n        animationstartevent = 'animationstart',\n        domPrefixes = 'Webkit Moz O ms'.split(' '),\n        startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),\n        pfx = '';\n    {\n      var elm = _window.document.createElement('fakeelement');\n\n      if (elm.style.animationName !== undefined) {\n        animation = true;\n      }\n\n      if (animation === false) {\n        for (var i = 0; i < domPrefixes.length; i++) {\n          if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {\n            pfx = domPrefixes[i];\n            keyframeprefix = '-' + pfx.toLowerCase() + '-';\n            animationstartevent = startEvents[i];\n            animation = true;\n            break;\n          }\n        }\n      }\n    }\n    var animationName = 'resizeanim';\n    var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';\n    var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';\n  }\n\n  var createStyles = function createStyles(doc) {\n    if (!doc.getElementById('detectElementResize')) {\n      //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360\n      var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: \" \"; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }',\n          head = doc.head || doc.getElementsByTagName('head')[0],\n          style = doc.createElement('style');\n      style.id = 'detectElementResize';\n      style.type = 'text/css';\n\n      if (nonce != null) {\n        style.setAttribute('nonce', nonce);\n      }\n\n      if (style.styleSheet) {\n        style.styleSheet.cssText = css;\n      } else {\n        style.appendChild(doc.createTextNode(css));\n      }\n\n      head.appendChild(style);\n    }\n  };\n\n  var addResizeListener = function addResizeListener(element, fn) {\n    if (attachEvent) {\n      element.attachEvent('onresize', fn);\n    } else {\n      if (!element.__resizeTriggers__) {\n        var doc = element.ownerDocument;\n\n        var elementStyle = _window.getComputedStyle(element);\n\n        if (elementStyle && elementStyle.position == 'static') {\n          element.style.position = 'relative';\n        }\n\n        createStyles(doc);\n        element.__resizeLast__ = {};\n        element.__resizeListeners__ = [];\n        (element.__resizeTriggers__ = doc.createElement('div')).className = 'resize-triggers';\n        var resizeTriggersHtml = '<div class=\"expand-trigger\"><div></div></div>' + '<div class=\"contract-trigger\"></div>';\n\n        if (window.trustedTypes) {\n          var staticPolicy = trustedTypes.createPolicy('react-virtualized-auto-sizer', {\n            createHTML: function createHTML() {\n              return resizeTriggersHtml;\n            }\n          });\n          element.__resizeTriggers__.innerHTML = staticPolicy.createHTML('');\n        } else {\n          element.__resizeTriggers__.innerHTML = resizeTriggersHtml;\n        }\n\n        element.appendChild(element.__resizeTriggers__);\n        resetTriggers(element);\n        element.addEventListener('scroll', scrollListener, true);\n        /* Listen for a css animation to detect element display/re-attach */\n\n        if (animationstartevent) {\n          element.__resizeTriggers__.__animationListener__ = function animationListener(e) {\n            if (e.animationName == animationName) {\n              resetTriggers(element);\n            }\n          };\n\n          element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\n        }\n      }\n\n      element.__resizeListeners__.push(fn);\n    }\n  };\n\n  var removeResizeListener = function removeResizeListener(element, fn) {\n    if (attachEvent) {\n      element.detachEvent('onresize', fn);\n    } else {\n      element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n\n      if (!element.__resizeListeners__.length) {\n        element.removeEventListener('scroll', scrollListener, true);\n\n        if (element.__resizeTriggers__.__animationListener__) {\n          element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\n\n          element.__resizeTriggers__.__animationListener__ = null;\n        }\n\n        try {\n          element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);\n        } catch (e) {// Preact compat; see developit/preact-compat/issues/228\n        }\n      }\n    }\n  };\n\n  return {\n    addResizeListener: addResizeListener,\n    removeResizeListener: removeResizeListener\n  };\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nimport * as React from 'react';\nimport { findDOMNode } from 'react-dom';\n\n/**\n * Wraps a cell and measures its rendered content.\n * Measurements are stored in a per-cell cache.\n * Cached-content is not be re-measured.\n */\nvar CellMeasurer = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(CellMeasurer, _React$PureComponent);\n\n  function CellMeasurer() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, CellMeasurer);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellMeasurer)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"_child\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_measure\", function () {\n      var _this$props = _this.props,\n          cache = _this$props.cache,\n          _this$props$columnInd = _this$props.columnIndex,\n          columnIndex = _this$props$columnInd === void 0 ? 0 : _this$props$columnInd,\n          parent = _this$props.parent,\n          _this$props$rowIndex = _this$props.rowIndex,\n          rowIndex = _this$props$rowIndex === void 0 ? _this.props.index || 0 : _this$props$rowIndex;\n\n      var _this$_getCellMeasure = _this._getCellMeasurements(),\n          height = _this$_getCellMeasure.height,\n          width = _this$_getCellMeasure.width;\n\n      if (height !== cache.getHeight(rowIndex, columnIndex) || width !== cache.getWidth(rowIndex, columnIndex)) {\n        cache.set(rowIndex, columnIndex, width, height);\n\n        if (parent && typeof parent.recomputeGridSize === 'function') {\n          parent.recomputeGridSize({\n            columnIndex: columnIndex,\n            rowIndex: rowIndex\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerChild\", function (element) {\n      if (element && !(element instanceof Element)) {\n        console.warn('CellMeasurer registerChild expects to be passed Element or null');\n      }\n\n      _this._child = element;\n\n      if (element) {\n        _this._maybeMeasureCell();\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(CellMeasurer, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._maybeMeasureCell();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._maybeMeasureCell();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      return typeof children === 'function' ? children({\n        measure: this._measure,\n        registerChild: this._registerChild\n      }) : children;\n    }\n  }, {\n    key: \"_getCellMeasurements\",\n    value: function _getCellMeasurements() {\n      var cache = this.props.cache;\n      var node = this._child || findDOMNode(this); // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height\n\n      if (node && node.ownerDocument && node.ownerDocument.defaultView && node instanceof node.ownerDocument.defaultView.HTMLElement) {\n        var styleWidth = node.style.width;\n        var styleHeight = node.style.height; // If we are re-measuring a cell that has already been measured,\n        // It will have a hard-coded width/height from the previous measurement.\n        // The fact that we are measuring indicates this measurement is probably stale,\n        // So explicitly clear it out (eg set to \"auto\") so we can recalculate.\n        // See issue #593 for more info.\n        // Even if we are measuring initially- if we're inside of a MultiGrid component,\n        // Explicitly clear width/height before measuring to avoid being tainted by another Grid.\n        // eg top/left Grid renders before bottom/right Grid\n        // Since the CellMeasurerCache is shared between them this taints derived cell size values.\n\n        if (!cache.hasFixedWidth()) {\n          node.style.width = 'auto';\n        }\n\n        if (!cache.hasFixedHeight()) {\n          node.style.height = 'auto';\n        }\n\n        var height = Math.ceil(node.offsetHeight);\n        var width = Math.ceil(node.offsetWidth); // Reset after measuring to avoid breaking styles; see #660\n\n        if (styleWidth) {\n          node.style.width = styleWidth;\n        }\n\n        if (styleHeight) {\n          node.style.height = styleHeight;\n        }\n\n        return {\n          height: height,\n          width: width\n        };\n      } else {\n        return {\n          height: 0,\n          width: 0\n        };\n      }\n    }\n  }, {\n    key: \"_maybeMeasureCell\",\n    value: function _maybeMeasureCell() {\n      var _this$props2 = this.props,\n          cache = _this$props2.cache,\n          _this$props2$columnIn = _this$props2.columnIndex,\n          columnIndex = _this$props2$columnIn === void 0 ? 0 : _this$props2$columnIn,\n          parent = _this$props2.parent,\n          _this$props2$rowIndex = _this$props2.rowIndex,\n          rowIndex = _this$props2$rowIndex === void 0 ? this.props.index || 0 : _this$props2$rowIndex;\n\n      if (!cache.has(rowIndex, columnIndex)) {\n        var _this$_getCellMeasure2 = this._getCellMeasurements(),\n            height = _this$_getCellMeasure2.height,\n            width = _this$_getCellMeasure2.width;\n\n        cache.set(rowIndex, columnIndex, width, height); // If size has changed, let Grid know to re-render.\n\n        if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {\n          parent.invalidateCellSizeAfterRender({\n            columnIndex: columnIndex,\n            rowIndex: rowIndex\n          });\n        }\n      }\n    }\n  }]);\n\n  return CellMeasurer;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"cache\": function cache() {\n    return (typeof bpfrpt_proptype_CellMeasureCache === \"function\" ? bpfrpt_proptype_CellMeasureCache.isRequired ? bpfrpt_proptype_CellMeasureCache.isRequired : bpfrpt_proptype_CellMeasureCache : PropTypes.shape(bpfrpt_proptype_CellMeasureCache).isRequired).apply(this, arguments);\n  },\n  \"children\": PropTypes.oneOfType([PropTypes.func, PropTypes.node]).isRequired,\n  \"columnIndex\": PropTypes.number,\n  \"index\": PropTypes.number,\n  \"parent\": PropTypes.shape({\n    invalidateCellSizeAfterRender: PropTypes.func,\n    recomputeGridSize: PropTypes.func\n  }).isRequired,\n  \"rowIndex\": PropTypes.number\n}), _temp); // Used for DEV mode warning check\n\n_defineProperty(CellMeasurer, \"__internalCellMeasurerFlag\", false);\n\nexport { CellMeasurer as default };\n\nif (process.env.NODE_ENV !== 'production') {\n  CellMeasurer.__internalCellMeasurerFlag = true;\n}\n\nimport { bpfrpt_proptype_CellMeasureCache } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nexport var DEFAULT_HEIGHT = 30;\nexport var DEFAULT_WIDTH = 100; // Enables more intelligent mapping of a given column and row index to an item ID.\n// This prevents a cell cache from being invalidated when its parent collection is modified.\n\n/**\n * Caches measurements for a given cell.\n */\nvar CellMeasurerCache =\n/*#__PURE__*/\nfunction () {\n  function CellMeasurerCache() {\n    var _this = this;\n\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, CellMeasurerCache);\n\n    _defineProperty(this, \"_cellHeightCache\", {});\n\n    _defineProperty(this, \"_cellWidthCache\", {});\n\n    _defineProperty(this, \"_columnWidthCache\", {});\n\n    _defineProperty(this, \"_rowHeightCache\", {});\n\n    _defineProperty(this, \"_defaultHeight\", void 0);\n\n    _defineProperty(this, \"_defaultWidth\", void 0);\n\n    _defineProperty(this, \"_minHeight\", void 0);\n\n    _defineProperty(this, \"_minWidth\", void 0);\n\n    _defineProperty(this, \"_keyMapper\", void 0);\n\n    _defineProperty(this, \"_hasFixedHeight\", void 0);\n\n    _defineProperty(this, \"_hasFixedWidth\", void 0);\n\n    _defineProperty(this, \"_columnCount\", 0);\n\n    _defineProperty(this, \"_rowCount\", 0);\n\n    _defineProperty(this, \"columnWidth\", function (_ref) {\n      var index = _ref.index;\n\n      var key = _this._keyMapper(0, index);\n\n      return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;\n    });\n\n    _defineProperty(this, \"rowHeight\", function (_ref2) {\n      var index = _ref2.index;\n\n      var key = _this._keyMapper(index, 0);\n\n      return _this._rowHeightCache[key] !== undefined ? _this._rowHeightCache[key] : _this._defaultHeight;\n    });\n\n    var defaultHeight = params.defaultHeight,\n        defaultWidth = params.defaultWidth,\n        fixedHeight = params.fixedHeight,\n        fixedWidth = params.fixedWidth,\n        keyMapper = params.keyMapper,\n        minHeight = params.minHeight,\n        minWidth = params.minWidth;\n    this._hasFixedHeight = fixedHeight === true;\n    this._hasFixedWidth = fixedWidth === true;\n    this._minHeight = minHeight || 0;\n    this._minWidth = minWidth || 0;\n    this._keyMapper = keyMapper || defaultKeyMapper;\n    this._defaultHeight = Math.max(this._minHeight, typeof defaultHeight === 'number' ? defaultHeight : DEFAULT_HEIGHT);\n    this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (this._hasFixedHeight === false && this._hasFixedWidth === false) {\n        console.warn(\"CellMeasurerCache should only measure a cell's width or height. \" + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');\n      }\n\n      if (this._hasFixedHeight === false && this._defaultHeight === 0) {\n        console.warn('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');\n      }\n\n      if (this._hasFixedWidth === false && this._defaultWidth === 0) {\n        console.warn('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');\n      }\n    }\n  }\n\n  _createClass(CellMeasurerCache, [{\n    key: \"clear\",\n    value: function clear(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      delete this._cellHeightCache[key];\n      delete this._cellWidthCache[key];\n\n      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);\n    }\n  }, {\n    key: \"clearAll\",\n    value: function clearAll() {\n      this._cellHeightCache = {};\n      this._cellWidthCache = {};\n      this._columnWidthCache = {};\n      this._rowHeightCache = {};\n      this._rowCount = 0;\n      this._columnCount = 0;\n    }\n  }, {\n    key: \"hasFixedHeight\",\n    value: function hasFixedHeight() {\n      return this._hasFixedHeight;\n    }\n  }, {\n    key: \"hasFixedWidth\",\n    value: function hasFixedWidth() {\n      return this._hasFixedWidth;\n    }\n  }, {\n    key: \"getHeight\",\n    value: function getHeight(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      if (this._hasFixedHeight) {\n        return this._defaultHeight;\n      } else {\n        var _key = this._keyMapper(rowIndex, columnIndex);\n\n        return this._cellHeightCache[_key] !== undefined ? Math.max(this._minHeight, this._cellHeightCache[_key]) : this._defaultHeight;\n      }\n    }\n  }, {\n    key: \"getWidth\",\n    value: function getWidth(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      if (this._hasFixedWidth) {\n        return this._defaultWidth;\n      } else {\n        var _key2 = this._keyMapper(rowIndex, columnIndex);\n\n        return this._cellWidthCache[_key2] !== undefined ? Math.max(this._minWidth, this._cellWidthCache[_key2]) : this._defaultWidth;\n      }\n    }\n  }, {\n    key: \"has\",\n    value: function has(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      return this._cellHeightCache[key] !== undefined;\n    }\n  }, {\n    key: \"set\",\n    value: function set(rowIndex, columnIndex, width, height) {\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      if (columnIndex >= this._columnCount) {\n        this._columnCount = columnIndex + 1;\n      }\n\n      if (rowIndex >= this._rowCount) {\n        this._rowCount = rowIndex + 1;\n      } // Size is cached per cell so we don't have to re-measure if cells are re-ordered.\n\n\n      this._cellHeightCache[key] = height;\n      this._cellWidthCache[key] = width;\n\n      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);\n    }\n  }, {\n    key: \"_updateCachedColumnAndRowSizes\",\n    value: function _updateCachedColumnAndRowSizes(rowIndex, columnIndex) {\n      // :columnWidth and :rowHeight are derived based on all cells in a column/row.\n      // Pre-cache these derived values for faster lookup later.\n      // Reads are expected to occur more frequently than writes in this case.\n      // Only update non-fixed dimensions though to avoid doing unnecessary work.\n      if (!this._hasFixedWidth) {\n        var columnWidth = 0;\n\n        for (var i = 0; i < this._rowCount; i++) {\n          columnWidth = Math.max(columnWidth, this.getWidth(i, columnIndex));\n        }\n\n        var columnKey = this._keyMapper(0, columnIndex);\n\n        this._columnWidthCache[columnKey] = columnWidth;\n      }\n\n      if (!this._hasFixedHeight) {\n        var rowHeight = 0;\n\n        for (var _i = 0; _i < this._columnCount; _i++) {\n          rowHeight = Math.max(rowHeight, this.getHeight(rowIndex, _i));\n        }\n\n        var rowKey = this._keyMapper(rowIndex, 0);\n\n        this._rowHeightCache[rowKey] = rowHeight;\n      }\n    }\n  }, {\n    key: \"defaultHeight\",\n    get: function get() {\n      return this._defaultHeight;\n    }\n  }, {\n    key: \"defaultWidth\",\n    get: function get() {\n      return this._defaultWidth;\n    }\n  }]);\n\n  return CellMeasurerCache;\n}();\n\nexport { CellMeasurerCache as default };\n\nfunction defaultKeyMapper(rowIndex, columnIndex) {\n  return \"\".concat(rowIndex, \"-\").concat(columnIndex);\n}\n\nimport { bpfrpt_proptype_CellMeasureCache } from \"./types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\nimport getScrollbarSize from 'dom-helpers/scrollbarSize'; // @TODO Merge Collection and CollectionView\n\n/**\n * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nvar IS_SCROLLING_TIMEOUT = 150;\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\n\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n/**\n * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur.\n * This component does not render any visible content itself; it defers to the specified :cellLayoutManager.\n */\n\nvar CollectionView =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(CollectionView, _React$PureComponent);\n\n  // Invokes callbacks only when their values have changed.\n  function CollectionView() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, CollectionView);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CollectionView)).call.apply(_getPrototypeOf2, [this].concat(args))); // If this component is being rendered server-side, getScrollbarSize() will return undefined.\n    // We handle this case in componentDidMount()\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      isScrolling: false,\n      scrollLeft: 0,\n      scrollTop: 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_calculateSizeAndPositionDataOnNextUpdate\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRenderedMemoizer\", createCallbackMemoizer());\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollMemoizer\", createCallbackMemoizer(false));\n\n    _defineProperty(_assertThisInitialized(_this), \"_invokeOnSectionRenderedHelper\", function () {\n      var _this$props = _this.props,\n          cellLayoutManager = _this$props.cellLayoutManager,\n          onSectionRendered = _this$props.onSectionRendered;\n\n      _this._onSectionRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          indices: cellLayoutManager.getLastRenderedIndices()\n        }\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_updateScrollPositionForScrollToCell\", function () {\n      var _this$props2 = _this.props,\n          cellLayoutManager = _this$props2.cellLayoutManager,\n          height = _this$props2.height,\n          scrollToAlignment = _this$props2.scrollToAlignment,\n          scrollToCell = _this$props2.scrollToCell,\n          width = _this$props2.width;\n      var _this$state = _this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop;\n\n      if (scrollToCell >= 0) {\n        var scrollPosition = cellLayoutManager.getScrollPositionForCell({\n          align: scrollToAlignment,\n          cellIndex: scrollToCell,\n          height: height,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          width: width\n        });\n\n        if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) {\n          _this._setScrollPosition(scrollPosition);\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target !== _this._scrollingContainer) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      _this._enablePointerEventsAfterDelay(); // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.\n\n\n      var _this$props3 = _this.props,\n          cellLayoutManager = _this$props3.cellLayoutManager,\n          height = _this$props3.height,\n          isScrollingChange = _this$props3.isScrollingChange,\n          width = _this$props3.width;\n      var scrollbarSize = _this._scrollbarSize;\n\n      var _cellLayoutManager$ge = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge.height,\n          totalWidth = _cellLayoutManager$ge.width;\n\n      var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft));\n      var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop)); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n      if (_this.state.scrollLeft !== scrollLeft || _this.state.scrollTop !== scrollTop) {\n        // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set.\n        // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling).\n        // All things considered, this seems to be the best current work around that I'm aware of.\n        // For more information see https://github.com/bvaughn/react-virtualized/pull/124\n        var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; // Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called)\n\n        if (!_this.state.isScrolling) {\n          isScrollingChange(true);\n        }\n\n        _this.setState({\n          isScrolling: true,\n          scrollLeft: scrollLeft,\n          scrollPositionChangeReason: scrollPositionChangeReason,\n          scrollTop: scrollTop\n        });\n      }\n\n      _this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        totalWidth: totalWidth,\n        totalHeight: totalHeight\n      });\n    });\n\n    _this._scrollbarSize = getScrollbarSize();\n\n    if (_this._scrollbarSize === undefined) {\n      _this._scrollbarSizeMeasured = false;\n      _this._scrollbarSize = 0;\n    } else {\n      _this._scrollbarSizeMeasured = true;\n    }\n\n    return _this;\n  }\n  /**\n   * Forced recompute of cell sizes and positions.\n   * This function should be called if cell sizes have changed but nothing else has.\n   * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed.\n   */\n\n\n  _createClass(CollectionView, [{\n    key: \"recomputeCellSizesAndPositions\",\n    value: function recomputeCellSizesAndPositions() {\n      this._calculateSizeAndPositionDataOnNextUpdate = true;\n      this.forceUpdate();\n    }\n    /* ---------------------------- Component lifecycle methods ---------------------------- */\n\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props4 = this.props,\n          cellLayoutManager = _this$props4.cellLayoutManager,\n          scrollLeft = _this$props4.scrollLeft,\n          scrollToCell = _this$props4.scrollToCell,\n          scrollTop = _this$props4.scrollTop; // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n      if (!this._scrollbarSizeMeasured) {\n        this._scrollbarSize = getScrollbarSize();\n        this._scrollbarSizeMeasured = true;\n        this.setState({});\n      }\n\n      if (scrollToCell >= 0) {\n        this._updateScrollPositionForScrollToCell();\n      } else if (scrollLeft >= 0 || scrollTop >= 0) {\n        this._setScrollPosition({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n      } // Update onSectionRendered callback.\n\n\n      this._invokeOnSectionRenderedHelper();\n\n      var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge2.height,\n          totalWidth = _cellLayoutManager$ge2.width; // Initialize onScroll callback.\n\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalHeight: totalHeight,\n        totalWidth: totalWidth\n      });\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this$props5 = this.props,\n          height = _this$props5.height,\n          scrollToAlignment = _this$props5.scrollToAlignment,\n          scrollToCell = _this$props5.scrollToCell,\n          width = _this$props5.width;\n      var _this$state2 = this.state,\n          scrollLeft = _this$state2.scrollLeft,\n          scrollPositionChangeReason = _this$state2.scrollPositionChangeReason,\n          scrollTop = _this$state2.scrollTop; // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // 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).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n\n        if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      } // Update scroll offsets if the current :scrollToCell values requires it\n\n\n      if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) {\n        this._updateScrollPositionForScrollToCell();\n      } // Update onRowsRendered callback if start/stop indices have changed\n\n\n      this._invokeOnSectionRenderedHelper();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props6 = this.props,\n          autoHeight = _this$props6.autoHeight,\n          cellCount = _this$props6.cellCount,\n          cellLayoutManager = _this$props6.cellLayoutManager,\n          className = _this$props6.className,\n          height = _this$props6.height,\n          horizontalOverscanSize = _this$props6.horizontalOverscanSize,\n          id = _this$props6.id,\n          noContentRenderer = _this$props6.noContentRenderer,\n          style = _this$props6.style,\n          verticalOverscanSize = _this$props6.verticalOverscanSize,\n          width = _this$props6.width;\n      var _this$state3 = this.state,\n          isScrolling = _this$state3.isScrolling,\n          scrollLeft = _this$state3.scrollLeft,\n          scrollTop = _this$state3.scrollTop; // Memoization reset\n\n      if (this._lastRenderedCellCount !== cellCount || this._lastRenderedCellLayoutManager !== cellLayoutManager || this._calculateSizeAndPositionDataOnNextUpdate) {\n        this._lastRenderedCellCount = cellCount;\n        this._lastRenderedCellLayoutManager = cellLayoutManager;\n        this._calculateSizeAndPositionDataOnNextUpdate = false;\n        cellLayoutManager.calculateSizeAndPositionData();\n      }\n\n      var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge3.height,\n          totalWidth = _cellLayoutManager$ge3.width; // Safely expand the rendered area by the specified overscan amount\n\n\n      var left = Math.max(0, scrollLeft - horizontalOverscanSize);\n      var top = Math.max(0, scrollTop - verticalOverscanSize);\n      var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize);\n      var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize);\n      var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({\n        height: bottom - top,\n        isScrolling: isScrolling,\n        width: right - left,\n        x: left,\n        y: top\n      }) : [];\n      var collectionStyle = {\n        boxSizing: 'border-box',\n        direction: 'ltr',\n        height: autoHeight ? 'auto' : height,\n        position: 'relative',\n        WebkitOverflowScrolling: 'touch',\n        width: width,\n        willChange: 'transform'\n      }; // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n\n      var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0;\n      var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0; // Also explicitly init styles to 'auto' if scrollbars are required.\n      // This works around an obscure edge case where external CSS styles have not yet been loaded,\n      // But an initial scroll index of offset is set as an external prop.\n      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.\n      // This was originally reported via clauderic/react-infinite-calendar/issues/23\n\n      collectionStyle.overflowX = totalWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';\n      collectionStyle.overflowY = totalHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';\n      return React.createElement(\"div\", {\n        ref: this._setScrollingContainerRef,\n        \"aria-label\": this.props['aria-label'],\n        className: clsx('ReactVirtualized__Collection', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: \"grid\",\n        style: _objectSpread({}, collectionStyle, {}, style),\n        tabIndex: 0\n      }, cellCount > 0 && React.createElement(\"div\", {\n        className: \"ReactVirtualized__Collection__innerScrollContainer\",\n        style: {\n          height: totalHeight,\n          maxHeight: totalHeight,\n          maxWidth: totalWidth,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          width: totalWidth\n        }\n      }, childrenToDisplay), cellCount === 0 && noContentRenderer());\n    }\n    /* ---------------------------- Helper methods ---------------------------- */\n\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Collection.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: \"_enablePointerEventsAfterDelay\",\n    value: function _enablePointerEventsAfterDelay() {\n      var _this2 = this;\n\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = setTimeout(function () {\n        var isScrollingChange = _this2.props.isScrollingChange;\n        isScrollingChange(false);\n        _this2._disablePointerEventsTimeoutId = null;\n\n        _this2.setState({\n          isScrolling: false\n        });\n      }, IS_SCROLLING_TIMEOUT);\n    }\n  }, {\n    key: \"_invokeOnScrollMemoizer\",\n    value: function _invokeOnScrollMemoizer(_ref) {\n      var _this3 = this;\n\n      var scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          totalHeight = _ref.totalHeight,\n          totalWidth = _ref.totalWidth;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref2) {\n          var scrollLeft = _ref2.scrollLeft,\n              scrollTop = _ref2.scrollTop;\n          var _this3$props = _this3.props,\n              height = _this3$props.height,\n              onScroll = _this3$props.onScroll,\n              width = _this3$props.width;\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n  }, {\n    key: \"_setScrollPosition\",\n    value: function _setScrollPosition(_ref3) {\n      var scrollLeft = _ref3.scrollLeft,\n          scrollTop = _ref3.scrollTop;\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (scrollLeft >= 0) {\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (scrollTop >= 0) {\n        newState.scrollTop = scrollTop;\n      }\n\n      if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {\n        this.setState(newState);\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.cellCount === 0 && (prevState.scrollLeft !== 0 || prevState.scrollTop !== 0)) {\n        return {\n          scrollLeft: 0,\n          scrollTop: 0,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n        };\n      } else if (nextProps.scrollLeft !== prevState.scrollLeft || nextProps.scrollTop !== prevState.scrollTop) {\n        return {\n          scrollLeft: nextProps.scrollLeft != null ? nextProps.scrollLeft : prevState.scrollLeft,\n          scrollTop: nextProps.scrollTop != null ? nextProps.scrollTop : prevState.scrollTop,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return CollectionView;\n}(React.PureComponent);\n\n_defineProperty(CollectionView, \"defaultProps\", {\n  'aria-label': 'grid',\n  horizontalOverscanSize: 0,\n  noContentRenderer: function noContentRenderer() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  onSectionRendered: function onSectionRendered() {\n    return null;\n  },\n  scrollToAlignment: 'auto',\n  scrollToCell: -1,\n  style: {},\n  verticalOverscanSize: 0\n});\n\nCollectionView.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  'aria-label': PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: PropTypes.bool,\n\n  /**\n   * Number of cells in collection.\n   */\n  cellCount: PropTypes.number.isRequired,\n\n  /**\n   * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window.\n   */\n  cellLayoutManager: PropTypes.object.isRequired,\n\n  /**\n   * Optional custom CSS class name to attach to root Collection element.\n   */\n  className: PropTypes.string,\n\n  /**\n   * Height of Collection; this property determines the number of visible (vs virtualized) rows.\n   */\n  height: PropTypes.number.isRequired,\n\n  /**\n   * Optional custom id to attach to root Collection element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * Enables the `Collection` to horiontally \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  horizontalOverscanSize: PropTypes.number.isRequired,\n  isScrollingChange: PropTypes.func,\n\n  /**\n   * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0.\n   */\n  noContentRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void\n   */\n  onScroll: PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked with information about the section of the Collection that was just rendered.\n   * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices.\n   */\n  onSectionRendered: PropTypes.func.isRequired,\n\n  /**\n   * Horizontal offset.\n   */\n  scrollLeft: PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  scrollToAlignment: PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /**\n   * Cell index to ensure visible (by forcefully scrolling if necessary).\n   */\n  scrollToCell: PropTypes.number.isRequired,\n\n  /**\n   * Vertical offset.\n   */\n  scrollTop: PropTypes.number,\n\n  /**\n   * Optional custom inline style to attach to root Collection element.\n   */\n  style: PropTypes.object,\n\n  /**\n   * Enables the `Collection` to vertically \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  verticalOverscanSize: PropTypes.number.isRequired,\n\n  /**\n   * Width of Collection; this property determines the number of visible (vs virtualized) columns.\n   */\n  width: PropTypes.number.isRequired\n} : {};\npolyfill(CollectionView);\nexport default CollectionView;","var bpfrpt_proptype_Index = process.env.NODE_ENV === 'production' ? null : {\n  \"index\": PropTypes.number.isRequired\n};\nvar bpfrpt_proptype_PositionInfo = process.env.NODE_ENV === 'production' ? null : {\n  \"x\": PropTypes.number.isRequired,\n  \"y\": PropTypes.number.isRequired\n};\nvar bpfrpt_proptype_ScrollPosition = process.env.NODE_ENV === 'production' ? null : {\n  \"scrollLeft\": PropTypes.number.isRequired,\n  \"scrollTop\": PropTypes.number.isRequired\n};\nvar bpfrpt_proptype_SizeAndPositionInfo = process.env.NODE_ENV === 'production' ? null : {\n  \"height\": PropTypes.number.isRequired,\n  \"width\": PropTypes.number.isRequired,\n  \"x\": PropTypes.number.isRequired,\n  \"y\": PropTypes.number.isRequired\n};\nvar bpfrpt_proptype_SizeInfo = process.env.NODE_ENV === 'production' ? null : {\n  \"height\": PropTypes.number.isRequired,\n  \"width\": PropTypes.number.isRequired\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_Index };\nexport { bpfrpt_proptype_PositionInfo };\nexport { bpfrpt_proptype_ScrollPosition };\nexport { bpfrpt_proptype_SizeAndPositionInfo };\nexport { bpfrpt_proptype_SizeInfo };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\n\n/**\n * A section of the Window.\n * Window Sections are used to group nearby cells.\n * This enables us to more quickly determine which cells to display in a given region of the Window.\n * Sections have a fixed size and contain 0 to many cells (tracked by their indices).\n */\nvar Section =\n/*#__PURE__*/\nfunction () {\n  function Section(_ref) {\n    var height = _ref.height,\n        width = _ref.width,\n        x = _ref.x,\n        y = _ref.y;\n\n    _classCallCheck(this, Section);\n\n    this.height = height;\n    this.width = width;\n    this.x = x;\n    this.y = y;\n    this._indexMap = {};\n    this._indices = [];\n  }\n  /** Add a cell to this section. */\n\n\n  _createClass(Section, [{\n    key: \"addCellIndex\",\n    value: function addCellIndex(_ref2) {\n      var index = _ref2.index;\n\n      if (!this._indexMap[index]) {\n        this._indexMap[index] = true;\n\n        this._indices.push(index);\n      }\n    }\n    /** Get all cell indices that have been added to this section. */\n\n  }, {\n    key: \"getCellIndices\",\n    value: function getCellIndices() {\n      return this._indices;\n    }\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: \"toString\",\n    value: function toString() {\n      return \"\".concat(this.x, \",\").concat(this.y, \" \").concat(this.width, \"x\").concat(this.height);\n    }\n  }]);\n\n  return Section;\n}();\n\nexport { Section as default };\nimport { bpfrpt_proptype_Index } from \"./types\";\nimport { bpfrpt_proptype_SizeAndPositionInfo } from \"./types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\n\n/**\n * Window Sections are used to group nearby cells.\n * This enables us to more quickly determine which cells to display in a given region of the Window.\n * \n */\nimport Section from './Section';\nvar SECTION_SIZE = 100;\n\n/**\n * Contains 0 to many Sections.\n * Grows (and adds Sections) dynamically as cells are registered.\n * Automatically adds cells to the appropriate Section(s).\n */\nvar SectionManager =\n/*#__PURE__*/\nfunction () {\n  function SectionManager() {\n    var sectionSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SECTION_SIZE;\n\n    _classCallCheck(this, SectionManager);\n\n    this._sectionSize = sectionSize;\n    this._cellMetadata = [];\n    this._sections = {};\n  }\n  /**\n   * Gets all cell indices contained in the specified region.\n   * A region may encompass 1 or more Sections.\n   */\n\n\n  _createClass(SectionManager, [{\n    key: \"getCellIndices\",\n    value: function getCellIndices(_ref) {\n      var height = _ref.height,\n          width = _ref.width,\n          x = _ref.x,\n          y = _ref.y;\n      var indices = {};\n      this.getSections({\n        height: height,\n        width: width,\n        x: x,\n        y: y\n      }).forEach(function (section) {\n        return section.getCellIndices().forEach(function (index) {\n          indices[index] = index;\n        });\n      }); // Object keys are strings; this function returns numbers\n\n      return Object.keys(indices).map(function (index) {\n        return indices[index];\n      });\n    }\n    /** Get size and position information for the cell specified. */\n\n  }, {\n    key: \"getCellMetadata\",\n    value: function getCellMetadata(_ref2) {\n      var index = _ref2.index;\n      return this._cellMetadata[index];\n    }\n    /** Get all Sections overlapping the specified region. */\n\n  }, {\n    key: \"getSections\",\n    value: function getSections(_ref3) {\n      var height = _ref3.height,\n          width = _ref3.width,\n          x = _ref3.x,\n          y = _ref3.y;\n      var sectionXStart = Math.floor(x / this._sectionSize);\n      var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);\n      var sectionYStart = Math.floor(y / this._sectionSize);\n      var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);\n      var sections = [];\n\n      for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {\n        for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {\n          var key = \"\".concat(sectionX, \".\").concat(sectionY);\n\n          if (!this._sections[key]) {\n            this._sections[key] = new Section({\n              height: this._sectionSize,\n              width: this._sectionSize,\n              x: sectionX * this._sectionSize,\n              y: sectionY * this._sectionSize\n            });\n          }\n\n          sections.push(this._sections[key]);\n        }\n      }\n\n      return sections;\n    }\n    /** Total number of Sections based on the currently registered cells. */\n\n  }, {\n    key: \"getTotalSectionCount\",\n    value: function getTotalSectionCount() {\n      return Object.keys(this._sections).length;\n    }\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: \"toString\",\n    value: function toString() {\n      var _this = this;\n\n      return Object.keys(this._sections).map(function (index) {\n        return _this._sections[index].toString();\n      });\n    }\n    /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */\n\n  }, {\n    key: \"registerCell\",\n    value: function registerCell(_ref4) {\n      var cellMetadatum = _ref4.cellMetadatum,\n          index = _ref4.index;\n      this._cellMetadata[index] = cellMetadatum;\n      this.getSections(cellMetadatum).forEach(function (section) {\n        return section.addCellIndex({\n          index: index\n        });\n      });\n    }\n  }]);\n\n  return SectionManager;\n}();\n\nexport { SectionManager as default };\nimport { bpfrpt_proptype_Index } from \"./types\";\nimport { bpfrpt_proptype_SizeAndPositionInfo } from \"./types\";","/**\n * Determines a new offset that ensures a certain cell is visible, given the current offset.\n * If the cell is already visible then the current offset will be returned.\n * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n *\n * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n * @param cellOffset Offset (x or y) position for cell\n * @param cellSize Size (width or height) of cell\n * @param containerSize Total size (width or height) of the container\n * @param currentOffset Container's current (x or y) offset\n * @return Offset to use to ensure the specified cell is visible\n */\nexport default function getUpdatedOffsetForIndex(_ref) {\n  var _ref$align = _ref.align,\n      align = _ref$align === void 0 ? 'auto' : _ref$align,\n      cellOffset = _ref.cellOffset,\n      cellSize = _ref.cellSize,\n      containerSize = _ref.containerSize,\n      currentOffset = _ref.currentOffset;\n  var maxOffset = cellOffset;\n  var minOffset = maxOffset - containerSize + cellSize;\n\n  switch (align) {\n    case 'start':\n      return maxOffset;\n\n    case 'end':\n      return minOffset;\n\n    case 'center':\n      return maxOffset - (containerSize - cellSize) / 2;\n\n    default:\n      return Math.max(minOffset, Math.min(maxOffset, currentOffset));\n  }\n}","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport CollectionView from './CollectionView';\nimport _calculateSizeAndPositionData from './utils/calculateSizeAndPositionData';\nimport getUpdatedOffsetForIndex from '../utils/getUpdatedOffsetForIndex';\n\n/**\n * Renders scattered or non-linear data.\n * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data.\n */\nvar Collection =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Collection, _React$PureComponent);\n\n  function Collection(props, context) {\n    var _this;\n\n    _classCallCheck(this, Collection);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Collection).call(this, props, context));\n    _this._cellMetadata = [];\n    _this._lastRenderedCellIndices = []; // Cell cache during scroll (for performance)\n\n    _this._cellCache = [];\n    _this._isScrollingChange = _this._isScrollingChange.bind(_assertThisInitialized(_this));\n    _this._setCollectionViewRef = _this._setCollectionViewRef.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(Collection, [{\n    key: \"forceUpdate\",\n    value: function forceUpdate() {\n      if (this._collectionView !== undefined) {\n        this._collectionView.forceUpdate();\n      }\n    }\n    /** See Collection#recomputeCellSizesAndPositions */\n\n  }, {\n    key: \"recomputeCellSizesAndPositions\",\n    value: function recomputeCellSizesAndPositions() {\n      this._cellCache = [];\n\n      this._collectionView.recomputeCellSizesAndPositions();\n    }\n    /** React lifecycle methods */\n\n  }, {\n    key: \"render\",\n    value: function render() {\n      var props = _extends({}, this.props);\n\n      return React.createElement(CollectionView, _extends({\n        cellLayoutManager: this,\n        isScrollingChange: this._isScrollingChange,\n        ref: this._setCollectionViewRef\n      }, props));\n    }\n    /** CellLayoutManager interface */\n\n  }, {\n    key: \"calculateSizeAndPositionData\",\n    value: function calculateSizeAndPositionData() {\n      var _this$props = this.props,\n          cellCount = _this$props.cellCount,\n          cellSizeAndPositionGetter = _this$props.cellSizeAndPositionGetter,\n          sectionSize = _this$props.sectionSize;\n\n      var data = _calculateSizeAndPositionData({\n        cellCount: cellCount,\n        cellSizeAndPositionGetter: cellSizeAndPositionGetter,\n        sectionSize: sectionSize\n      });\n\n      this._cellMetadata = data.cellMetadata;\n      this._sectionManager = data.sectionManager;\n      this._height = data.height;\n      this._width = data.width;\n    }\n    /**\n     * Returns the most recently rendered set of cell indices.\n     */\n\n  }, {\n    key: \"getLastRenderedIndices\",\n    value: function getLastRenderedIndices() {\n      return this._lastRenderedCellIndices;\n    }\n    /**\n     * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible.\n     */\n\n  }, {\n    key: \"getScrollPositionForCell\",\n    value: function getScrollPositionForCell(_ref) {\n      var align = _ref.align,\n          cellIndex = _ref.cellIndex,\n          height = _ref.height,\n          scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          width = _ref.width;\n      var cellCount = this.props.cellCount;\n\n      if (cellIndex >= 0 && cellIndex < cellCount) {\n        var cellMetadata = this._cellMetadata[cellIndex];\n        scrollLeft = getUpdatedOffsetForIndex({\n          align: align,\n          cellOffset: cellMetadata.x,\n          cellSize: cellMetadata.width,\n          containerSize: width,\n          currentOffset: scrollLeft,\n          targetIndex: cellIndex\n        });\n        scrollTop = getUpdatedOffsetForIndex({\n          align: align,\n          cellOffset: cellMetadata.y,\n          cellSize: cellMetadata.height,\n          containerSize: height,\n          currentOffset: scrollTop,\n          targetIndex: cellIndex\n        });\n      }\n\n      return {\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      };\n    }\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      return {\n        height: this._height,\n        width: this._width\n      };\n    }\n  }, {\n    key: \"cellRenderers\",\n    value: function cellRenderers(_ref2) {\n      var _this2 = this;\n\n      var height = _ref2.height,\n          isScrolling = _ref2.isScrolling,\n          width = _ref2.width,\n          x = _ref2.x,\n          y = _ref2.y;\n      var _this$props2 = this.props,\n          cellGroupRenderer = _this$props2.cellGroupRenderer,\n          cellRenderer = _this$props2.cellRenderer; // Store for later calls to getLastRenderedIndices()\n\n      this._lastRenderedCellIndices = this._sectionManager.getCellIndices({\n        height: height,\n        width: width,\n        x: x,\n        y: y\n      });\n      return cellGroupRenderer({\n        cellCache: this._cellCache,\n        cellRenderer: cellRenderer,\n        cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref3) {\n          var index = _ref3.index;\n          return _this2._sectionManager.getCellMetadata({\n            index: index\n          });\n        },\n        indices: this._lastRenderedCellIndices,\n        isScrolling: isScrolling\n      });\n    }\n  }, {\n    key: \"_isScrollingChange\",\n    value: function _isScrollingChange(isScrolling) {\n      if (!isScrolling) {\n        this._cellCache = [];\n      }\n    }\n  }, {\n    key: \"_setCollectionViewRef\",\n    value: function _setCollectionViewRef(ref) {\n      this._collectionView = ref;\n    }\n  }]);\n\n  return Collection;\n}(React.PureComponent);\n\n_defineProperty(Collection, \"defaultProps\", {\n  'aria-label': 'grid',\n  cellGroupRenderer: defaultCellGroupRenderer\n});\n\nexport { Collection as default };\nCollection.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  'aria-label': PropTypes.string,\n\n  /**\n   * Number of cells in Collection.\n   */\n  cellCount: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a group of cells given their indices.\n   * Should implement the following interface: ({\n   *   cellSizeAndPositionGetter:Function,\n   *   indices: Array<number>,\n   *   cellRenderer: Function\n   * }): Array<PropTypes.node>\n   */\n  cellGroupRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Responsible for rendering a cell given an row and column index.\n   * Should implement the following interface: ({ index: number, key: string, style: object }): PropTypes.element\n   */\n  cellRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Callback responsible for returning size and offset/position information for a given cell (index).\n   * ({ index: number }): { height: number, width: number, x: number, y: number }\n   */\n  cellSizeAndPositionGetter: PropTypes.func.isRequired,\n\n  /**\n   * Optionally override the size of the sections a Collection's cells are split into.\n   */\n  sectionSize: PropTypes.number\n} : {};\n\nfunction defaultCellGroupRenderer(_ref4) {\n  var cellCache = _ref4.cellCache,\n      cellRenderer = _ref4.cellRenderer,\n      cellSizeAndPositionGetter = _ref4.cellSizeAndPositionGetter,\n      indices = _ref4.indices,\n      isScrolling = _ref4.isScrolling;\n  return indices.map(function (index) {\n    var cellMetadata = cellSizeAndPositionGetter({\n      index: index\n    });\n    var cellRendererProps = {\n      index: index,\n      isScrolling: isScrolling,\n      key: index,\n      style: {\n        height: cellMetadata.height,\n        left: cellMetadata.x,\n        position: 'absolute',\n        top: cellMetadata.y,\n        width: cellMetadata.width\n      }\n    }; // Avoid re-creating cells while scrolling.\n    // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n    // If a scroll is in progress- cache and reuse cells.\n    // This cache will be thrown away once scrolling complets.\n\n    if (isScrolling) {\n      if (!(index in cellCache)) {\n        cellCache[index] = cellRenderer(cellRendererProps);\n      }\n\n      return cellCache[index];\n    } else {\n      return cellRenderer(cellRendererProps);\n    }\n  }).filter(function (renderedCell) {\n    return !!renderedCell;\n  });\n}\n\nimport { bpfrpt_proptype_ScrollPosition } from \"./types\";\nimport { bpfrpt_proptype_SizeInfo } from \"./types\";","import SectionManager from '../SectionManager';\nexport default function calculateSizeAndPositionData(_ref) {\n  var cellCount = _ref.cellCount,\n      cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter,\n      sectionSize = _ref.sectionSize;\n  var cellMetadata = [];\n  var sectionManager = new SectionManager(sectionSize);\n  var height = 0;\n  var width = 0;\n\n  for (var index = 0; index < cellCount; index++) {\n    var cellMetadatum = cellSizeAndPositionGetter({\n      index: index\n    });\n\n    if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) {\n      throw Error(\"Invalid metadata returned for cell \".concat(index, \":\\n        x:\").concat(cellMetadatum.x, \", y:\").concat(cellMetadatum.y, \", width:\").concat(cellMetadatum.width, \", height:\").concat(cellMetadatum.height));\n    }\n\n    height = Math.max(height, cellMetadatum.y + cellMetadatum.height);\n    width = Math.max(width, cellMetadatum.x + cellMetadatum.width);\n    cellMetadata[index] = cellMetadatum;\n    sectionManager.registerCell({\n      cellMetadatum: cellMetadatum,\n      index: index\n    });\n  }\n\n  return {\n    cellMetadata: cellMetadata,\n    height: height,\n    sectionManager: sectionManager,\n    width: width\n  };\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\n/**\n * High-order component that auto-calculates column-widths for `Grid` cells.\n */\n\nvar ColumnSizer =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ColumnSizer, _React$PureComponent);\n\n  function ColumnSizer(props, context) {\n    var _this;\n\n    _classCallCheck(this, ColumnSizer);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ColumnSizer).call(this, props, context));\n    _this._registerChild = _this._registerChild.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(ColumnSizer, [{\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      var _this$props = this.props,\n          columnMaxWidth = _this$props.columnMaxWidth,\n          columnMinWidth = _this$props.columnMinWidth,\n          columnCount = _this$props.columnCount,\n          width = _this$props.width;\n\n      if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) {\n        if (this._registeredChild) {\n          this._registeredChild.recomputeGridSize();\n        }\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          children = _this$props2.children,\n          columnMaxWidth = _this$props2.columnMaxWidth,\n          columnMinWidth = _this$props2.columnMinWidth,\n          columnCount = _this$props2.columnCount,\n          width = _this$props2.width;\n      var safeColumnMinWidth = columnMinWidth || 1;\n      var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width;\n      var columnWidth = width / columnCount;\n      columnWidth = Math.max(safeColumnMinWidth, columnWidth);\n      columnWidth = Math.min(safeColumnMaxWidth, columnWidth);\n      columnWidth = Math.floor(columnWidth);\n      var adjustedWidth = Math.min(width, columnWidth * columnCount);\n      return children({\n        adjustedWidth: adjustedWidth,\n        columnWidth: columnWidth,\n        getColumnWidth: function getColumnWidth() {\n          return columnWidth;\n        },\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: \"_registerChild\",\n    value: function _registerChild(child) {\n      if (child && typeof child.recomputeGridSize !== 'function') {\n        throw Error('Unexpected child type registered; only Grid/MultiGrid children are supported.');\n      }\n\n      this._registeredChild = child;\n\n      if (this._registeredChild) {\n        this._registeredChild.recomputeGridSize();\n      }\n    }\n  }]);\n\n  return ColumnSizer;\n}(React.PureComponent);\n\nexport { ColumnSizer as default };\nColumnSizer.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering a virtualized Grid.\n   * This function should implement the following signature:\n   * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element\n   *\n   * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property.\n   * The :registerChild should be passed to the Grid's :ref property.\n   * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns.\n   */\n  children: PropTypes.func.isRequired,\n\n  /** Optional maximum allowed column width */\n  columnMaxWidth: PropTypes.number,\n\n  /** Optional minimum allowed column width */\n  columnMinWidth: PropTypes.number,\n\n  /** Number of columns in Grid or Table child */\n  columnCount: PropTypes.number.isRequired,\n\n  /** Width of Grid or Table child */\n  width: PropTypes.number.isRequired\n} : {};","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\n/**\n * Higher-order component that manages lazy-loading for \"infinite\" data.\n * This component decorates a virtual component and just-in-time prefetches rows as a user scrolls.\n * It is intended as a convenience component; fork it if you'd like finer-grained control over data-loading.\n */\n\nvar InfiniteLoader =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(InfiniteLoader, _React$PureComponent);\n\n  function InfiniteLoader(props, context) {\n    var _this;\n\n    _classCallCheck(this, InfiniteLoader);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(InfiniteLoader).call(this, props, context));\n    _this._loadMoreRowsMemoizer = createCallbackMemoizer();\n    _this._onRowsRendered = _this._onRowsRendered.bind(_assertThisInitialized(_this));\n    _this._registerChild = _this._registerChild.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(InfiniteLoader, [{\n    key: \"resetLoadMoreRowsCache\",\n    value: function resetLoadMoreRowsCache(autoReload) {\n      this._loadMoreRowsMemoizer = createCallbackMemoizer();\n\n      if (autoReload) {\n        this._doStuff(this._lastRenderedStartIndex, this._lastRenderedStopIndex);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      return children({\n        onRowsRendered: this._onRowsRendered,\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: \"_loadUnloadedRanges\",\n    value: function _loadUnloadedRanges(unloadedRanges) {\n      var _this2 = this;\n\n      var loadMoreRows = this.props.loadMoreRows;\n      unloadedRanges.forEach(function (unloadedRange) {\n        var promise = loadMoreRows(unloadedRange);\n\n        if (promise) {\n          promise.then(function () {\n            // Refresh the visible rows if any of them have just been loaded.\n            // Otherwise they will remain in their unloaded visual state.\n            if (isRangeVisible({\n              lastRenderedStartIndex: _this2._lastRenderedStartIndex,\n              lastRenderedStopIndex: _this2._lastRenderedStopIndex,\n              startIndex: unloadedRange.startIndex,\n              stopIndex: unloadedRange.stopIndex\n            })) {\n              if (_this2._registeredChild) {\n                forceUpdateReactVirtualizedComponent(_this2._registeredChild, _this2._lastRenderedStartIndex);\n              }\n            }\n          });\n        }\n      });\n    }\n  }, {\n    key: \"_onRowsRendered\",\n    value: function _onRowsRendered(_ref) {\n      var startIndex = _ref.startIndex,\n          stopIndex = _ref.stopIndex;\n      this._lastRenderedStartIndex = startIndex;\n      this._lastRenderedStopIndex = stopIndex;\n\n      this._doStuff(startIndex, stopIndex);\n    }\n  }, {\n    key: \"_doStuff\",\n    value: function _doStuff(startIndex, stopIndex) {\n      var _ref2,\n          _this3 = this;\n\n      var _this$props = this.props,\n          isRowLoaded = _this$props.isRowLoaded,\n          minimumBatchSize = _this$props.minimumBatchSize,\n          rowCount = _this$props.rowCount,\n          threshold = _this$props.threshold;\n      var unloadedRanges = scanForUnloadedRanges({\n        isRowLoaded: isRowLoaded,\n        minimumBatchSize: minimumBatchSize,\n        rowCount: rowCount,\n        startIndex: Math.max(0, startIndex - threshold),\n        stopIndex: Math.min(rowCount - 1, stopIndex + threshold)\n      }); // For memoize comparison\n\n      var squashedUnloadedRanges = (_ref2 = []).concat.apply(_ref2, _toConsumableArray(unloadedRanges.map(function (_ref3) {\n        var startIndex = _ref3.startIndex,\n            stopIndex = _ref3.stopIndex;\n        return [startIndex, stopIndex];\n      })));\n\n      this._loadMoreRowsMemoizer({\n        callback: function callback() {\n          _this3._loadUnloadedRanges(unloadedRanges);\n        },\n        indices: {\n          squashedUnloadedRanges: squashedUnloadedRanges\n        }\n      });\n    }\n  }, {\n    key: \"_registerChild\",\n    value: function _registerChild(registeredChild) {\n      this._registeredChild = registeredChild;\n    }\n  }]);\n\n  return InfiniteLoader;\n}(React.PureComponent);\n/**\n * Determines if the specified start/stop range is visible based on the most recently rendered range.\n */\n\n\n_defineProperty(InfiniteLoader, \"defaultProps\", {\n  minimumBatchSize: 10,\n  rowCount: 0,\n  threshold: 15\n});\n\nexport { InfiniteLoader as default };\nInfiniteLoader.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering a virtualized component.\n   * This function should implement the following signature:\n   * ({ onRowsRendered, registerChild }) => PropTypes.element\n   *\n   * The specified :onRowsRendered function should be passed through to the child's :onRowsRendered property.\n   * The :registerChild callback should be set as the virtualized component's :ref.\n   */\n  children: PropTypes.func.isRequired,\n\n  /**\n   * Function responsible for tracking the loaded state of each row.\n   * It should implement the following signature: ({ index: number }): boolean\n   */\n  isRowLoaded: PropTypes.func.isRequired,\n\n  /**\n   * Callback to be invoked when more rows must be loaded.\n   * It should implement the following signature: ({ startIndex, stopIndex }): Promise\n   * The returned Promise should be resolved once row data has finished loading.\n   * It will be used to determine when to refresh the list with the newly-loaded data.\n   * This callback may be called multiple times in reaction to a single scroll event.\n   */\n  loadMoreRows: PropTypes.func.isRequired,\n\n  /**\n   * Minimum number of rows to be loaded at a time.\n   * This property can be used to batch requests to reduce HTTP requests.\n   */\n  minimumBatchSize: PropTypes.number.isRequired,\n\n  /**\n   * Number of rows in list; can be arbitrary high number if actual number is unknown.\n   */\n  rowCount: PropTypes.number.isRequired,\n\n  /**\n   * Threshold at which to pre-fetch data.\n   * A threshold X means that data will start loading when a user scrolls within X rows.\n   * This value defaults to 15.\n   */\n  threshold: PropTypes.number.isRequired\n} : {};\nexport function isRangeVisible(_ref4) {\n  var lastRenderedStartIndex = _ref4.lastRenderedStartIndex,\n      lastRenderedStopIndex = _ref4.lastRenderedStopIndex,\n      startIndex = _ref4.startIndex,\n      stopIndex = _ref4.stopIndex;\n  return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex);\n}\n/**\n * Returns all of the ranges within a larger range that contain unloaded rows.\n */\n\nexport function scanForUnloadedRanges(_ref5) {\n  var isRowLoaded = _ref5.isRowLoaded,\n      minimumBatchSize = _ref5.minimumBatchSize,\n      rowCount = _ref5.rowCount,\n      startIndex = _ref5.startIndex,\n      stopIndex = _ref5.stopIndex;\n  var unloadedRanges = [];\n  var rangeStartIndex = null;\n  var rangeStopIndex = null;\n\n  for (var index = startIndex; index <= stopIndex; index++) {\n    var loaded = isRowLoaded({\n      index: index\n    });\n\n    if (!loaded) {\n      rangeStopIndex = index;\n\n      if (rangeStartIndex === null) {\n        rangeStartIndex = index;\n      }\n    } else if (rangeStopIndex !== null) {\n      unloadedRanges.push({\n        startIndex: rangeStartIndex,\n        stopIndex: rangeStopIndex\n      });\n      rangeStartIndex = rangeStopIndex = null;\n    }\n  } // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows.\n  // Scan forward to try filling our :minimumBatchSize.\n\n\n  if (rangeStopIndex !== null) {\n    var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), rowCount - 1);\n\n    for (var _index = rangeStopIndex + 1; _index <= potentialStopIndex; _index++) {\n      if (!isRowLoaded({\n        index: _index\n      })) {\n        rangeStopIndex = _index;\n      } else {\n        break;\n      }\n    }\n\n    unloadedRanges.push({\n      startIndex: rangeStartIndex,\n      stopIndex: rangeStopIndex\n    });\n  } // Check to see if our first range ended prematurely.\n  // In this case we should scan backwards to try filling our :minimumBatchSize.\n\n\n  if (unloadedRanges.length) {\n    var firstUnloadedRange = unloadedRanges[0];\n\n    while (firstUnloadedRange.stopIndex - firstUnloadedRange.startIndex + 1 < minimumBatchSize && firstUnloadedRange.startIndex > 0) {\n      var _index2 = firstUnloadedRange.startIndex - 1;\n\n      if (!isRowLoaded({\n        index: _index2\n      })) {\n        firstUnloadedRange.startIndex = _index2;\n      } else {\n        break;\n      }\n    }\n  }\n\n  return unloadedRanges;\n}\n/**\n * Since RV components use shallowCompare we need to force a render (even though props haven't changed).\n * However InfiniteLoader may wrap a Grid or it may wrap a Table or List.\n * In the first case the built-in React forceUpdate() method is sufficient to force a re-render,\n * But in the latter cases we need to use the RV-specific forceUpdateGrid() method.\n * Else the inner Grid will not be re-rendered and visuals may be stale.\n *\n * Additionally, while a Grid is scrolling the cells can be cached,\n * So it's important to invalidate that cache by recalculating sizes\n * before forcing a rerender.\n */\n\nexport function forceUpdateReactVirtualizedComponent(component) {\n  var currentIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var recomputeSize = typeof component.recomputeGridSize === 'function' ? component.recomputeGridSize : component.recomputeRowHeights;\n\n  if (recomputeSize) {\n    recomputeSize.call(component, currentIndex);\n  } else {\n    component.forceUpdate();\n  }\n}","import * as React from 'react';\nvar bpfrpt_proptype_RowRendererParams = process.env.NODE_ENV === 'production' ? null : {\n  \"index\": PropTypes.number.isRequired,\n  \"isScrolling\": PropTypes.bool.isRequired,\n  \"isVisible\": PropTypes.bool.isRequired,\n  \"key\": PropTypes.string.isRequired,\n  \"parent\": PropTypes.object.isRequired,\n  \"style\": PropTypes.object.isRequired\n};\nvar bpfrpt_proptype_RowRenderer = process.env.NODE_ENV === 'production' ? null : PropTypes.func;\nvar bpfrpt_proptype_RenderedRows = process.env.NODE_ENV === 'production' ? null : {\n  \"overscanStartIndex\": PropTypes.number.isRequired,\n  \"overscanStopIndex\": PropTypes.number.isRequired,\n  \"startIndex\": PropTypes.number.isRequired,\n  \"stopIndex\": PropTypes.number.isRequired\n};\nvar bpfrpt_proptype_Scroll = process.env.NODE_ENV === 'production' ? null : {\n  \"clientHeight\": PropTypes.number.isRequired,\n  \"scrollHeight\": PropTypes.number.isRequired,\n  \"scrollTop\": PropTypes.number.isRequired\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_RowRendererParams };\nexport { bpfrpt_proptype_RowRenderer };\nexport { bpfrpt_proptype_RenderedRows };\nexport { bpfrpt_proptype_Scroll };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nimport Grid, { accessibilityOverscanIndicesGetter } from '../Grid';\nimport * as React from 'react';\nimport clsx from 'clsx';\n/**\n * It is inefficient to create and manage a large list of DOM elements within a scrolling container\n * if only a few of those elements are visible. The primary purpose of this component is to improve\n * performance by only rendering the DOM nodes that a user is able to see based on their current\n * scroll position.\n *\n * This component renders a virtualized list of elements with either fixed or dynamic heights.\n */\n\nvar List = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(List, _React$PureComponent);\n\n  function List() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, List);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(List)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"Grid\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRenderer\", function (_ref) {\n      var parent = _ref.parent,\n          rowIndex = _ref.rowIndex,\n          style = _ref.style,\n          isScrolling = _ref.isScrolling,\n          isVisible = _ref.isVisible,\n          key = _ref.key;\n      var rowRenderer = _this.props.rowRenderer; // TRICKY The style object is sometimes cached by Grid.\n      // This prevents new style objects from bypassing shallowCompare().\n      // However as of React 16, style props are auto-frozen (at least in dev mode)\n      // Check to make sure we can still modify the style before proceeding.\n      // https://github.com/facebook/react/commit/977357765b44af8ff0cfea327866861073095c12#commitcomment-20648713\n\n      var widthDescriptor = Object.getOwnPropertyDescriptor(style, 'width');\n\n      if (widthDescriptor && widthDescriptor.writable) {\n        // By default, List cells should be 100% width.\n        // This prevents them from flowing under a scrollbar (if present).\n        style.width = '100%';\n      }\n\n      return rowRenderer({\n        index: rowIndex,\n        style: style,\n        isScrolling: isScrolling,\n        isVisible: isVisible,\n        key: key,\n        parent: parent\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setRef\", function (ref) {\n      _this.Grid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (_ref2) {\n      var clientHeight = _ref2.clientHeight,\n          scrollHeight = _ref2.scrollHeight,\n          scrollTop = _ref2.scrollTop;\n      var onScroll = _this.props.onScroll;\n      onScroll({\n        clientHeight: clientHeight,\n        scrollHeight: scrollHeight,\n        scrollTop: scrollTop\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRendered\", function (_ref3) {\n      var rowOverscanStartIndex = _ref3.rowOverscanStartIndex,\n          rowOverscanStopIndex = _ref3.rowOverscanStopIndex,\n          rowStartIndex = _ref3.rowStartIndex,\n          rowStopIndex = _ref3.rowStopIndex;\n      var onRowsRendered = _this.props.onRowsRendered;\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    });\n\n    return _this;\n  }\n\n  _createClass(List, [{\n    key: \"forceUpdateGrid\",\n    value: function forceUpdateGrid() {\n      if (this.Grid) {\n        this.Grid.forceUpdate();\n      }\n    }\n    /** See Grid#getOffsetForCell */\n\n  }, {\n    key: \"getOffsetForRow\",\n    value: function getOffsetForRow(_ref4) {\n      var alignment = _ref4.alignment,\n          index = _ref4.index;\n\n      if (this.Grid) {\n        var _this$Grid$getOffsetF = this.Grid.getOffsetForCell({\n          alignment: alignment,\n          rowIndex: index,\n          columnIndex: 0\n        }),\n            scrollTop = _this$Grid$getOffsetF.scrollTop;\n\n        return scrollTop;\n      }\n\n      return 0;\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref5) {\n      var columnIndex = _ref5.columnIndex,\n          rowIndex = _ref5.rowIndex;\n\n      if (this.Grid) {\n        this.Grid.invalidateCellSizeAfterRender({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllRows\",\n    value: function measureAllRows() {\n      if (this.Grid) {\n        this.Grid.measureAllCells();\n      }\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref6$columnIndex = _ref6.columnIndex,\n          columnIndex = _ref6$columnIndex === void 0 ? 0 : _ref6$columnIndex,\n          _ref6$rowIndex = _ref6.rowIndex,\n          rowIndex = _ref6$rowIndex === void 0 ? 0 : _ref6$rowIndex;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeRowHeights\",\n    value: function recomputeRowHeights() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: index,\n          columnIndex: 0\n        });\n      }\n    }\n    /** See Grid#scrollToPosition */\n\n  }, {\n    key: \"scrollToPosition\",\n    value: function scrollToPosition() {\n      var scrollTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToPosition({\n          scrollTop: scrollTop\n        });\n      }\n    }\n    /** See Grid#scrollToCell */\n\n  }, {\n    key: \"scrollToRow\",\n    value: function scrollToRow() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToCell({\n          columnIndex: 0,\n          rowIndex: index\n        });\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props = this.props,\n          className = _this$props.className,\n          noRowsRenderer = _this$props.noRowsRenderer,\n          scrollToIndex = _this$props.scrollToIndex,\n          width = _this$props.width;\n      var classNames = clsx('ReactVirtualized__List', className);\n      return React.createElement(Grid, _extends({}, this.props, {\n        autoContainerWidth: true,\n        cellRenderer: this._cellRenderer,\n        className: classNames,\n        columnWidth: width,\n        columnCount: 1,\n        noContentRenderer: noRowsRenderer,\n        onScroll: this._onScroll,\n        onSectionRendered: this._onSectionRendered,\n        ref: this._setRef,\n        scrollToRow: scrollToIndex\n      }));\n    }\n  }]);\n\n  return List;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  \"autoHeight\": PropTypes.bool.isRequired,\n\n  /** Optional CSS class name */\n  \"className\": PropTypes.string,\n\n  /**\n   * Used to estimate the total height of a List before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  \"estimatedRowSize\": PropTypes.number.isRequired,\n\n  /** Height constraint for list (determines how many actual rows are rendered) */\n  \"height\": PropTypes.number.isRequired,\n\n  /** Optional renderer to be used in place of rows when rowCount is 0 */\n  \"noRowsRenderer\": function noRowsRenderer() {\n    return (typeof bpfrpt_proptype_NoContentRenderer === \"function\" ? bpfrpt_proptype_NoContentRenderer.isRequired ? bpfrpt_proptype_NoContentRenderer.isRequired : bpfrpt_proptype_NoContentRenderer : PropTypes.shape(bpfrpt_proptype_NoContentRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Callback invoked with information about the slice of rows that were just rendered.  */\n  \"onRowsRendered\": PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /** See Grid#overscanIndicesGetter */\n  \"overscanIndicesGetter\": function overscanIndicesGetter() {\n    return (typeof bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? bpfrpt_proptype_OverscanIndicesGetter.isRequired ? bpfrpt_proptype_OverscanIndicesGetter.isRequired : bpfrpt_proptype_OverscanIndicesGetter : PropTypes.shape(bpfrpt_proptype_OverscanIndicesGetter).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  \"overscanRowCount\": PropTypes.number.isRequired,\n\n  /** Either a fixed row height (number) or a function that returns the height of a row given its index.  */\n  \"rowHeight\": function rowHeight() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Responsible for rendering a row given an index; ({ index: number }): node */\n  \"rowRenderer\": function rowRenderer() {\n    return (typeof bpfrpt_proptype_RowRenderer === \"function\" ? bpfrpt_proptype_RowRenderer.isRequired ? bpfrpt_proptype_RowRenderer.isRequired : bpfrpt_proptype_RowRenderer : PropTypes.shape(bpfrpt_proptype_RowRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in list. */\n  \"rowCount\": PropTypes.number.isRequired,\n\n  /** See Grid#scrollToAlignment */\n  \"scrollToAlignment\": function scrollToAlignment() {\n    return (typeof bpfrpt_proptype_Alignment === \"function\" ? bpfrpt_proptype_Alignment.isRequired ? bpfrpt_proptype_Alignment.isRequired : bpfrpt_proptype_Alignment : PropTypes.shape(bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToIndex\": PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": PropTypes.number,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": PropTypes.number,\n\n  /** Width of list */\n  \"width\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(List, \"defaultProps\", {\n  autoHeight: false,\n  estimatedRowSize: 30,\n  onScroll: function onScroll() {},\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {},\n  overscanIndicesGetter: accessibilityOverscanIndicesGetter,\n  overscanRowCount: 10,\n  scrollToAlignment: 'auto',\n  scrollToIndex: -1,\n  style: {}\n});\n\nexport { List as default };\nimport { bpfrpt_proptype_NoContentRenderer } from \"../Grid\";\nimport { bpfrpt_proptype_Alignment } from \"../Grid\";\nimport { bpfrpt_proptype_CellSize } from \"../Grid\";\nimport { bpfrpt_proptype_CellPosition } from \"../Grid\";\nimport { bpfrpt_proptype_OverscanIndicesGetter } from \"../Grid\";\nimport { bpfrpt_proptype_RenderedSection } from \"../Grid\";\nimport { bpfrpt_proptype_CellRendererParams } from \"../Grid\";\nimport { bpfrpt_proptype_Scroll as bpfrpt_proptype_GridScroll } from \"../Grid\";\nimport { bpfrpt_proptype_RowRenderer } from \"./types\";\nimport { bpfrpt_proptype_RenderedRows } from \"./types\";\nimport { bpfrpt_proptype_Scroll } from \"./types\";\nimport PropTypes from \"prop-types\";","/**\n * Binary Search Bounds\n * https://github.com/mikolalysenko/binary-search-bounds\n * Mikola Lysenko\n *\n * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax.\n * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5\n **/\nfunction _GEA(a, l, h, y) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x >= y) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _GEP(a, l, h, y, c) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) >= 0) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchGE(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _GEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _GEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _GTA(a, l, h, y) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x > y) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _GTP(a, l, h, y, c) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) > 0) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchGT(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _GTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _GTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _LTA(a, l, h, y) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x < y) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _LTP(a, l, h, y, c) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) < 0) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchLT(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _LTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _LTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _LEA(a, l, h, y) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x <= y) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _LEP(a, l, h, y, c) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) <= 0) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchLE(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _LEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _LEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _EQA(a, l, h, y) {\n  l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x === y) {\n      return m;\n    } else if (x <= y) {\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return -1;\n}\n\nfunction _EQP(a, l, h, y, c) {\n  l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n    var p = c(x, y);\n\n    if (p === 0) {\n      return m;\n    } else if (p <= 0) {\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return -1;\n}\n\nfunction dispatchBsearchEQ(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _EQP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _EQA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nexport default {\n  ge: dispatchBsearchGE,\n  gt: dispatchBsearchGT,\n  lt: dispatchBsearchLT,\n  le: dispatchBsearchLE,\n  eq: dispatchBsearchEQ\n};","/**\n * Binary Search Bounds\n * https://github.com/mikolalysenko/interval-tree-1d\n * Mikola Lysenko\n *\n * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax in an upstream dependency.\n * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5\n **/\nimport bounds from './binarySearchBounds';\nvar NOT_FOUND = 0;\nvar SUCCESS = 1;\nvar EMPTY = 2;\n\nfunction IntervalTreeNode(mid, left, right, leftPoints, rightPoints) {\n  this.mid = mid;\n  this.left = left;\n  this.right = right;\n  this.leftPoints = leftPoints;\n  this.rightPoints = rightPoints;\n  this.count = (left ? left.count : 0) + (right ? right.count : 0) + leftPoints.length;\n}\n\nvar proto = IntervalTreeNode.prototype;\n\nfunction copy(a, b) {\n  a.mid = b.mid;\n  a.left = b.left;\n  a.right = b.right;\n  a.leftPoints = b.leftPoints;\n  a.rightPoints = b.rightPoints;\n  a.count = b.count;\n}\n\nfunction rebuild(node, intervals) {\n  var ntree = createIntervalTree(intervals);\n  node.mid = ntree.mid;\n  node.left = ntree.left;\n  node.right = ntree.right;\n  node.leftPoints = ntree.leftPoints;\n  node.rightPoints = ntree.rightPoints;\n  node.count = ntree.count;\n}\n\nfunction rebuildWithInterval(node, interval) {\n  var intervals = node.intervals([]);\n  intervals.push(interval);\n  rebuild(node, intervals);\n}\n\nfunction rebuildWithoutInterval(node, interval) {\n  var intervals = node.intervals([]);\n  var idx = intervals.indexOf(interval);\n\n  if (idx < 0) {\n    return NOT_FOUND;\n  }\n\n  intervals.splice(idx, 1);\n  rebuild(node, intervals);\n  return SUCCESS;\n}\n\nproto.intervals = function (result) {\n  result.push.apply(result, this.leftPoints);\n\n  if (this.left) {\n    this.left.intervals(result);\n  }\n\n  if (this.right) {\n    this.right.intervals(result);\n  }\n\n  return result;\n};\n\nproto.insert = function (interval) {\n  var weight = this.count - this.leftPoints.length;\n  this.count += 1;\n\n  if (interval[1] < this.mid) {\n    if (this.left) {\n      if (4 * (this.left.count + 1) > 3 * (weight + 1)) {\n        rebuildWithInterval(this, interval);\n      } else {\n        this.left.insert(interval);\n      }\n    } else {\n      this.left = createIntervalTree([interval]);\n    }\n  } else if (interval[0] > this.mid) {\n    if (this.right) {\n      if (4 * (this.right.count + 1) > 3 * (weight + 1)) {\n        rebuildWithInterval(this, interval);\n      } else {\n        this.right.insert(interval);\n      }\n    } else {\n      this.right = createIntervalTree([interval]);\n    }\n  } else {\n    var l = bounds.ge(this.leftPoints, interval, compareBegin);\n    var r = bounds.ge(this.rightPoints, interval, compareEnd);\n    this.leftPoints.splice(l, 0, interval);\n    this.rightPoints.splice(r, 0, interval);\n  }\n};\n\nproto.remove = function (interval) {\n  var weight = this.count - this.leftPoints;\n\n  if (interval[1] < this.mid) {\n    if (!this.left) {\n      return NOT_FOUND;\n    }\n\n    var rw = this.right ? this.right.count : 0;\n\n    if (4 * rw > 3 * (weight - 1)) {\n      return rebuildWithoutInterval(this, interval);\n    }\n\n    var r = this.left.remove(interval);\n\n    if (r === EMPTY) {\n      this.left = null;\n      this.count -= 1;\n      return SUCCESS;\n    } else if (r === SUCCESS) {\n      this.count -= 1;\n    }\n\n    return r;\n  } else if (interval[0] > this.mid) {\n    if (!this.right) {\n      return NOT_FOUND;\n    }\n\n    var lw = this.left ? this.left.count : 0;\n\n    if (4 * lw > 3 * (weight - 1)) {\n      return rebuildWithoutInterval(this, interval);\n    }\n\n    var r = this.right.remove(interval);\n\n    if (r === EMPTY) {\n      this.right = null;\n      this.count -= 1;\n      return SUCCESS;\n    } else if (r === SUCCESS) {\n      this.count -= 1;\n    }\n\n    return r;\n  } else {\n    if (this.count === 1) {\n      if (this.leftPoints[0] === interval) {\n        return EMPTY;\n      } else {\n        return NOT_FOUND;\n      }\n    }\n\n    if (this.leftPoints.length === 1 && this.leftPoints[0] === interval) {\n      if (this.left && this.right) {\n        var p = this;\n        var n = this.left;\n\n        while (n.right) {\n          p = n;\n          n = n.right;\n        }\n\n        if (p === this) {\n          n.right = this.right;\n        } else {\n          var l = this.left;\n          var r = this.right;\n          p.count -= n.count;\n          p.right = n.left;\n          n.left = l;\n          n.right = r;\n        }\n\n        copy(this, n);\n        this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;\n      } else if (this.left) {\n        copy(this, this.left);\n      } else {\n        copy(this, this.right);\n      }\n\n      return SUCCESS;\n    }\n\n    for (var l = bounds.ge(this.leftPoints, interval, compareBegin); l < this.leftPoints.length; ++l) {\n      if (this.leftPoints[l][0] !== interval[0]) {\n        break;\n      }\n\n      if (this.leftPoints[l] === interval) {\n        this.count -= 1;\n        this.leftPoints.splice(l, 1);\n\n        for (var r = bounds.ge(this.rightPoints, interval, compareEnd); r < this.rightPoints.length; ++r) {\n          if (this.rightPoints[r][1] !== interval[1]) {\n            break;\n          } else if (this.rightPoints[r] === interval) {\n            this.rightPoints.splice(r, 1);\n            return SUCCESS;\n          }\n        }\n      }\n    }\n\n    return NOT_FOUND;\n  }\n};\n\nfunction reportLeftRange(arr, hi, cb) {\n  for (var i = 0; i < arr.length && arr[i][0] <= hi; ++i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nfunction reportRightRange(arr, lo, cb) {\n  for (var i = arr.length - 1; i >= 0 && arr[i][1] >= lo; --i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nfunction reportRange(arr, cb) {\n  for (var i = 0; i < arr.length; ++i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nproto.queryPoint = function (x, cb) {\n  if (x < this.mid) {\n    if (this.left) {\n      var r = this.left.queryPoint(x, cb);\n\n      if (r) {\n        return r;\n      }\n    }\n\n    return reportLeftRange(this.leftPoints, x, cb);\n  } else if (x > this.mid) {\n    if (this.right) {\n      var r = this.right.queryPoint(x, cb);\n\n      if (r) {\n        return r;\n      }\n    }\n\n    return reportRightRange(this.rightPoints, x, cb);\n  } else {\n    return reportRange(this.leftPoints, cb);\n  }\n};\n\nproto.queryInterval = function (lo, hi, cb) {\n  if (lo < this.mid && this.left) {\n    var r = this.left.queryInterval(lo, hi, cb);\n\n    if (r) {\n      return r;\n    }\n  }\n\n  if (hi > this.mid && this.right) {\n    var r = this.right.queryInterval(lo, hi, cb);\n\n    if (r) {\n      return r;\n    }\n  }\n\n  if (hi < this.mid) {\n    return reportLeftRange(this.leftPoints, hi, cb);\n  } else if (lo > this.mid) {\n    return reportRightRange(this.rightPoints, lo, cb);\n  } else {\n    return reportRange(this.leftPoints, cb);\n  }\n};\n\nfunction compareNumbers(a, b) {\n  return a - b;\n}\n\nfunction compareBegin(a, b) {\n  var d = a[0] - b[0];\n\n  if (d) {\n    return d;\n  }\n\n  return a[1] - b[1];\n}\n\nfunction compareEnd(a, b) {\n  var d = a[1] - b[1];\n\n  if (d) {\n    return d;\n  }\n\n  return a[0] - b[0];\n}\n\nfunction createIntervalTree(intervals) {\n  if (intervals.length === 0) {\n    return null;\n  }\n\n  var pts = [];\n\n  for (var i = 0; i < intervals.length; ++i) {\n    pts.push(intervals[i][0], intervals[i][1]);\n  }\n\n  pts.sort(compareNumbers);\n  var mid = pts[pts.length >> 1];\n  var leftIntervals = [];\n  var rightIntervals = [];\n  var centerIntervals = [];\n\n  for (var i = 0; i < intervals.length; ++i) {\n    var s = intervals[i];\n\n    if (s[1] < mid) {\n      leftIntervals.push(s);\n    } else if (mid < s[0]) {\n      rightIntervals.push(s);\n    } else {\n      centerIntervals.push(s);\n    }\n  } //Split center intervals\n\n\n  var leftPoints = centerIntervals;\n  var rightPoints = centerIntervals.slice();\n  leftPoints.sort(compareBegin);\n  rightPoints.sort(compareEnd);\n  return new IntervalTreeNode(mid, createIntervalTree(leftIntervals), createIntervalTree(rightIntervals), leftPoints, rightPoints);\n} //User friendly wrapper that makes it possible to support empty trees\n\n\nfunction IntervalTree(root) {\n  this.root = root;\n}\n\nvar tproto = IntervalTree.prototype;\n\ntproto.insert = function (interval) {\n  if (this.root) {\n    this.root.insert(interval);\n  } else {\n    this.root = new IntervalTreeNode(interval[0], null, null, [interval], [interval]);\n  }\n};\n\ntproto.remove = function (interval) {\n  if (this.root) {\n    var r = this.root.remove(interval);\n\n    if (r === EMPTY) {\n      this.root = null;\n    }\n\n    return r !== NOT_FOUND;\n  }\n\n  return false;\n};\n\ntproto.queryPoint = function (p, cb) {\n  if (this.root) {\n    return this.root.queryPoint(p, cb);\n  }\n};\n\ntproto.queryInterval = function (lo, hi, cb) {\n  if (lo <= hi && this.root) {\n    return this.root.queryInterval(lo, hi, cb);\n  }\n};\n\nObject.defineProperty(tproto, 'count', {\n  get: function get() {\n    if (this.root) {\n      return this.root.count;\n    }\n\n    return 0;\n  }\n});\nObject.defineProperty(tproto, 'intervals', {\n  get: function get() {\n    if (this.root) {\n      return this.root.intervals([]);\n    }\n\n    return [];\n  }\n});\nexport default function createWrapper(intervals) {\n  if (!intervals || intervals.length === 0) {\n    return new IntervalTree(null);\n  }\n\n  return new IntervalTree(createIntervalTree(intervals));\n}","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport createIntervalTree from '../vendor/intervalTree';\n\n// Position cache requirements:\n//   O(log(n)) lookup of cells to render for a given viewport size\n//   O(1) lookup of shortest measured column (so we know when to enter phase 1)\nvar PositionCache =\n/*#__PURE__*/\nfunction () {\n  function PositionCache() {\n    _classCallCheck(this, PositionCache);\n\n    _defineProperty(this, \"_columnSizeMap\", {});\n\n    _defineProperty(this, \"_intervalTree\", createIntervalTree());\n\n    _defineProperty(this, \"_leftMap\", {});\n  }\n\n  _createClass(PositionCache, [{\n    key: \"estimateTotalHeight\",\n    value: function estimateTotalHeight(cellCount, columnCount, defaultCellHeight) {\n      var unmeasuredCellCount = cellCount - this.count;\n      return this.tallestColumnSize + Math.ceil(unmeasuredCellCount / columnCount) * defaultCellHeight;\n    } // Render all cells visible within the viewport range defined.\n\n  }, {\n    key: \"range\",\n    value: function range(scrollTop, clientHeight, renderCallback) {\n      var _this = this;\n\n      this._intervalTree.queryInterval(scrollTop, scrollTop + clientHeight, function (_ref) {\n        var _ref2 = _slicedToArray(_ref, 3),\n            top = _ref2[0],\n            _ = _ref2[1],\n            index = _ref2[2];\n\n        return renderCallback(index, _this._leftMap[index], top);\n      });\n    }\n  }, {\n    key: \"setPosition\",\n    value: function setPosition(index, left, top, height) {\n      this._intervalTree.insert([top, top + height, index]);\n\n      this._leftMap[index] = left;\n      var columnSizeMap = this._columnSizeMap;\n      var columnHeight = columnSizeMap[left];\n\n      if (columnHeight === undefined) {\n        columnSizeMap[left] = top + height;\n      } else {\n        columnSizeMap[left] = Math.max(columnHeight, top + height);\n      }\n    }\n  }, {\n    key: \"count\",\n    get: function get() {\n      return this._intervalTree.count;\n    }\n  }, {\n    key: \"shortestColumnSize\",\n    get: function get() {\n      var columnSizeMap = this._columnSizeMap;\n      var size = 0;\n\n      for (var i in columnSizeMap) {\n        var height = columnSizeMap[i];\n        size = size === 0 ? height : Math.min(size, height);\n      }\n\n      return size;\n    }\n  }, {\n    key: \"tallestColumnSize\",\n    get: function get() {\n      var columnSizeMap = this._columnSizeMap;\n      var size = 0;\n\n      for (var i in columnSizeMap) {\n        var height = columnSizeMap[i];\n        size = Math.max(size, height);\n      }\n\n      return size;\n    }\n  }]);\n\n  return PositionCache;\n}();\n\nexport { PositionCache as default };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport PositionCache from './PositionCache';\nimport { requestAnimationTimeout, cancelAnimationTimeout } from '../utils/requestAnimationTimeout';\nvar emptyObject = {};\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nexport var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;\n/**\n * This component efficiently displays arbitrarily positioned cells using windowing techniques.\n * Cell position is determined by an injected `cellPositioner` property.\n * Windowing is vertical; this component does not support horizontal scrolling.\n *\n * Rendering occurs in two phases:\n * 1) First pass uses estimated cell sizes (provided by the cache) to determine how many cells to measure in a batch.\n *    Batch size is chosen using a fast, naive layout algorithm that stacks images in order until the viewport has been filled.\n *    After measurement is complete (componentDidMount or componentDidUpdate) this component evaluates positioned cells\n *    in order to determine if another measurement pass is required (eg if actual cell sizes were less than estimated sizes).\n *    All measurements are permanently cached (keyed by `keyMapper`) for performance purposes.\n * 2) Second pass uses the external `cellPositioner` to layout cells.\n *    At this time the positioner has access to cached size measurements for all cells.\n *    The positions it returns are cached by Masonry for fast access later.\n *    Phase one is repeated if the user scrolls beyond the current layout's bounds.\n *    If the layout is invalidated due to eg a resize, cached positions can be cleared using `recomputeCellPositions()`.\n *\n * Animation constraints:\n *   Simple animations are supported (eg translate/slide into place on initial reveal).\n *   More complex animations are not (eg flying from one position to another on resize).\n *\n * Layout constraints:\n *   This component supports multi-column layout.\n *   The height of each item may vary.\n *   The width of each item must not exceed the width of the column it is \"in\".\n *   The left position of all items within a column must align.\n *   (Items may not span multiple columns.)\n */\n\nvar Masonry = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Masonry, _React$PureComponent);\n\n  function Masonry() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, Masonry);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Masonry)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      isScrolling: false,\n      scrollTop: 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceResetIsScrollingId\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_invalidateOnUpdateStartIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_invalidateOnUpdateStopIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionCache\", new PositionCache());\n\n    _defineProperty(_assertThisInitialized(_this), \"_startIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_startIndexMemoized\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_stopIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_stopIndexMemoized\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceResetIsScrollingCallback\", function () {\n      _this.setState({\n        isScrolling: false\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      var height = _this.props.height;\n      var eventScrollTop = event.currentTarget.scrollTop; // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.\n\n      var scrollTop = Math.min(Math.max(0, _this._getEstimatedTotalHeight() - height), eventScrollTop); // On iOS, we can arrive at negative offsets by swiping past the start or end.\n      // Avoid re-rendering in this case as it can cause problems; see #532 for more.\n\n      if (eventScrollTop !== scrollTop) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      _this._debounceResetIsScrolling(); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n\n      if (_this.state.scrollTop !== scrollTop) {\n        _this.setState({\n          isScrolling: true,\n          scrollTop: scrollTop\n        });\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(Masonry, [{\n    key: \"clearCellPositions\",\n    value: function clearCellPositions() {\n      this._positionCache = new PositionCache();\n      this.forceUpdate();\n    } // HACK This method signature was intended for Grid\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref) {\n      var index = _ref.rowIndex;\n\n      if (this._invalidateOnUpdateStartIndex === null) {\n        this._invalidateOnUpdateStartIndex = index;\n        this._invalidateOnUpdateStopIndex = index;\n      } else {\n        this._invalidateOnUpdateStartIndex = Math.min(this._invalidateOnUpdateStartIndex, index);\n        this._invalidateOnUpdateStopIndex = Math.max(this._invalidateOnUpdateStopIndex, index);\n      }\n    }\n  }, {\n    key: \"recomputeCellPositions\",\n    value: function recomputeCellPositions() {\n      var stopIndex = this._positionCache.count - 1;\n      this._positionCache = new PositionCache();\n\n      this._populatePositionCache(0, stopIndex);\n\n      this.forceUpdate();\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._checkInvalidateOnUpdate();\n\n      this._invokeOnScrollCallback();\n\n      this._invokeOnCellsRenderedCallback();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      this._checkInvalidateOnUpdate();\n\n      this._invokeOnScrollCallback();\n\n      this._invokeOnCellsRenderedCallback();\n\n      if (this.props.scrollTop !== prevProps.scrollTop) {\n        this._debounceResetIsScrolling();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._debounceResetIsScrollingId) {\n        cancelAnimationTimeout(this._debounceResetIsScrollingId);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this2 = this;\n\n      var _this$props = this.props,\n          autoHeight = _this$props.autoHeight,\n          cellCount = _this$props.cellCount,\n          cellMeasurerCache = _this$props.cellMeasurerCache,\n          cellRenderer = _this$props.cellRenderer,\n          className = _this$props.className,\n          height = _this$props.height,\n          id = _this$props.id,\n          keyMapper = _this$props.keyMapper,\n          overscanByPixels = _this$props.overscanByPixels,\n          role = _this$props.role,\n          style = _this$props.style,\n          tabIndex = _this$props.tabIndex,\n          width = _this$props.width,\n          rowDirection = _this$props.rowDirection;\n      var _this$state = this.state,\n          isScrolling = _this$state.isScrolling,\n          scrollTop = _this$state.scrollTop;\n      var children = [];\n\n      var estimateTotalHeight = this._getEstimatedTotalHeight();\n\n      var shortestColumnSize = this._positionCache.shortestColumnSize;\n      var measuredCellCount = this._positionCache.count;\n      var startIndex = 0;\n      var stopIndex;\n\n      this._positionCache.range(Math.max(0, scrollTop - overscanByPixels), height + overscanByPixels * 2, function (index, left, top) {\n        var _style;\n\n        if (typeof stopIndex === 'undefined') {\n          startIndex = index;\n          stopIndex = index;\n        } else {\n          startIndex = Math.min(startIndex, index);\n          stopIndex = Math.max(stopIndex, index);\n        }\n\n        children.push(cellRenderer({\n          index: index,\n          isScrolling: isScrolling,\n          key: keyMapper(index),\n          parent: _this2,\n          style: (_style = {\n            height: cellMeasurerCache.getHeight(index)\n          }, _defineProperty(_style, rowDirection === 'ltr' ? 'left' : 'right', left), _defineProperty(_style, \"position\", 'absolute'), _defineProperty(_style, \"top\", top), _defineProperty(_style, \"width\", cellMeasurerCache.getWidth(index)), _style)\n        }));\n      }); // We need to measure additional cells for this layout\n\n\n      if (shortestColumnSize < scrollTop + height + overscanByPixels && measuredCellCount < cellCount) {\n        var batchSize = Math.min(cellCount - measuredCellCount, Math.ceil((scrollTop + height + overscanByPixels - shortestColumnSize) / cellMeasurerCache.defaultHeight * width / cellMeasurerCache.defaultWidth));\n\n        for (var _index = measuredCellCount; _index < measuredCellCount + batchSize; _index++) {\n          stopIndex = _index;\n          children.push(cellRenderer({\n            index: _index,\n            isScrolling: isScrolling,\n            key: keyMapper(_index),\n            parent: this,\n            style: {\n              width: cellMeasurerCache.getWidth(_index)\n            }\n          }));\n        }\n      }\n\n      this._startIndex = startIndex;\n      this._stopIndex = stopIndex;\n      return React.createElement(\"div\", {\n        ref: this._setScrollingContainerRef,\n        \"aria-label\": this.props['aria-label'],\n        className: clsx('ReactVirtualized__Masonry', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: role,\n        style: _objectSpread({\n          boxSizing: 'border-box',\n          direction: 'ltr',\n          height: autoHeight ? 'auto' : height,\n          overflowX: 'hidden',\n          overflowY: estimateTotalHeight < height ? 'hidden' : 'auto',\n          position: 'relative',\n          width: width,\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform'\n        }, style),\n        tabIndex: tabIndex\n      }, React.createElement(\"div\", {\n        className: \"ReactVirtualized__Masonry__innerScrollContainer\",\n        style: {\n          width: '100%',\n          height: estimateTotalHeight,\n          maxWidth: '100%',\n          maxHeight: estimateTotalHeight,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          position: 'relative'\n        }\n      }, children));\n    }\n  }, {\n    key: \"_checkInvalidateOnUpdate\",\n    value: function _checkInvalidateOnUpdate() {\n      if (typeof this._invalidateOnUpdateStartIndex === 'number') {\n        var startIndex = this._invalidateOnUpdateStartIndex;\n        var stopIndex = this._invalidateOnUpdateStopIndex;\n        this._invalidateOnUpdateStartIndex = null;\n        this._invalidateOnUpdateStopIndex = null; // Query external layout logic for position of newly-measured cells\n\n        this._populatePositionCache(startIndex, stopIndex);\n\n        this.forceUpdate();\n      }\n    }\n  }, {\n    key: \"_debounceResetIsScrolling\",\n    value: function _debounceResetIsScrolling() {\n      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;\n\n      if (this._debounceResetIsScrollingId) {\n        cancelAnimationTimeout(this._debounceResetIsScrollingId);\n      }\n\n      this._debounceResetIsScrollingId = requestAnimationTimeout(this._debounceResetIsScrollingCallback, scrollingResetTimeInterval);\n    }\n  }, {\n    key: \"_getEstimatedTotalHeight\",\n    value: function _getEstimatedTotalHeight() {\n      var _this$props2 = this.props,\n          cellCount = _this$props2.cellCount,\n          cellMeasurerCache = _this$props2.cellMeasurerCache,\n          width = _this$props2.width;\n      var estimatedColumnCount = Math.max(1, Math.floor(width / cellMeasurerCache.defaultWidth));\n      return this._positionCache.estimateTotalHeight(cellCount, estimatedColumnCount, cellMeasurerCache.defaultHeight);\n    }\n  }, {\n    key: \"_invokeOnScrollCallback\",\n    value: function _invokeOnScrollCallback() {\n      var _this$props3 = this.props,\n          height = _this$props3.height,\n          onScroll = _this$props3.onScroll;\n      var scrollTop = this.state.scrollTop;\n\n      if (this._onScrollMemoized !== scrollTop) {\n        onScroll({\n          clientHeight: height,\n          scrollHeight: this._getEstimatedTotalHeight(),\n          scrollTop: scrollTop\n        });\n        this._onScrollMemoized = scrollTop;\n      }\n    }\n  }, {\n    key: \"_invokeOnCellsRenderedCallback\",\n    value: function _invokeOnCellsRenderedCallback() {\n      if (this._startIndexMemoized !== this._startIndex || this._stopIndexMemoized !== this._stopIndex) {\n        var onCellsRendered = this.props.onCellsRendered;\n        onCellsRendered({\n          startIndex: this._startIndex,\n          stopIndex: this._stopIndex\n        });\n        this._startIndexMemoized = this._startIndex;\n        this._stopIndexMemoized = this._stopIndex;\n      }\n    }\n  }, {\n    key: \"_populatePositionCache\",\n    value: function _populatePositionCache(startIndex, stopIndex) {\n      var _this$props4 = this.props,\n          cellMeasurerCache = _this$props4.cellMeasurerCache,\n          cellPositioner = _this$props4.cellPositioner;\n\n      for (var _index2 = startIndex; _index2 <= stopIndex; _index2++) {\n        var _cellPositioner = cellPositioner(_index2),\n            left = _cellPositioner.left,\n            top = _cellPositioner.top;\n\n        this._positionCache.setPosition(_index2, left, top, cellMeasurerCache.getHeight(_index2));\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.scrollTop !== undefined && prevState.scrollTop !== nextProps.scrollTop) {\n        return {\n          isScrolling: true,\n          scrollTop: nextProps.scrollTop\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return Masonry;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"autoHeight\": PropTypes.bool.isRequired,\n  \"cellCount\": PropTypes.number.isRequired,\n  \"cellMeasurerCache\": function cellMeasurerCache() {\n    return (typeof CellMeasurerCache === \"function\" ? PropTypes.instanceOf(CellMeasurerCache).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"cellPositioner\": function cellPositioner() {\n    return (typeof Positioner === \"function\" ? PropTypes.instanceOf(Positioner).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"cellRenderer\": function cellRenderer() {\n    return (typeof CellRenderer === \"function\" ? PropTypes.instanceOf(CellRenderer).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"className\": PropTypes.string,\n  \"height\": PropTypes.number.isRequired,\n  \"id\": PropTypes.string,\n  \"keyMapper\": function keyMapper() {\n    return (typeof KeyMapper === \"function\" ? PropTypes.instanceOf(KeyMapper).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"onCellsRendered\": function onCellsRendered() {\n    return (typeof OnCellsRenderedCallback === \"function\" ? PropTypes.instanceOf(OnCellsRenderedCallback) : PropTypes.any).apply(this, arguments);\n  },\n  \"onScroll\": function onScroll() {\n    return (typeof OnScrollCallback === \"function\" ? PropTypes.instanceOf(OnScrollCallback) : PropTypes.any).apply(this, arguments);\n  },\n  \"overscanByPixels\": PropTypes.number.isRequired,\n  \"role\": PropTypes.string.isRequired,\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n  \"style\": function style(props, propName, componentName) {\n    if (!Object.prototype.hasOwnProperty.call(props, propName)) {\n      throw new Error(\"Prop `\".concat(propName, \"` has type 'any' or 'mixed', but was not provided to `\").concat(componentName, \"`. Pass undefined or any other value.\"));\n    }\n  },\n  \"tabIndex\": PropTypes.number.isRequired,\n  \"width\": PropTypes.number.isRequired,\n  \"rowDirection\": PropTypes.string.isRequired,\n  \"scrollTop\": PropTypes.number\n}), _temp);\n\n_defineProperty(Masonry, \"defaultProps\", {\n  autoHeight: false,\n  keyMapper: identity,\n  onCellsRendered: noop,\n  onScroll: noop,\n  overscanByPixels: 20,\n  role: 'grid',\n  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,\n  style: emptyObject,\n  tabIndex: 0,\n  rowDirection: 'ltr'\n});\n\nfunction identity(value) {\n  return value;\n}\n\nfunction noop() {}\n\nvar bpfrpt_proptype_CellMeasurerCache = process.env.NODE_ENV === 'production' ? null : {\n  \"defaultHeight\": PropTypes.number.isRequired,\n  \"defaultWidth\": PropTypes.number.isRequired,\n  \"getHeight\": PropTypes.func.isRequired,\n  \"getWidth\": PropTypes.func.isRequired\n};\npolyfill(Masonry);\nexport default Masonry;\nvar bpfrpt_proptype_Positioner = process.env.NODE_ENV === 'production' ? null : PropTypes.func;\nimport { bpfrpt_proptype_AnimationTimeoutId } from \"../utils/requestAnimationTimeout\";\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_CellMeasurerCache };\nexport { bpfrpt_proptype_Positioner };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport { CellMeasurerCache } from '../CellMeasurer';\n\n/**\n * Caches measurements for a given cell.\n */\nvar CellMeasurerCacheDecorator =\n/*#__PURE__*/\nfunction () {\n  function CellMeasurerCacheDecorator() {\n    var _this = this;\n\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, CellMeasurerCacheDecorator);\n\n    _defineProperty(this, \"_cellMeasurerCache\", void 0);\n\n    _defineProperty(this, \"_columnIndexOffset\", void 0);\n\n    _defineProperty(this, \"_rowIndexOffset\", void 0);\n\n    _defineProperty(this, \"columnWidth\", function (_ref) {\n      var index = _ref.index;\n\n      _this._cellMeasurerCache.columnWidth({\n        index: index + _this._columnIndexOffset\n      });\n    });\n\n    _defineProperty(this, \"rowHeight\", function (_ref2) {\n      var index = _ref2.index;\n\n      _this._cellMeasurerCache.rowHeight({\n        index: index + _this._rowIndexOffset\n      });\n    });\n\n    var cellMeasurerCache = params.cellMeasurerCache,\n        _params$columnIndexOf = params.columnIndexOffset,\n        columnIndexOffset = _params$columnIndexOf === void 0 ? 0 : _params$columnIndexOf,\n        _params$rowIndexOffse = params.rowIndexOffset,\n        rowIndexOffset = _params$rowIndexOffse === void 0 ? 0 : _params$rowIndexOffse;\n    this._cellMeasurerCache = cellMeasurerCache;\n    this._columnIndexOffset = columnIndexOffset;\n    this._rowIndexOffset = rowIndexOffset;\n  }\n\n  _createClass(CellMeasurerCacheDecorator, [{\n    key: \"clear\",\n    value: function clear(rowIndex, columnIndex) {\n      this._cellMeasurerCache.clear(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"clearAll\",\n    value: function clearAll() {\n      this._cellMeasurerCache.clearAll();\n    }\n  }, {\n    key: \"hasFixedHeight\",\n    value: function hasFixedHeight() {\n      return this._cellMeasurerCache.hasFixedHeight();\n    }\n  }, {\n    key: \"hasFixedWidth\",\n    value: function hasFixedWidth() {\n      return this._cellMeasurerCache.hasFixedWidth();\n    }\n  }, {\n    key: \"getHeight\",\n    value: function getHeight(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.getHeight(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"getWidth\",\n    value: function getWidth(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.getWidth(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"has\",\n    value: function has(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.has(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"set\",\n    value: function set(rowIndex, columnIndex, width, height) {\n      this._cellMeasurerCache.set(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset, width, height);\n    }\n  }, {\n    key: \"defaultHeight\",\n    get: function get() {\n      return this._cellMeasurerCache.defaultHeight;\n    }\n  }, {\n    key: \"defaultWidth\",\n    get: function get() {\n      return this._cellMeasurerCache.defaultWidth;\n    }\n  }]);\n\n  return CellMeasurerCacheDecorator;\n}();\n\nexport { CellMeasurerCacheDecorator as default };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport CellMeasurerCacheDecorator from './CellMeasurerCacheDecorator';\nimport Grid from '../Grid';\nvar SCROLLBAR_SIZE_BUFFER = 20;\n/**\n * Renders 1, 2, or 4 Grids depending on configuration.\n * A main (body) Grid will always be rendered.\n * Optionally, 1-2 Grids for sticky header rows will also be rendered.\n * If no sticky columns, only 1 sticky header Grid will be rendered.\n * If sticky columns, 2 sticky header Grids will be rendered.\n */\n\nvar MultiGrid =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(MultiGrid, _React$PureComponent);\n\n  function MultiGrid(props, context) {\n    var _this;\n\n    _classCallCheck(this, MultiGrid);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(MultiGrid).call(this, props, context));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollbarSize: 0,\n      showHorizontalScrollbar: false,\n      showVerticalScrollbar: false\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateColumnIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateRowIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_bottomLeftGridRef\", function (ref) {\n      _this._bottomLeftGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_bottomRightGridRef\", function (ref) {\n      _this._bottomRightGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererBottomLeftGrid\", function (_ref) {\n      var rowIndex = _ref.rowIndex,\n          rest = _objectWithoutProperties(_ref, [\"rowIndex\"]);\n\n      var _this$props = _this.props,\n          cellRenderer = _this$props.cellRenderer,\n          fixedRowCount = _this$props.fixedRowCount,\n          rowCount = _this$props.rowCount;\n\n      if (rowIndex === rowCount - fixedRowCount) {\n        return React.createElement(\"div\", {\n          key: rest.key,\n          style: _objectSpread({}, rest.style, {\n            height: SCROLLBAR_SIZE_BUFFER\n          })\n        });\n      } else {\n        return cellRenderer(_objectSpread({}, rest, {\n          parent: _assertThisInitialized(_this),\n          rowIndex: rowIndex + fixedRowCount\n        }));\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererBottomRightGrid\", function (_ref2) {\n      var columnIndex = _ref2.columnIndex,\n          rowIndex = _ref2.rowIndex,\n          rest = _objectWithoutProperties(_ref2, [\"columnIndex\", \"rowIndex\"]);\n\n      var _this$props2 = _this.props,\n          cellRenderer = _this$props2.cellRenderer,\n          fixedColumnCount = _this$props2.fixedColumnCount,\n          fixedRowCount = _this$props2.fixedRowCount;\n      return cellRenderer(_objectSpread({}, rest, {\n        columnIndex: columnIndex + fixedColumnCount,\n        parent: _assertThisInitialized(_this),\n        rowIndex: rowIndex + fixedRowCount\n      }));\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererTopRightGrid\", function (_ref3) {\n      var columnIndex = _ref3.columnIndex,\n          rest = _objectWithoutProperties(_ref3, [\"columnIndex\"]);\n\n      var _this$props3 = _this.props,\n          cellRenderer = _this$props3.cellRenderer,\n          columnCount = _this$props3.columnCount,\n          fixedColumnCount = _this$props3.fixedColumnCount;\n\n      if (columnIndex === columnCount - fixedColumnCount) {\n        return React.createElement(\"div\", {\n          key: rest.key,\n          style: _objectSpread({}, rest.style, {\n            width: SCROLLBAR_SIZE_BUFFER\n          })\n        });\n      } else {\n        return cellRenderer(_objectSpread({}, rest, {\n          columnIndex: columnIndex + fixedColumnCount,\n          parent: _assertThisInitialized(_this)\n        }));\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnWidthRightGrid\", function (_ref4) {\n      var index = _ref4.index;\n      var _this$props4 = _this.props,\n          columnCount = _this$props4.columnCount,\n          fixedColumnCount = _this$props4.fixedColumnCount,\n          columnWidth = _this$props4.columnWidth;\n      var _this$state = _this.state,\n          scrollbarSize = _this$state.scrollbarSize,\n          showHorizontalScrollbar = _this$state.showHorizontalScrollbar; // An extra cell is added to the count\n      // This gives the smaller Grid extra room for offset,\n      // In case the main (bottom right) Grid has a scrollbar\n      // If no scrollbar, the extra space is overflow:hidden anyway\n\n      if (showHorizontalScrollbar && index === columnCount - fixedColumnCount) {\n        return scrollbarSize;\n      }\n\n      return typeof columnWidth === 'function' ? columnWidth({\n        index: index + fixedColumnCount\n      }) : columnWidth;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (scrollInfo) {\n      var scrollLeft = scrollInfo.scrollLeft,\n          scrollTop = scrollInfo.scrollTop;\n\n      _this.setState({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      });\n\n      var onScroll = _this.props.onScroll;\n\n      if (onScroll) {\n        onScroll(scrollInfo);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollbarPresenceChange\", function (_ref5) {\n      var horizontal = _ref5.horizontal,\n          size = _ref5.size,\n          vertical = _ref5.vertical;\n      var _this$state2 = _this.state,\n          showHorizontalScrollbar = _this$state2.showHorizontalScrollbar,\n          showVerticalScrollbar = _this$state2.showVerticalScrollbar;\n\n      if (horizontal !== showHorizontalScrollbar || vertical !== showVerticalScrollbar) {\n        _this.setState({\n          scrollbarSize: size,\n          showHorizontalScrollbar: horizontal,\n          showVerticalScrollbar: vertical\n        });\n\n        var onScrollbarPresenceChange = _this.props.onScrollbarPresenceChange;\n\n        if (typeof onScrollbarPresenceChange === 'function') {\n          onScrollbarPresenceChange({\n            horizontal: horizontal,\n            size: size,\n            vertical: vertical\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollLeft\", function (scrollInfo) {\n      var scrollLeft = scrollInfo.scrollLeft;\n\n      _this._onScroll({\n        scrollLeft: scrollLeft,\n        scrollTop: _this.state.scrollTop\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollTop\", function (scrollInfo) {\n      var scrollTop = scrollInfo.scrollTop;\n\n      _this._onScroll({\n        scrollTop: scrollTop,\n        scrollLeft: _this.state.scrollLeft\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowHeightBottomGrid\", function (_ref6) {\n      var index = _ref6.index;\n      var _this$props5 = _this.props,\n          fixedRowCount = _this$props5.fixedRowCount,\n          rowCount = _this$props5.rowCount,\n          rowHeight = _this$props5.rowHeight;\n      var _this$state3 = _this.state,\n          scrollbarSize = _this$state3.scrollbarSize,\n          showVerticalScrollbar = _this$state3.showVerticalScrollbar; // An extra cell is added to the count\n      // This gives the smaller Grid extra room for offset,\n      // In case the main (bottom right) Grid has a scrollbar\n      // If no scrollbar, the extra space is overflow:hidden anyway\n\n      if (showVerticalScrollbar && index === rowCount - fixedRowCount) {\n        return scrollbarSize;\n      }\n\n      return typeof rowHeight === 'function' ? rowHeight({\n        index: index + fixedRowCount\n      }) : rowHeight;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_topLeftGridRef\", function (ref) {\n      _this._topLeftGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_topRightGridRef\", function (ref) {\n      _this._topRightGrid = ref;\n    });\n\n    var deferredMeasurementCache = props.deferredMeasurementCache,\n        _fixedColumnCount = props.fixedColumnCount,\n        _fixedRowCount = props.fixedRowCount;\n\n    _this._maybeCalculateCachedStyles(true);\n\n    if (deferredMeasurementCache) {\n      _this._deferredMeasurementCacheBottomLeftGrid = _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: 0,\n        rowIndexOffset: _fixedRowCount\n      }) : deferredMeasurementCache;\n      _this._deferredMeasurementCacheBottomRightGrid = _fixedColumnCount > 0 || _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: _fixedColumnCount,\n        rowIndexOffset: _fixedRowCount\n      }) : deferredMeasurementCache;\n      _this._deferredMeasurementCacheTopRightGrid = _fixedColumnCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: _fixedColumnCount,\n        rowIndexOffset: 0\n      }) : deferredMeasurementCache;\n    }\n\n    return _this;\n  }\n\n  _createClass(MultiGrid, [{\n    key: \"forceUpdateGrids\",\n    value: function forceUpdateGrids() {\n      this._bottomLeftGrid && this._bottomLeftGrid.forceUpdate();\n      this._bottomRightGrid && this._bottomRightGrid.forceUpdate();\n      this._topLeftGrid && this._topLeftGrid.forceUpdate();\n      this._topRightGrid && this._topRightGrid.forceUpdate();\n    }\n    /** See Grid#invalidateCellSizeAfterRender */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender() {\n      var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref7$columnIndex = _ref7.columnIndex,\n          columnIndex = _ref7$columnIndex === void 0 ? 0 : _ref7$columnIndex,\n          _ref7$rowIndex = _ref7.rowIndex,\n          rowIndex = _ref7$rowIndex === void 0 ? 0 : _ref7$rowIndex;\n\n      this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;\n      this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllCells\",\n    value: function measureAllCells() {\n      this._bottomLeftGrid && this._bottomLeftGrid.measureAllCells();\n      this._bottomRightGrid && this._bottomRightGrid.measureAllCells();\n      this._topLeftGrid && this._topLeftGrid.measureAllCells();\n      this._topRightGrid && this._topRightGrid.measureAllCells();\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref8$columnIndex = _ref8.columnIndex,\n          columnIndex = _ref8$columnIndex === void 0 ? 0 : _ref8$columnIndex,\n          _ref8$rowIndex = _ref8.rowIndex,\n          rowIndex = _ref8$rowIndex === void 0 ? 0 : _ref8$rowIndex;\n\n      var _this$props6 = this.props,\n          fixedColumnCount = _this$props6.fixedColumnCount,\n          fixedRowCount = _this$props6.fixedRowCount;\n      var adjustedColumnIndex = Math.max(0, columnIndex - fixedColumnCount);\n      var adjustedRowIndex = Math.max(0, rowIndex - fixedRowCount);\n      this._bottomLeftGrid && this._bottomLeftGrid.recomputeGridSize({\n        columnIndex: columnIndex,\n        rowIndex: adjustedRowIndex\n      });\n      this._bottomRightGrid && this._bottomRightGrid.recomputeGridSize({\n        columnIndex: adjustedColumnIndex,\n        rowIndex: adjustedRowIndex\n      });\n      this._topLeftGrid && this._topLeftGrid.recomputeGridSize({\n        columnIndex: columnIndex,\n        rowIndex: rowIndex\n      });\n      this._topRightGrid && this._topRightGrid.recomputeGridSize({\n        columnIndex: adjustedColumnIndex,\n        rowIndex: rowIndex\n      });\n      this._leftGridWidth = null;\n      this._topGridHeight = null;\n\n      this._maybeCalculateCachedStyles(true);\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props7 = this.props,\n          scrollLeft = _this$props7.scrollLeft,\n          scrollTop = _this$props7.scrollTop;\n\n      if (scrollLeft > 0 || scrollTop > 0) {\n        var newState = {};\n\n        if (scrollLeft > 0) {\n          newState.scrollLeft = scrollLeft;\n        }\n\n        if (scrollTop > 0) {\n          newState.scrollTop = scrollTop;\n        }\n\n        this.setState(newState);\n      }\n\n      this._handleInvalidatedGridSize();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._handleInvalidatedGridSize();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props8 = this.props,\n          onScroll = _this$props8.onScroll,\n          onSectionRendered = _this$props8.onSectionRendered,\n          onScrollbarPresenceChange = _this$props8.onScrollbarPresenceChange,\n          scrollLeftProp = _this$props8.scrollLeft,\n          scrollToColumn = _this$props8.scrollToColumn,\n          scrollTopProp = _this$props8.scrollTop,\n          scrollToRow = _this$props8.scrollToRow,\n          rest = _objectWithoutProperties(_this$props8, [\"onScroll\", \"onSectionRendered\", \"onScrollbarPresenceChange\", \"scrollLeft\", \"scrollToColumn\", \"scrollTop\", \"scrollToRow\"]);\n\n      this._prepareForRender(); // Don't render any of our Grids if there are no cells.\n      // This mirrors what Grid does,\n      // And prevents us from recording inaccurage measurements when used with CellMeasurer.\n\n\n      if (this.props.width === 0 || this.props.height === 0) {\n        return null;\n      } // scrollTop and scrollLeft props are explicitly filtered out and ignored\n\n\n      var _this$state4 = this.state,\n          scrollLeft = _this$state4.scrollLeft,\n          scrollTop = _this$state4.scrollTop;\n      return React.createElement(\"div\", {\n        style: this._containerOuterStyle\n      }, React.createElement(\"div\", {\n        style: this._containerTopStyle\n      }, this._renderTopLeftGrid(rest), this._renderTopRightGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        scrollLeft: scrollLeft\n      }))), React.createElement(\"div\", {\n        style: this._containerBottomStyle\n      }, this._renderBottomLeftGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        scrollTop: scrollTop\n      })), this._renderBottomRightGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        onSectionRendered: onSectionRendered,\n        scrollLeft: scrollLeft,\n        scrollToColumn: scrollToColumn,\n        scrollToRow: scrollToRow,\n        scrollTop: scrollTop\n      }))));\n    }\n  }, {\n    key: \"_getBottomGridHeight\",\n    value: function _getBottomGridHeight(props) {\n      var height = props.height;\n\n      var topGridHeight = this._getTopGridHeight(props);\n\n      return height - topGridHeight;\n    }\n  }, {\n    key: \"_getLeftGridWidth\",\n    value: function _getLeftGridWidth(props) {\n      var fixedColumnCount = props.fixedColumnCount,\n          columnWidth = props.columnWidth;\n\n      if (this._leftGridWidth == null) {\n        if (typeof columnWidth === 'function') {\n          var leftGridWidth = 0;\n\n          for (var index = 0; index < fixedColumnCount; index++) {\n            leftGridWidth += columnWidth({\n              index: index\n            });\n          }\n\n          this._leftGridWidth = leftGridWidth;\n        } else {\n          this._leftGridWidth = columnWidth * fixedColumnCount;\n        }\n      }\n\n      return this._leftGridWidth;\n    }\n  }, {\n    key: \"_getRightGridWidth\",\n    value: function _getRightGridWidth(props) {\n      var width = props.width;\n\n      var leftGridWidth = this._getLeftGridWidth(props);\n\n      return width - leftGridWidth;\n    }\n  }, {\n    key: \"_getTopGridHeight\",\n    value: function _getTopGridHeight(props) {\n      var fixedRowCount = props.fixedRowCount,\n          rowHeight = props.rowHeight;\n\n      if (this._topGridHeight == null) {\n        if (typeof rowHeight === 'function') {\n          var topGridHeight = 0;\n\n          for (var index = 0; index < fixedRowCount; index++) {\n            topGridHeight += rowHeight({\n              index: index\n            });\n          }\n\n          this._topGridHeight = topGridHeight;\n        } else {\n          this._topGridHeight = rowHeight * fixedRowCount;\n        }\n      }\n\n      return this._topGridHeight;\n    }\n  }, {\n    key: \"_handleInvalidatedGridSize\",\n    value: function _handleInvalidatedGridSize() {\n      if (typeof this._deferredInvalidateColumnIndex === 'number') {\n        var columnIndex = this._deferredInvalidateColumnIndex;\n        var rowIndex = this._deferredInvalidateRowIndex;\n        this._deferredInvalidateColumnIndex = null;\n        this._deferredInvalidateRowIndex = null;\n        this.recomputeGridSize({\n          columnIndex: columnIndex,\n          rowIndex: rowIndex\n        });\n        this.forceUpdate();\n      }\n    }\n    /**\n     * Avoid recreating inline styles each render; this bypasses Grid's shallowCompare.\n     * This method recalculates styles only when specific props change.\n     */\n\n  }, {\n    key: \"_maybeCalculateCachedStyles\",\n    value: function _maybeCalculateCachedStyles(resetAll) {\n      var _this$props9 = this.props,\n          columnWidth = _this$props9.columnWidth,\n          enableFixedColumnScroll = _this$props9.enableFixedColumnScroll,\n          enableFixedRowScroll = _this$props9.enableFixedRowScroll,\n          height = _this$props9.height,\n          fixedColumnCount = _this$props9.fixedColumnCount,\n          fixedRowCount = _this$props9.fixedRowCount,\n          rowHeight = _this$props9.rowHeight,\n          style = _this$props9.style,\n          styleBottomLeftGrid = _this$props9.styleBottomLeftGrid,\n          styleBottomRightGrid = _this$props9.styleBottomRightGrid,\n          styleTopLeftGrid = _this$props9.styleTopLeftGrid,\n          styleTopRightGrid = _this$props9.styleTopRightGrid,\n          width = _this$props9.width;\n      var sizeChange = resetAll || height !== this._lastRenderedHeight || width !== this._lastRenderedWidth;\n      var leftSizeChange = resetAll || columnWidth !== this._lastRenderedColumnWidth || fixedColumnCount !== this._lastRenderedFixedColumnCount;\n      var topSizeChange = resetAll || fixedRowCount !== this._lastRenderedFixedRowCount || rowHeight !== this._lastRenderedRowHeight;\n\n      if (resetAll || sizeChange || style !== this._lastRenderedStyle) {\n        this._containerOuterStyle = _objectSpread({\n          height: height,\n          overflow: 'visible',\n          // Let :focus outline show through\n          width: width\n        }, style);\n      }\n\n      if (resetAll || sizeChange || topSizeChange) {\n        this._containerTopStyle = {\n          height: this._getTopGridHeight(this.props),\n          position: 'relative',\n          width: width\n        };\n        this._containerBottomStyle = {\n          height: height - this._getTopGridHeight(this.props),\n          overflow: 'visible',\n          // Let :focus outline show through\n          position: 'relative',\n          width: width\n        };\n      }\n\n      if (resetAll || styleBottomLeftGrid !== this._lastRenderedStyleBottomLeftGrid) {\n        this._bottomLeftGridStyle = _objectSpread({\n          left: 0,\n          overflowX: 'hidden',\n          overflowY: enableFixedColumnScroll ? 'auto' : 'hidden',\n          position: 'absolute'\n        }, styleBottomLeftGrid);\n      }\n\n      if (resetAll || leftSizeChange || styleBottomRightGrid !== this._lastRenderedStyleBottomRightGrid) {\n        this._bottomRightGridStyle = _objectSpread({\n          left: this._getLeftGridWidth(this.props),\n          position: 'absolute'\n        }, styleBottomRightGrid);\n      }\n\n      if (resetAll || styleTopLeftGrid !== this._lastRenderedStyleTopLeftGrid) {\n        this._topLeftGridStyle = _objectSpread({\n          left: 0,\n          overflowX: 'hidden',\n          overflowY: 'hidden',\n          position: 'absolute',\n          top: 0\n        }, styleTopLeftGrid);\n      }\n\n      if (resetAll || leftSizeChange || styleTopRightGrid !== this._lastRenderedStyleTopRightGrid) {\n        this._topRightGridStyle = _objectSpread({\n          left: this._getLeftGridWidth(this.props),\n          overflowX: enableFixedRowScroll ? 'auto' : 'hidden',\n          overflowY: 'hidden',\n          position: 'absolute',\n          top: 0\n        }, styleTopRightGrid);\n      }\n\n      this._lastRenderedColumnWidth = columnWidth;\n      this._lastRenderedFixedColumnCount = fixedColumnCount;\n      this._lastRenderedFixedRowCount = fixedRowCount;\n      this._lastRenderedHeight = height;\n      this._lastRenderedRowHeight = rowHeight;\n      this._lastRenderedStyle = style;\n      this._lastRenderedStyleBottomLeftGrid = styleBottomLeftGrid;\n      this._lastRenderedStyleBottomRightGrid = styleBottomRightGrid;\n      this._lastRenderedStyleTopLeftGrid = styleTopLeftGrid;\n      this._lastRenderedStyleTopRightGrid = styleTopRightGrid;\n      this._lastRenderedWidth = width;\n    }\n  }, {\n    key: \"_prepareForRender\",\n    value: function _prepareForRender() {\n      if (this._lastRenderedColumnWidth !== this.props.columnWidth || this._lastRenderedFixedColumnCount !== this.props.fixedColumnCount) {\n        this._leftGridWidth = null;\n      }\n\n      if (this._lastRenderedFixedRowCount !== this.props.fixedRowCount || this._lastRenderedRowHeight !== this.props.rowHeight) {\n        this._topGridHeight = null;\n      }\n\n      this._maybeCalculateCachedStyles();\n\n      this._lastRenderedColumnWidth = this.props.columnWidth;\n      this._lastRenderedFixedColumnCount = this.props.fixedColumnCount;\n      this._lastRenderedFixedRowCount = this.props.fixedRowCount;\n      this._lastRenderedRowHeight = this.props.rowHeight;\n    }\n  }, {\n    key: \"_renderBottomLeftGrid\",\n    value: function _renderBottomLeftGrid(props) {\n      var enableFixedColumnScroll = props.enableFixedColumnScroll,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          rowCount = props.rowCount,\n          hideBottomLeftGridScrollbar = props.hideBottomLeftGridScrollbar;\n      var showVerticalScrollbar = this.state.showVerticalScrollbar;\n\n      if (!fixedColumnCount) {\n        return null;\n      }\n\n      var additionalRowCount = showVerticalScrollbar ? 1 : 0,\n          height = this._getBottomGridHeight(props),\n          width = this._getLeftGridWidth(props),\n          scrollbarSize = this.state.showVerticalScrollbar ? this.state.scrollbarSize : 0,\n          gridWidth = hideBottomLeftGridScrollbar ? width + scrollbarSize : width;\n\n      var bottomLeftGrid = React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererBottomLeftGrid,\n        className: this.props.classNameBottomLeftGrid,\n        columnCount: fixedColumnCount,\n        deferredMeasurementCache: this._deferredMeasurementCacheBottomLeftGrid,\n        height: height,\n        onScroll: enableFixedColumnScroll ? this._onScrollTop : undefined,\n        ref: this._bottomLeftGridRef,\n        rowCount: Math.max(0, rowCount - fixedRowCount) + additionalRowCount,\n        rowHeight: this._rowHeightBottomGrid,\n        style: this._bottomLeftGridStyle,\n        tabIndex: null,\n        width: gridWidth\n      }));\n\n      if (hideBottomLeftGridScrollbar) {\n        return React.createElement(\"div\", {\n          className: \"BottomLeftGrid_ScrollWrapper\",\n          style: _objectSpread({}, this._bottomLeftGridStyle, {\n            height: height,\n            width: width,\n            overflowY: 'hidden'\n          })\n        }, bottomLeftGrid);\n      }\n\n      return bottomLeftGrid;\n    }\n  }, {\n    key: \"_renderBottomRightGrid\",\n    value: function _renderBottomRightGrid(props) {\n      var columnCount = props.columnCount,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          rowCount = props.rowCount,\n          scrollToColumn = props.scrollToColumn,\n          scrollToRow = props.scrollToRow;\n      return React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererBottomRightGrid,\n        className: this.props.classNameBottomRightGrid,\n        columnCount: Math.max(0, columnCount - fixedColumnCount),\n        columnWidth: this._columnWidthRightGrid,\n        deferredMeasurementCache: this._deferredMeasurementCacheBottomRightGrid,\n        height: this._getBottomGridHeight(props),\n        onScroll: this._onScroll,\n        onScrollbarPresenceChange: this._onScrollbarPresenceChange,\n        ref: this._bottomRightGridRef,\n        rowCount: Math.max(0, rowCount - fixedRowCount),\n        rowHeight: this._rowHeightBottomGrid,\n        scrollToColumn: scrollToColumn - fixedColumnCount,\n        scrollToRow: scrollToRow - fixedRowCount,\n        style: this._bottomRightGridStyle,\n        width: this._getRightGridWidth(props)\n      }));\n    }\n  }, {\n    key: \"_renderTopLeftGrid\",\n    value: function _renderTopLeftGrid(props) {\n      var fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount;\n\n      if (!fixedColumnCount || !fixedRowCount) {\n        return null;\n      }\n\n      return React.createElement(Grid, _extends({}, props, {\n        className: this.props.classNameTopLeftGrid,\n        columnCount: fixedColumnCount,\n        height: this._getTopGridHeight(props),\n        ref: this._topLeftGridRef,\n        rowCount: fixedRowCount,\n        style: this._topLeftGridStyle,\n        tabIndex: null,\n        width: this._getLeftGridWidth(props)\n      }));\n    }\n  }, {\n    key: \"_renderTopRightGrid\",\n    value: function _renderTopRightGrid(props) {\n      var columnCount = props.columnCount,\n          enableFixedRowScroll = props.enableFixedRowScroll,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          scrollLeft = props.scrollLeft,\n          hideTopRightGridScrollbar = props.hideTopRightGridScrollbar;\n      var _this$state5 = this.state,\n          showHorizontalScrollbar = _this$state5.showHorizontalScrollbar,\n          scrollbarSize = _this$state5.scrollbarSize;\n\n      if (!fixedRowCount) {\n        return null;\n      }\n\n      var additionalColumnCount = showHorizontalScrollbar ? 1 : 0,\n          height = this._getTopGridHeight(props),\n          width = this._getRightGridWidth(props),\n          additionalHeight = showHorizontalScrollbar ? scrollbarSize : 0;\n\n      var gridHeight = height,\n          style = this._topRightGridStyle;\n\n      if (hideTopRightGridScrollbar) {\n        gridHeight = height + additionalHeight;\n        style = _objectSpread({}, this._topRightGridStyle, {\n          left: 0\n        });\n      }\n\n      var topRightGrid = React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererTopRightGrid,\n        className: this.props.classNameTopRightGrid,\n        columnCount: Math.max(0, columnCount - fixedColumnCount) + additionalColumnCount,\n        columnWidth: this._columnWidthRightGrid,\n        deferredMeasurementCache: this._deferredMeasurementCacheTopRightGrid,\n        height: gridHeight,\n        onScroll: enableFixedRowScroll ? this._onScrollLeft : undefined,\n        ref: this._topRightGridRef,\n        rowCount: fixedRowCount,\n        scrollLeft: scrollLeft,\n        style: style,\n        tabIndex: null,\n        width: width\n      }));\n\n      if (hideTopRightGridScrollbar) {\n        return React.createElement(\"div\", {\n          className: \"TopRightGrid_ScrollWrapper\",\n          style: _objectSpread({}, this._topRightGridStyle, {\n            height: height,\n            width: width,\n            overflowX: 'hidden'\n          })\n        }, topRightGrid);\n      }\n\n      return topRightGrid;\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.scrollLeft !== prevState.scrollLeft || nextProps.scrollTop !== prevState.scrollTop) {\n        return {\n          scrollLeft: nextProps.scrollLeft != null && nextProps.scrollLeft >= 0 ? nextProps.scrollLeft : prevState.scrollLeft,\n          scrollTop: nextProps.scrollTop != null && nextProps.scrollTop >= 0 ? nextProps.scrollTop : prevState.scrollTop\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return MultiGrid;\n}(React.PureComponent);\n\n_defineProperty(MultiGrid, \"defaultProps\", {\n  classNameBottomLeftGrid: '',\n  classNameBottomRightGrid: '',\n  classNameTopLeftGrid: '',\n  classNameTopRightGrid: '',\n  enableFixedColumnScroll: false,\n  enableFixedRowScroll: false,\n  fixedColumnCount: 0,\n  fixedRowCount: 0,\n  scrollToColumn: -1,\n  scrollToRow: -1,\n  style: {},\n  styleBottomLeftGrid: {},\n  styleBottomRightGrid: {},\n  styleTopLeftGrid: {},\n  styleTopRightGrid: {},\n  hideTopRightGridScrollbar: false,\n  hideBottomLeftGridScrollbar: false\n});\n\nMultiGrid.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  classNameBottomLeftGrid: PropTypes.string.isRequired,\n  classNameBottomRightGrid: PropTypes.string.isRequired,\n  classNameTopLeftGrid: PropTypes.string.isRequired,\n  classNameTopRightGrid: PropTypes.string.isRequired,\n  enableFixedColumnScroll: PropTypes.bool.isRequired,\n  enableFixedRowScroll: PropTypes.bool.isRequired,\n  fixedColumnCount: PropTypes.number.isRequired,\n  fixedRowCount: PropTypes.number.isRequired,\n  onScrollbarPresenceChange: PropTypes.func,\n  style: PropTypes.object.isRequired,\n  styleBottomLeftGrid: PropTypes.object.isRequired,\n  styleBottomRightGrid: PropTypes.object.isRequired,\n  styleTopLeftGrid: PropTypes.object.isRequired,\n  styleTopRightGrid: PropTypes.object.isRequired,\n  hideTopRightGridScrollbar: PropTypes.bool,\n  hideBottomLeftGridScrollbar: PropTypes.bool\n} : {};\npolyfill(MultiGrid);\nexport default MultiGrid;","import * as React from 'react';\nexport default function defaultHeaderRowRenderer(_ref) {\n  var className = _ref.className,\n      columns = _ref.columns,\n      style = _ref.style;\n  return React.createElement(\"div\", {\n    className: className,\n    role: \"row\",\n    style: style\n  }, columns);\n}\ndefaultHeaderRowRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_HeaderRowRendererParams === PropTypes.any ? {} : bpfrpt_proptype_HeaderRowRendererParams;\nimport { bpfrpt_proptype_HeaderRowRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\n/**\n * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components.\n */\n\nvar ScrollSync =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ScrollSync, _React$PureComponent);\n\n  function ScrollSync(props, context) {\n    var _this;\n\n    _classCallCheck(this, ScrollSync);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollSync).call(this, props, context));\n    _this.state = {\n      clientHeight: 0,\n      clientWidth: 0,\n      scrollHeight: 0,\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollWidth: 0\n    };\n    _this._onScroll = _this._onScroll.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(ScrollSync, [{\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      var _this$state = this.state,\n          clientHeight = _this$state.clientHeight,\n          clientWidth = _this$state.clientWidth,\n          scrollHeight = _this$state.scrollHeight,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop,\n          scrollWidth = _this$state.scrollWidth;\n      return children({\n        clientHeight: clientHeight,\n        clientWidth: clientWidth,\n        onScroll: this._onScroll,\n        scrollHeight: scrollHeight,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        scrollWidth: scrollWidth\n      });\n    }\n  }, {\n    key: \"_onScroll\",\n    value: function _onScroll(_ref) {\n      var clientHeight = _ref.clientHeight,\n          clientWidth = _ref.clientWidth,\n          scrollHeight = _ref.scrollHeight,\n          scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          scrollWidth = _ref.scrollWidth;\n      this.setState({\n        clientHeight: clientHeight,\n        clientWidth: clientWidth,\n        scrollHeight: scrollHeight,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        scrollWidth: scrollWidth\n      });\n    }\n  }]);\n\n  return ScrollSync;\n}(React.PureComponent);\n\nexport { ScrollSync as default };\nScrollSync.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering 2 or more virtualized components.\n   * This function should implement the following signature:\n   * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element\n   */\n  children: PropTypes.func.isRequired\n} : {};","var SortDirection = {\n  /**\n   * Sort items in ascending order.\n   * This means arranging from the lowest value to the highest (e.g. a-z, 0-9).\n   */\n  ASC: 'ASC',\n\n  /**\n   * Sort items in descending order.\n   * This means arranging from the highest value to the lowest (e.g. z-a, 9-0).\n   */\n  DESC: 'DESC'\n};\nexport default SortDirection;","import clsx from 'clsx';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport SortDirection from './SortDirection';\n/**\n * Displayed beside a header to indicate that a Table is currently sorted by this column.\n */\n\nexport default function SortIndicator(_ref) {\n  var sortDirection = _ref.sortDirection;\n  var classNames = clsx('ReactVirtualized__Table__sortableHeaderIcon', {\n    'ReactVirtualized__Table__sortableHeaderIcon--ASC': sortDirection === SortDirection.ASC,\n    'ReactVirtualized__Table__sortableHeaderIcon--DESC': sortDirection === SortDirection.DESC\n  });\n  return React.createElement(\"svg\", {\n    className: classNames,\n    width: 18,\n    height: 18,\n    viewBox: \"0 0 24 24\"\n  }, sortDirection === SortDirection.ASC ? React.createElement(\"path\", {\n    d: \"M7 14l5-5 5 5z\"\n  }) : React.createElement(\"path\", {\n    d: \"M7 10l5 5 5-5z\"\n  }), React.createElement(\"path\", {\n    d: \"M0 0h24v24H0z\",\n    fill: \"none\"\n  }));\n}\nSortIndicator.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  sortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC])\n} : {};","import * as React from 'react';\nimport SortIndicator from './SortIndicator';\n\n/**\n * Default table header renderer.\n */\nexport default function defaultHeaderRenderer(_ref) {\n  var dataKey = _ref.dataKey,\n      label = _ref.label,\n      sortBy = _ref.sortBy,\n      sortDirection = _ref.sortDirection;\n  var showSortIndicator = sortBy === dataKey;\n  var children = [React.createElement(\"span\", {\n    className: \"ReactVirtualized__Table__headerTruncatedText\",\n    key: \"label\",\n    title: typeof label === 'string' ? label : null\n  }, label)];\n\n  if (showSortIndicator) {\n    children.push(React.createElement(SortIndicator, {\n      key: \"SortIndicator\",\n      sortDirection: sortDirection\n    }));\n  }\n\n  return children;\n}\ndefaultHeaderRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_HeaderRendererParams === PropTypes.any ? {} : bpfrpt_proptype_HeaderRendererParams;\nimport { bpfrpt_proptype_HeaderRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","import _extends from \"@babel/runtime/helpers/extends\";\nimport * as React from 'react';\n\n/**\n * Default row renderer for Table.\n */\nexport default function defaultRowRenderer(_ref) {\n  var className = _ref.className,\n      columns = _ref.columns,\n      index = _ref.index,\n      key = _ref.key,\n      onRowClick = _ref.onRowClick,\n      onRowDoubleClick = _ref.onRowDoubleClick,\n      onRowMouseOut = _ref.onRowMouseOut,\n      onRowMouseOver = _ref.onRowMouseOver,\n      onRowRightClick = _ref.onRowRightClick,\n      rowData = _ref.rowData,\n      style = _ref.style;\n  var a11yProps = {\n    'aria-rowindex': index + 1\n  };\n\n  if (onRowClick || onRowDoubleClick || onRowMouseOut || onRowMouseOver || onRowRightClick) {\n    a11yProps['aria-label'] = 'row';\n    a11yProps.tabIndex = 0;\n\n    if (onRowClick) {\n      a11yProps.onClick = function (event) {\n        return onRowClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowDoubleClick) {\n      a11yProps.onDoubleClick = function (event) {\n        return onRowDoubleClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowMouseOut) {\n      a11yProps.onMouseOut = function (event) {\n        return onRowMouseOut({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowMouseOver) {\n      a11yProps.onMouseOver = function (event) {\n        return onRowMouseOver({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowRightClick) {\n      a11yProps.onContextMenu = function (event) {\n        return onRowRightClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n  }\n\n  return React.createElement(\"div\", _extends({}, a11yProps, {\n    className: className,\n    key: key,\n    role: \"row\",\n    style: style\n  }), columns);\n}\ndefaultRowRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_RowRendererParams === PropTypes.any ? {} : bpfrpt_proptype_RowRendererParams;\nimport { bpfrpt_proptype_RowRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport defaultHeaderRenderer from './defaultHeaderRenderer';\nimport defaultCellRenderer from './defaultCellRenderer';\nimport defaultCellDataGetter from './defaultCellDataGetter';\nimport SortDirection from './SortDirection';\n/**\n * Describes the header and cell contents of a table column.\n */\n\nvar Column =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inherits(Column, _React$Component);\n\n  function Column() {\n    _classCallCheck(this, Column);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(Column).apply(this, arguments));\n  }\n\n  return Column;\n}(React.Component);\n\n_defineProperty(Column, \"defaultProps\", {\n  cellDataGetter: defaultCellDataGetter,\n  cellRenderer: defaultCellRenderer,\n  defaultSortDirection: SortDirection.ASC,\n  flexGrow: 0,\n  flexShrink: 1,\n  headerRenderer: defaultHeaderRenderer,\n  style: {}\n});\n\nexport { Column as default };\nColumn.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /** Optional aria-label value to set on the column header */\n  'aria-label': PropTypes.string,\n\n  /**\n   * Callback responsible for returning a cell's data, given its :dataKey\n   * ({ columnData: any, dataKey: string, rowData: any }): any\n   */\n  cellDataGetter: PropTypes.func,\n\n  /**\n   * Callback responsible for rendering a cell's contents.\n   * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node\n   */\n  cellRenderer: PropTypes.func,\n\n  /** Optional CSS class to apply to cell */\n  className: PropTypes.string,\n\n  /** Optional additional data passed to this column's :cellDataGetter */\n  columnData: PropTypes.object,\n\n  /** Uniquely identifies the row-data attribute corresponding to this cell */\n  dataKey: PropTypes.any.isRequired,\n\n  /** Optional direction to be used when clicked the first time */\n  defaultSortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC]),\n\n  /** If sort is enabled for the table at large, disable it for this column */\n  disableSort: PropTypes.bool,\n\n  /** Flex grow style; defaults to 0 */\n  flexGrow: PropTypes.number,\n\n  /** Flex shrink style; defaults to 1 */\n  flexShrink: PropTypes.number,\n\n  /** Optional CSS class to apply to this column's header */\n  headerClassName: PropTypes.string,\n\n  /**\n   * Optional callback responsible for rendering a column header contents.\n   * ({ columnData: object, dataKey: string, disableSort: boolean, label: node, sortBy: string, sortDirection: string }): PropTypes.node\n   */\n  headerRenderer: PropTypes.func.isRequired,\n\n  /** Optional inline style to apply to this column's header */\n  headerStyle: PropTypes.object,\n\n  /** Optional id to set on the column header */\n  id: PropTypes.string,\n\n  /** Header label for this column */\n  label: PropTypes.node,\n\n  /** Maximum width of column; this property will only be used if :flexGrow is > 0. */\n  maxWidth: PropTypes.number,\n\n  /** Minimum width of column. */\n  minWidth: PropTypes.number,\n\n  /** Optional inline style to apply to cell */\n  style: PropTypes.object,\n\n  /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */\n  width: PropTypes.number.isRequired\n} : {};","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport Column from './Column';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { findDOMNode } from 'react-dom';\nimport Grid, { accessibilityOverscanIndicesGetter } from '../Grid';\nimport defaultRowRenderer from './defaultRowRenderer';\nimport defaultHeaderRowRenderer from './defaultHeaderRowRenderer';\nimport SortDirection from './SortDirection';\n/**\n * Table component with fixed headers and virtualized rows for improved performance with large data sets.\n * This component expects explicit width, height, and padding parameters.\n */\n\nvar Table =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Table, _React$PureComponent);\n\n  function Table(props) {\n    var _this;\n\n    _classCallCheck(this, Table);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Table).call(this, props));\n    _this.state = {\n      scrollbarWidth: 0\n    };\n    _this._createColumn = _this._createColumn.bind(_assertThisInitialized(_this));\n    _this._createRow = _this._createRow.bind(_assertThisInitialized(_this));\n    _this._onScroll = _this._onScroll.bind(_assertThisInitialized(_this));\n    _this._onSectionRendered = _this._onSectionRendered.bind(_assertThisInitialized(_this));\n    _this._setRef = _this._setRef.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(Table, [{\n    key: \"forceUpdateGrid\",\n    value: function forceUpdateGrid() {\n      if (this.Grid) {\n        this.Grid.forceUpdate();\n      }\n    }\n    /** See Grid#getOffsetForCell */\n\n  }, {\n    key: \"getOffsetForRow\",\n    value: function getOffsetForRow(_ref) {\n      var alignment = _ref.alignment,\n          index = _ref.index;\n\n      if (this.Grid) {\n        var _this$Grid$getOffsetF = this.Grid.getOffsetForCell({\n          alignment: alignment,\n          rowIndex: index\n        }),\n            scrollTop = _this$Grid$getOffsetF.scrollTop;\n\n        return scrollTop;\n      }\n\n      return 0;\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref2) {\n      var columnIndex = _ref2.columnIndex,\n          rowIndex = _ref2.rowIndex;\n\n      if (this.Grid) {\n        this.Grid.invalidateCellSizeAfterRender({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllRows\",\n    value: function measureAllRows() {\n      if (this.Grid) {\n        this.Grid.measureAllCells();\n      }\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref3$columnIndex = _ref3.columnIndex,\n          columnIndex = _ref3$columnIndex === void 0 ? 0 : _ref3$columnIndex,\n          _ref3$rowIndex = _ref3.rowIndex,\n          rowIndex = _ref3$rowIndex === void 0 ? 0 : _ref3$rowIndex;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeRowHeights\",\n    value: function recomputeRowHeights() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: index\n        });\n      }\n    }\n    /** See Grid#scrollToPosition */\n\n  }, {\n    key: \"scrollToPosition\",\n    value: function scrollToPosition() {\n      var scrollTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToPosition({\n          scrollTop: scrollTop\n        });\n      }\n    }\n    /** See Grid#scrollToCell */\n\n  }, {\n    key: \"scrollToRow\",\n    value: function scrollToRow() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToCell({\n          columnIndex: 0,\n          rowIndex: index\n        });\n      }\n    }\n  }, {\n    key: \"getScrollbarWidth\",\n    value: function getScrollbarWidth() {\n      if (this.Grid) {\n        var _Grid = findDOMNode(this.Grid);\n\n        var clientWidth = _Grid.clientWidth || 0;\n        var offsetWidth = _Grid.offsetWidth || 0;\n        return offsetWidth - clientWidth;\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this2 = this;\n\n      var _this$props = this.props,\n          children = _this$props.children,\n          className = _this$props.className,\n          disableHeader = _this$props.disableHeader,\n          gridClassName = _this$props.gridClassName,\n          gridStyle = _this$props.gridStyle,\n          headerHeight = _this$props.headerHeight,\n          headerRowRenderer = _this$props.headerRowRenderer,\n          height = _this$props.height,\n          id = _this$props.id,\n          noRowsRenderer = _this$props.noRowsRenderer,\n          rowClassName = _this$props.rowClassName,\n          rowStyle = _this$props.rowStyle,\n          scrollToIndex = _this$props.scrollToIndex,\n          style = _this$props.style,\n          width = _this$props.width;\n      var scrollbarWidth = this.state.scrollbarWidth;\n      var availableRowsHeight = disableHeader ? height : height - headerHeight;\n      var rowClass = typeof rowClassName === 'function' ? rowClassName({\n        index: -1\n      }) : rowClassName;\n      var rowStyleObject = typeof rowStyle === 'function' ? rowStyle({\n        index: -1\n      }) : rowStyle; // Precompute and cache column styles before rendering rows and columns to speed things up\n\n      this._cachedColumnStyles = [];\n      React.Children.toArray(children).forEach(function (column, index) {\n        var flexStyles = _this2._getFlexStyleForColumn(column, column.props.style);\n\n        _this2._cachedColumnStyles[index] = _objectSpread({\n          overflow: 'hidden'\n        }, flexStyles);\n      }); // Note that we specify :rowCount, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.\n      // This is done because Grid is a pure component and won't update unless its properties or state has changed.\n      // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display.\n\n      return React.createElement(\"div\", {\n        \"aria-label\": this.props['aria-label'],\n        \"aria-labelledby\": this.props['aria-labelledby'],\n        \"aria-colcount\": React.Children.toArray(children).length,\n        \"aria-rowcount\": this.props.rowCount,\n        className: clsx('ReactVirtualized__Table', className),\n        id: id,\n        role: \"grid\",\n        style: style\n      }, !disableHeader && headerRowRenderer({\n        className: clsx('ReactVirtualized__Table__headerRow', rowClass),\n        columns: this._getHeaderColumns(),\n        style: _objectSpread({\n          height: headerHeight,\n          overflow: 'hidden',\n          paddingRight: scrollbarWidth,\n          width: width\n        }, rowStyleObject)\n      }), React.createElement(Grid, _extends({}, this.props, {\n        \"aria-readonly\": null,\n        autoContainerWidth: true,\n        className: clsx('ReactVirtualized__Table__Grid', gridClassName),\n        cellRenderer: this._createRow,\n        columnWidth: width,\n        columnCount: 1,\n        height: availableRowsHeight,\n        id: undefined,\n        noContentRenderer: noRowsRenderer,\n        onScroll: this._onScroll,\n        onSectionRendered: this._onSectionRendered,\n        ref: this._setRef,\n        role: \"rowgroup\",\n        scrollbarWidth: scrollbarWidth,\n        scrollToRow: scrollToIndex,\n        style: _objectSpread({}, gridStyle, {\n          overflowX: 'hidden'\n        })\n      })));\n    }\n  }, {\n    key: \"_createColumn\",\n    value: function _createColumn(_ref4) {\n      var column = _ref4.column,\n          columnIndex = _ref4.columnIndex,\n          isScrolling = _ref4.isScrolling,\n          parent = _ref4.parent,\n          rowData = _ref4.rowData,\n          rowIndex = _ref4.rowIndex;\n      var onColumnClick = this.props.onColumnClick;\n      var _column$props = column.props,\n          cellDataGetter = _column$props.cellDataGetter,\n          cellRenderer = _column$props.cellRenderer,\n          className = _column$props.className,\n          columnData = _column$props.columnData,\n          dataKey = _column$props.dataKey,\n          id = _column$props.id;\n      var cellData = cellDataGetter({\n        columnData: columnData,\n        dataKey: dataKey,\n        rowData: rowData\n      });\n      var renderedCell = cellRenderer({\n        cellData: cellData,\n        columnData: columnData,\n        columnIndex: columnIndex,\n        dataKey: dataKey,\n        isScrolling: isScrolling,\n        parent: parent,\n        rowData: rowData,\n        rowIndex: rowIndex\n      });\n\n      var onClick = function onClick(event) {\n        onColumnClick && onColumnClick({\n          columnData: columnData,\n          dataKey: dataKey,\n          event: event\n        });\n      };\n\n      var style = this._cachedColumnStyles[columnIndex];\n      var title = typeof renderedCell === 'string' ? renderedCell : null; // Avoid using object-spread syntax with multiple objects here,\n      // Since it results in an extra method call to 'babel-runtime/helpers/extends'\n      // See PR https://github.com/bvaughn/react-virtualized/pull/942\n\n      return React.createElement(\"div\", {\n        \"aria-colindex\": columnIndex + 1,\n        \"aria-describedby\": id,\n        className: clsx('ReactVirtualized__Table__rowColumn', className),\n        key: 'Row' + rowIndex + '-' + 'Col' + columnIndex,\n        onClick: onClick,\n        role: \"gridcell\",\n        style: style,\n        title: title\n      }, renderedCell);\n    }\n  }, {\n    key: \"_createHeader\",\n    value: function _createHeader(_ref5) {\n      var column = _ref5.column,\n          index = _ref5.index;\n      var _this$props2 = this.props,\n          headerClassName = _this$props2.headerClassName,\n          headerStyle = _this$props2.headerStyle,\n          onHeaderClick = _this$props2.onHeaderClick,\n          sort = _this$props2.sort,\n          sortBy = _this$props2.sortBy,\n          sortDirection = _this$props2.sortDirection;\n      var _column$props2 = column.props,\n          columnData = _column$props2.columnData,\n          dataKey = _column$props2.dataKey,\n          defaultSortDirection = _column$props2.defaultSortDirection,\n          disableSort = _column$props2.disableSort,\n          headerRenderer = _column$props2.headerRenderer,\n          id = _column$props2.id,\n          label = _column$props2.label;\n      var sortEnabled = !disableSort && sort;\n      var classNames = clsx('ReactVirtualized__Table__headerColumn', headerClassName, column.props.headerClassName, {\n        ReactVirtualized__Table__sortableHeaderColumn: sortEnabled\n      });\n\n      var style = this._getFlexStyleForColumn(column, _objectSpread({}, headerStyle, {}, column.props.headerStyle));\n\n      var renderedHeader = headerRenderer({\n        columnData: columnData,\n        dataKey: dataKey,\n        disableSort: disableSort,\n        label: label,\n        sortBy: sortBy,\n        sortDirection: sortDirection\n      });\n      var headerOnClick, headerOnKeyDown, headerTabIndex, headerAriaSort, headerAriaLabel;\n\n      if (sortEnabled || onHeaderClick) {\n        // If this is a sortable header, clicking it should update the table data's sorting.\n        var isFirstTimeSort = sortBy !== dataKey; // If this is the firstTime sort of this column, use the column default sort order.\n        // Otherwise, invert the direction of the sort.\n\n        var newSortDirection = isFirstTimeSort ? defaultSortDirection : sortDirection === SortDirection.DESC ? SortDirection.ASC : SortDirection.DESC;\n\n        var onClick = function onClick(event) {\n          sortEnabled && sort({\n            defaultSortDirection: defaultSortDirection,\n            event: event,\n            sortBy: dataKey,\n            sortDirection: newSortDirection\n          });\n          onHeaderClick && onHeaderClick({\n            columnData: columnData,\n            dataKey: dataKey,\n            event: event\n          });\n        };\n\n        var onKeyDown = function onKeyDown(event) {\n          if (event.key === 'Enter' || event.key === ' ') {\n            onClick(event);\n          }\n        };\n\n        headerAriaLabel = column.props['aria-label'] || label || dataKey;\n        headerAriaSort = 'none';\n        headerTabIndex = 0;\n        headerOnClick = onClick;\n        headerOnKeyDown = onKeyDown;\n      }\n\n      if (sortBy === dataKey) {\n        headerAriaSort = sortDirection === SortDirection.ASC ? 'ascending' : 'descending';\n      } // Avoid using object-spread syntax with multiple objects here,\n      // Since it results in an extra method call to 'babel-runtime/helpers/extends'\n      // See PR https://github.com/bvaughn/react-virtualized/pull/942\n\n\n      return React.createElement(\"div\", {\n        \"aria-label\": headerAriaLabel,\n        \"aria-sort\": headerAriaSort,\n        className: classNames,\n        id: id,\n        key: 'Header-Col' + index,\n        onClick: headerOnClick,\n        onKeyDown: headerOnKeyDown,\n        role: \"columnheader\",\n        style: style,\n        tabIndex: headerTabIndex\n      }, renderedHeader);\n    }\n  }, {\n    key: \"_createRow\",\n    value: function _createRow(_ref6) {\n      var _this3 = this;\n\n      var index = _ref6.rowIndex,\n          isScrolling = _ref6.isScrolling,\n          key = _ref6.key,\n          parent = _ref6.parent,\n          style = _ref6.style;\n      var _this$props3 = this.props,\n          children = _this$props3.children,\n          onRowClick = _this$props3.onRowClick,\n          onRowDoubleClick = _this$props3.onRowDoubleClick,\n          onRowRightClick = _this$props3.onRowRightClick,\n          onRowMouseOver = _this$props3.onRowMouseOver,\n          onRowMouseOut = _this$props3.onRowMouseOut,\n          rowClassName = _this$props3.rowClassName,\n          rowGetter = _this$props3.rowGetter,\n          rowRenderer = _this$props3.rowRenderer,\n          rowStyle = _this$props3.rowStyle;\n      var scrollbarWidth = this.state.scrollbarWidth;\n      var rowClass = typeof rowClassName === 'function' ? rowClassName({\n        index: index\n      }) : rowClassName;\n      var rowStyleObject = typeof rowStyle === 'function' ? rowStyle({\n        index: index\n      }) : rowStyle;\n      var rowData = rowGetter({\n        index: index\n      });\n      var columns = React.Children.toArray(children).map(function (column, columnIndex) {\n        return _this3._createColumn({\n          column: column,\n          columnIndex: columnIndex,\n          isScrolling: isScrolling,\n          parent: parent,\n          rowData: rowData,\n          rowIndex: index,\n          scrollbarWidth: scrollbarWidth\n        });\n      });\n      var className = clsx('ReactVirtualized__Table__row', rowClass);\n\n      var flattenedStyle = _objectSpread({}, style, {\n        height: this._getRowHeight(index),\n        overflow: 'hidden',\n        paddingRight: scrollbarWidth\n      }, rowStyleObject);\n\n      return rowRenderer({\n        className: className,\n        columns: columns,\n        index: index,\n        isScrolling: isScrolling,\n        key: key,\n        onRowClick: onRowClick,\n        onRowDoubleClick: onRowDoubleClick,\n        onRowRightClick: onRowRightClick,\n        onRowMouseOver: onRowMouseOver,\n        onRowMouseOut: onRowMouseOut,\n        rowData: rowData,\n        style: flattenedStyle\n      });\n    }\n    /**\n     * Determines the flex-shrink, flex-grow, and width values for a cell (header or column).\n     */\n\n  }, {\n    key: \"_getFlexStyleForColumn\",\n    value: function _getFlexStyleForColumn(column) {\n      var customStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var flexValue = \"\".concat(column.props.flexGrow, \" \").concat(column.props.flexShrink, \" \").concat(column.props.width, \"px\");\n\n      var style = _objectSpread({}, customStyle, {\n        flex: flexValue,\n        msFlex: flexValue,\n        WebkitFlex: flexValue\n      });\n\n      if (column.props.maxWidth) {\n        style.maxWidth = column.props.maxWidth;\n      }\n\n      if (column.props.minWidth) {\n        style.minWidth = column.props.minWidth;\n      }\n\n      return style;\n    }\n  }, {\n    key: \"_getHeaderColumns\",\n    value: function _getHeaderColumns() {\n      var _this4 = this;\n\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          disableHeader = _this$props4.disableHeader;\n      var items = disableHeader ? [] : React.Children.toArray(children);\n      return items.map(function (column, index) {\n        return _this4._createHeader({\n          column: column,\n          index: index\n        });\n      });\n    }\n  }, {\n    key: \"_getRowHeight\",\n    value: function _getRowHeight(rowIndex) {\n      var rowHeight = this.props.rowHeight;\n      return typeof rowHeight === 'function' ? rowHeight({\n        index: rowIndex\n      }) : rowHeight;\n    }\n  }, {\n    key: \"_onScroll\",\n    value: function _onScroll(_ref7) {\n      var clientHeight = _ref7.clientHeight,\n          scrollHeight = _ref7.scrollHeight,\n          scrollTop = _ref7.scrollTop;\n      var onScroll = this.props.onScroll;\n      onScroll({\n        clientHeight: clientHeight,\n        scrollHeight: scrollHeight,\n        scrollTop: scrollTop\n      });\n    }\n  }, {\n    key: \"_onSectionRendered\",\n    value: function _onSectionRendered(_ref8) {\n      var rowOverscanStartIndex = _ref8.rowOverscanStartIndex,\n          rowOverscanStopIndex = _ref8.rowOverscanStopIndex,\n          rowStartIndex = _ref8.rowStartIndex,\n          rowStopIndex = _ref8.rowStopIndex;\n      var onRowsRendered = this.props.onRowsRendered;\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    }\n  }, {\n    key: \"_setRef\",\n    value: function _setRef(ref) {\n      this.Grid = ref;\n    }\n  }, {\n    key: \"_setScrollbarWidth\",\n    value: function _setScrollbarWidth() {\n      var scrollbarWidth = this.getScrollbarWidth();\n      this.setState({\n        scrollbarWidth: scrollbarWidth\n      });\n    }\n  }]);\n\n  return Table;\n}(React.PureComponent);\n\n_defineProperty(Table, \"defaultProps\", {\n  disableHeader: false,\n  estimatedRowSize: 30,\n  headerHeight: 0,\n  headerStyle: {},\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  overscanIndicesGetter: accessibilityOverscanIndicesGetter,\n  overscanRowCount: 10,\n  rowRenderer: defaultRowRenderer,\n  headerRowRenderer: defaultHeaderRowRenderer,\n  rowStyle: {},\n  scrollToAlignment: 'auto',\n  scrollToIndex: -1,\n  style: {}\n});\n\nexport { Table as default };\nTable.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /** This is just set on the grid top element. */\n  'aria-label': PropTypes.string,\n\n  /** This is just set on the grid top element. */\n  'aria-labelledby': PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: PropTypes.bool,\n\n  /** One or more Columns describing the data displayed in this row */\n  children: function children(props) {\n    var children = React.Children.toArray(props.children);\n\n    for (var i = 0; i < children.length; i++) {\n      var childType = children[i].type;\n\n      if (childType !== Column && !(childType.prototype instanceof Column)) {\n        return new Error('Table only accepts children of type Column');\n      }\n    }\n  },\n\n  /** Optional CSS class name */\n  className: PropTypes.string,\n\n  /** Disable rendering the header at all */\n  disableHeader: PropTypes.bool,\n\n  /**\n   * Used to estimate the total height of a Table before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  estimatedRowSize: PropTypes.number.isRequired,\n\n  /** Optional custom CSS class name to attach to inner Grid element. */\n  gridClassName: PropTypes.string,\n\n  /** Optional inline style to attach to inner Grid element. */\n  gridStyle: PropTypes.object,\n\n  /** Optional CSS class to apply to all column headers */\n  headerClassName: PropTypes.string,\n\n  /** Fixed height of header row */\n  headerHeight: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a table row given an array of columns:\n   * Should implement the following interface: ({\n   *   className: string,\n   *   columns: any[],\n   *   style: any\n   * }): PropTypes.node\n   */\n  headerRowRenderer: PropTypes.func,\n\n  /** Optional custom inline style to attach to table header columns. */\n  headerStyle: PropTypes.object,\n\n  /** Fixed/available height for out DOM element */\n  height: PropTypes.number.isRequired,\n\n  /** Optional id */\n  id: PropTypes.string,\n\n  /** Optional renderer to be used in place of table body rows when rowCount is 0 */\n  noRowsRenderer: PropTypes.func,\n\n  /**\n   * Optional callback when a column is clicked.\n   * ({ columnData: any, dataKey: string }): void\n   */\n  onColumnClick: PropTypes.func,\n\n  /**\n   * Optional callback when a column's header is clicked.\n   * ({ columnData: any, dataKey: string }): void\n   */\n  onHeaderClick: PropTypes.func,\n\n  /**\n   * Callback invoked when a user clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowClick: PropTypes.func,\n\n  /**\n   * Callback invoked when a user double-clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowDoubleClick: PropTypes.func,\n\n  /**\n   * Callback invoked when the mouse leaves a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOut: PropTypes.func,\n\n  /**\n   * Callback invoked when a user moves the mouse over a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOver: PropTypes.func,\n\n  /**\n   * Callback invoked when a user right-clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowRightClick: PropTypes.func,\n\n  /**\n   * Callback invoked with information about the slice of rows that were just rendered.\n   * ({ startIndex, stopIndex }): void\n   */\n  onRowsRendered: PropTypes.func,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, scrollHeight, scrollTop }): void\n   */\n  onScroll: PropTypes.func.isRequired,\n\n  /** See Grid#overscanIndicesGetter */\n  overscanIndicesGetter: PropTypes.func.isRequired,\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  overscanRowCount: PropTypes.number.isRequired,\n\n  /**\n   * Optional CSS class to apply to all table rows (including the header row).\n   * This property can be a CSS class name (string) or a function that returns a class name.\n   * If a function is provided its signature should be: ({ index: number }): string\n   */\n  rowClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),\n\n  /**\n   * Callback responsible for returning a data row given an index.\n   * ({ index: number }): any\n   */\n  rowGetter: PropTypes.func.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * ({ index: number }): number\n   */\n  rowHeight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]).isRequired,\n\n  /** Number of rows in table. */\n  rowCount: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a table row given an array of columns:\n   * Should implement the following interface: ({\n   *   className: string,\n   *   columns: Array,\n   *   index: number,\n   *   isScrolling: boolean,\n   *   onRowClick: ?Function,\n   *   onRowDoubleClick: ?Function,\n   *   onRowMouseOver: ?Function,\n   *   onRowMouseOut: ?Function,\n   *   rowData: any,\n   *   style: any\n   * }): PropTypes.node\n   */\n  rowRenderer: PropTypes.func,\n\n  /** Optional custom inline style to attach to table rows. */\n  rowStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired,\n\n  /** See Grid#scrollToAlignment */\n  scrollToAlignment: PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  scrollToIndex: PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  scrollTop: PropTypes.number,\n\n  /**\n   * Sort function to be called if a sortable header is clicked.\n   * Should implement the following interface: ({\n   *   defaultSortDirection: 'ASC' | 'DESC',\n   *   event: MouseEvent,\n   *   sortBy: string,\n   *   sortDirection: SortDirection\n   * }): void\n   */\n  sort: PropTypes.func,\n\n  /** Table data is currently sorted by this :dataKey (if it is sorted at all) */\n  sortBy: PropTypes.string,\n\n  /** Table data is currently sorted in this direction (if it is sorted at all) */\n  sortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC]),\n\n  /** Optional inline style */\n  style: PropTypes.object,\n\n  /** Tab index for focus */\n  tabIndex: PropTypes.number,\n\n  /** Width of list */\n  width: PropTypes.number.isRequired\n} : {};\nimport { bpfrpt_proptype_CellPosition } from \"../Grid\";","/**\n * Default accessor for returning a cell value for a given attribute.\n * This function expects to operate on either a vanilla Object or an Immutable Map.\n * You should override the column's cellDataGetter if your data is some other type of object.\n */\nexport default function defaultCellDataGetter(_ref) {\n  var dataKey = _ref.dataKey,\n      rowData = _ref.rowData;\n\n  if (typeof rowData.get === 'function') {\n    return rowData.get(dataKey);\n  } else {\n    return rowData[dataKey];\n  }\n}\nimport { bpfrpt_proptype_CellDataGetterParams } from \"./types\";","/**\n * Default cell renderer that displays an attribute as a simple string\n * You should override the column's cellRenderer if your data is some other type of object.\n */\nexport default function defaultCellRenderer(_ref) {\n  var cellData = _ref.cellData;\n\n  if (cellData == null) {\n    return '';\n  } else {\n    return String(cellData);\n  }\n}\nimport { bpfrpt_proptype_CellRendererParams } from \"./types\";","import { requestAnimationTimeout, cancelAnimationTimeout } from '../../utils/requestAnimationTimeout';\nvar mountedInstances = [];\nvar originalBodyPointerEvents = null;\nvar disablePointerEventsTimeoutId = null;\n\nfunction enablePointerEventsIfDisabled() {\n  if (disablePointerEventsTimeoutId) {\n    disablePointerEventsTimeoutId = null;\n\n    if (document.body && originalBodyPointerEvents != null) {\n      document.body.style.pointerEvents = originalBodyPointerEvents;\n    }\n\n    originalBodyPointerEvents = null;\n  }\n}\n\nfunction enablePointerEventsAfterDelayCallback() {\n  enablePointerEventsIfDisabled();\n  mountedInstances.forEach(function (instance) {\n    return instance.__resetIsScrolling();\n  });\n}\n\nfunction enablePointerEventsAfterDelay() {\n  if (disablePointerEventsTimeoutId) {\n    cancelAnimationTimeout(disablePointerEventsTimeoutId);\n  }\n\n  var maximumTimeout = 0;\n  mountedInstances.forEach(function (instance) {\n    maximumTimeout = Math.max(maximumTimeout, instance.props.scrollingResetTimeInterval);\n  });\n  disablePointerEventsTimeoutId = requestAnimationTimeout(enablePointerEventsAfterDelayCallback, maximumTimeout);\n}\n\nfunction onScrollWindow(event) {\n  if (event.currentTarget === window && originalBodyPointerEvents == null && document.body) {\n    originalBodyPointerEvents = document.body.style.pointerEvents;\n    document.body.style.pointerEvents = 'none';\n  }\n\n  enablePointerEventsAfterDelay();\n  mountedInstances.forEach(function (instance) {\n    if (instance.props.scrollElement === event.currentTarget) {\n      instance.__handleWindowScrollEvent();\n    }\n  });\n}\n\nexport function registerScrollListener(component, element) {\n  if (!mountedInstances.some(function (instance) {\n    return instance.props.scrollElement === element;\n  })) {\n    element.addEventListener('scroll', onScrollWindow);\n  }\n\n  mountedInstances.push(component);\n}\nexport function unregisterScrollListener(component, element) {\n  mountedInstances = mountedInstances.filter(function (instance) {\n    return instance !== component;\n  });\n\n  if (!mountedInstances.length) {\n    element.removeEventListener('scroll', onScrollWindow);\n\n    if (disablePointerEventsTimeoutId) {\n      cancelAnimationTimeout(disablePointerEventsTimeoutId);\n      enablePointerEventsIfDisabled();\n    }\n  }\n}\nimport { bpfrpt_proptype_WindowScroller } from \"../WindowScroller.js\";","/**\n * Gets the dimensions of the element, accounting for API differences between\n * `window` and other DOM elements.\n */\n// TODO Move this into WindowScroller and import from there\nvar isWindow = function isWindow(element) {\n  return element === window;\n};\n\nvar getBoundingBox = function getBoundingBox(element) {\n  return element.getBoundingClientRect();\n};\n\nexport function getDimensions(scrollElement, props) {\n  if (!scrollElement) {\n    return {\n      height: props.serverHeight,\n      width: props.serverWidth\n    };\n  } else if (isWindow(scrollElement)) {\n    var _window = window,\n        innerHeight = _window.innerHeight,\n        innerWidth = _window.innerWidth;\n    return {\n      height: typeof innerHeight === 'number' ? innerHeight : 0,\n      width: typeof innerWidth === 'number' ? innerWidth : 0\n    };\n  } else {\n    return getBoundingBox(scrollElement);\n  }\n}\n/**\n * Gets the vertical and horizontal position of an element within its scroll container.\n * Elements that have been “scrolled past” return negative values.\n * Handles edge-case where a user is navigating back (history) from an already-scrolled page.\n * In this case the body’s top or left position will be a negative number and this element’s top or left will be increased (by that amount).\n */\n\nexport function getPositionOffset(element, container) {\n  if (isWindow(container) && document.documentElement) {\n    var containerElement = document.documentElement;\n    var elementRect = getBoundingBox(element);\n    var containerRect = getBoundingBox(containerElement);\n    return {\n      top: elementRect.top - containerRect.top,\n      left: elementRect.left - containerRect.left\n    };\n  } else {\n    var scrollOffset = getScrollOffset(container);\n\n    var _elementRect = getBoundingBox(element);\n\n    var _containerRect = getBoundingBox(container);\n\n    return {\n      top: _elementRect.top + scrollOffset.top - _containerRect.top,\n      left: _elementRect.left + scrollOffset.left - _containerRect.left\n    };\n  }\n}\n/**\n * Gets the vertical and horizontal scroll amount of the element, accounting for IE compatibility\n * and API differences between `window` and other DOM elements.\n */\n\nexport function getScrollOffset(element) {\n  if (isWindow(element) && document.documentElement) {\n    return {\n      top: 'scrollY' in window ? window.scrollY : document.documentElement.scrollTop,\n      left: 'scrollX' in window ? window.scrollX : document.documentElement.scrollLeft\n    };\n  } else {\n    return {\n      top: element.scrollTop,\n      left: element.scrollLeft\n    };\n  }\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { registerScrollListener, unregisterScrollListener } from './utils/onScroll';\nimport { getDimensions, getPositionOffset, getScrollOffset } from './utils/dimensions';\nimport createDetectElementResize from '../vendor/detectElementResize';\n\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\nexport var IS_SCROLLING_TIMEOUT = 150;\n\nvar getWindow = function getWindow() {\n  return typeof window !== 'undefined' ? window : undefined;\n};\n\nvar WindowScroller = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(WindowScroller, _React$PureComponent);\n\n  function WindowScroller() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, WindowScroller);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WindowScroller)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"_window\", getWindow());\n\n    _defineProperty(_assertThisInitialized(_this), \"_isMounted\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionFromTop\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionFromLeft\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_detectElementResize\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_child\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", _objectSpread({}, getDimensions(_this.props.scrollElement, _this.props), {\n      isScrolling: false,\n      scrollLeft: 0,\n      scrollTop: 0\n    }));\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerChild\", function (element) {\n      if (element && !(element instanceof Element)) {\n        console.warn('WindowScroller registerChild expects to be passed Element or null');\n      }\n\n      _this._child = element;\n\n      _this.updatePosition();\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onChildScroll\", function (_ref) {\n      var scrollTop = _ref.scrollTop;\n\n      if (_this.state.scrollTop === scrollTop) {\n        return;\n      }\n\n      var scrollElement = _this.props.scrollElement;\n\n      if (scrollElement) {\n        if (typeof scrollElement.scrollTo === 'function') {\n          scrollElement.scrollTo(0, scrollTop + _this._positionFromTop);\n        } else {\n          scrollElement.scrollTop = scrollTop + _this._positionFromTop;\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerResizeListener\", function (element) {\n      if (element === window) {\n        window.addEventListener('resize', _this._onResize, false);\n      } else {\n        _this._detectElementResize.addResizeListener(element, _this._onResize);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_unregisterResizeListener\", function (element) {\n      if (element === window) {\n        window.removeEventListener('resize', _this._onResize, false);\n      } else if (element) {\n        _this._detectElementResize.removeResizeListener(element, _this._onResize);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onResize\", function () {\n      _this.updatePosition();\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"__handleWindowScrollEvent\", function () {\n      if (!_this._isMounted) {\n        return;\n      }\n\n      var onScroll = _this.props.onScroll;\n      var scrollElement = _this.props.scrollElement;\n\n      if (scrollElement) {\n        var scrollOffset = getScrollOffset(scrollElement);\n        var scrollLeft = Math.max(0, scrollOffset.left - _this._positionFromLeft);\n        var scrollTop = Math.max(0, scrollOffset.top - _this._positionFromTop);\n\n        _this.setState({\n          isScrolling: true,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n\n        onScroll({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"__resetIsScrolling\", function () {\n      _this.setState({\n        isScrolling: false\n      });\n    });\n\n    return _this;\n  }\n\n  _createClass(WindowScroller, [{\n    key: \"updatePosition\",\n    value: function updatePosition() {\n      var scrollElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props.scrollElement;\n      var onResize = this.props.onResize;\n      var _this$state = this.state,\n          height = _this$state.height,\n          width = _this$state.width;\n      var thisNode = this._child || ReactDOM.findDOMNode(this);\n\n      if (thisNode instanceof Element && scrollElement) {\n        var offset = getPositionOffset(thisNode, scrollElement);\n        this._positionFromTop = offset.top;\n        this._positionFromLeft = offset.left;\n      }\n\n      var dimensions = getDimensions(scrollElement, this.props);\n\n      if (height !== dimensions.height || width !== dimensions.width) {\n        this.setState({\n          height: dimensions.height,\n          width: dimensions.width\n        });\n        onResize({\n          height: dimensions.height,\n          width: dimensions.width\n        });\n      }\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var scrollElement = this.props.scrollElement;\n      this._detectElementResize = createDetectElementResize();\n      this.updatePosition(scrollElement);\n\n      if (scrollElement) {\n        registerScrollListener(this, scrollElement);\n\n        this._registerResizeListener(scrollElement);\n      }\n\n      this._isMounted = true;\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var scrollElement = this.props.scrollElement;\n      var prevScrollElement = prevProps.scrollElement;\n\n      if (prevScrollElement !== scrollElement && prevScrollElement != null && scrollElement != null) {\n        this.updatePosition(scrollElement);\n        unregisterScrollListener(this, prevScrollElement);\n        registerScrollListener(this, scrollElement);\n\n        this._unregisterResizeListener(prevScrollElement);\n\n        this._registerResizeListener(scrollElement);\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      var scrollElement = this.props.scrollElement;\n\n      if (scrollElement) {\n        unregisterScrollListener(this, scrollElement);\n\n        this._unregisterResizeListener(scrollElement);\n      }\n\n      this._isMounted = false;\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      var _this$state2 = this.state,\n          isScrolling = _this$state2.isScrolling,\n          scrollTop = _this$state2.scrollTop,\n          scrollLeft = _this$state2.scrollLeft,\n          height = _this$state2.height,\n          width = _this$state2.width;\n      return children({\n        onChildScroll: this._onChildScroll,\n        registerChild: this._registerChild,\n        height: height,\n        isScrolling: isScrolling,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        width: width\n      });\n    }\n  }]);\n\n  return WindowScroller;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  /**\n   * Function responsible for rendering children.\n   * This function should implement the following signature:\n   * ({ height, isScrolling, scrollLeft, scrollTop, width }) => PropTypes.element\n   */\n  \"children\": PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-resize: ({ height, width }) */\n  \"onResize\": PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-scroll: ({ scrollLeft, scrollTop }) */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /** Element to attach scroll event listeners. Defaults to window. */\n  \"scrollElement\": PropTypes.oneOfType([PropTypes.any, function () {\n    return (typeof Element === \"function\" ? PropTypes.instanceOf(Element) : PropTypes.any).apply(this, arguments);\n  }]),\n\n  /**\n   * Wait this amount of time after the last scroll event before resetting child `pointer-events`.\n   */\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n\n  /** Height used for server-side rendering */\n  \"serverHeight\": PropTypes.number.isRequired,\n\n  /** Width used for server-side rendering */\n  \"serverWidth\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(WindowScroller, \"defaultProps\", {\n  onResize: function onResize() {},\n  onScroll: function onScroll() {},\n  scrollingResetTimeInterval: IS_SCROLLING_TIMEOUT,\n  scrollElement: getWindow(),\n  serverHeight: 0,\n  serverWidth: 0\n});\n\nexport { WindowScroller as default };\nimport PropTypes from \"prop-types\";"],"names":["_interopRequireDefault","exports","_react","_default","default","createElement","d","createHorizontalStrength","createVerticalStrength","createScrollingComponent","WrappedComponent","ScrollingComponent","props","_reactDnd","DragDropContextConsumer","_ref3","dragDropManager","undefined","_extends","obj","__esModule","newObj","key","Object","prototype","hasOwnProperty","call","desc","defineProperty","getOwnPropertyDescriptor","get","set","_interopRequireWildcard","_propTypes","_reactDom","_lodash","_raf","_reactDisplayName","_hoistNonReactStatics","_util","_typeof","Symbol","iterator","constructor","assign","target","i","arguments","length","source","apply","this","_defineProperties","descriptor","enumerable","configurable","writable","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","__proto__","_setPrototypeOf","p","_assertThisInitialized","self","ReferenceError","_defineProperty","value","_buffer","_ref","point","x","w","y","h","buffer","Math","min","_ref2","defaultHorizontalStrength","defaultVerticalStrength","_Component","ctx","_this","instance","Constructor","TypeError","_classCallCheck","_possibleConstructorReturn","evt","_this$container$getBo","container","getBoundingClientRect","box","left","top","width","height","coords","getCoords","_this$props","horizontalStrength","verticalStrength","scaleX","scaleY","frame","startScrolling","trailing","dragging","attached","attach","updateScrolling","wrappedInstance","createRef","protoProps","subClass","superClass","create","_inherits","_this2","findDOMNode","current","addEventListener","handleEvent","window","document","body","clearMonitorSubscription","getMonitor","subscribeToStateChange","handleMonitorChange","removeEventListener","stopScrolling","isDragging","_this3","tick","_this3$props","strengthMultiplier","onScrollChange","scrollLeft","scrollTop","scrollWidth","scrollHeight","clientWidth","clientHeight","intBetween","detach","cancel","_this$props2","excluded","sourceKeys","keys","indexOf","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_objectWithoutProperties","ref","Component","concat","object","isRequired","func","number","noop","max","val","floor","type","changedTouches","clientX","clientY","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","KNOWN_STATICS","name","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","getOwnPropertyNames","objectPrototype","module","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","e","calculateSizeAndPositionDataAndUpdateScrollOffset","cellCount","cellSize","computeMetadataCallback","computeMetadataCallbackProps","nextCellsCount","nextCellSize","nextScrollToIndex","scrollToIndex","updateScrollOffsetForScrollToIndex","CellSizeAndPositionManager","cellSizeGetter","estimatedCellSize","_cellSizeGetter","_cellCount","_estimatedCellSize","_lastMeasuredIndex","index","Error","lastMeasuredCellSizeAndPosition","getSizeAndPositionOfLastMeasuredCell","offset","size","isNaN","_cellSizeAndPositionData","_lastBatchedIndex","_ref3$align","align","containerSize","currentOffset","targetIndex","idealOffset","datum","getSizeAndPositionOfCell","maxOffset","minOffset","totalSize","getTotalSize","params","start","_findNearestCell","stop","high","low","middle","interval","_binarySearch","lastMeasuredIndex","_exponentialSearch","ScalingCellSizeAndPositionManager","_ref$maxScrollSize","maxScrollSize","chrome","_cellSizeAndPositionManager","_maxScrollSize","configure","getCellCount","getEstimatedCellSize","getLastMeasuredIndex","safeTotalSize","offsetPercentage","_getOffsetPercentage","round","_safeOffsetToOffset","getUpdatedOffsetForIndex","_offsetToSafeOffset","_ref4","getVisibleCellRange","resetCell","_ref5","_ref6","_ref7","createCallbackMemoizer","requireAllKeys","cachedIndices","callback","indices","allInitialized","every","Array","isArray","indexChanged","some","cachedValue","join","updateScrollIndexHelper","cellSizeAndPositionManager","previousCellsCount","previousCellSize","previousScrollToAlignment","previousScrollToIndex","previousSize","scrollOffset","scrollToAlignment","sizeJustIncreasedFromZero","updateScrollIndexCallback","hasScrollToIndex","win","scrollbarSize","recalc","canUseDOM","scrollDiv","style","position","overflow","appendChild","offsetWidth","removeChild","_class","_temp","request","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","setTimeout","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","oCancelAnimationFrame","msCancelAnimationFrame","id","clearTimeout","raf","caf","cancelAnimationTimeout","requestAnimationTimeout","delay","Promise","resolve","then","Date","now","timeout","ownKeys","enumerableOnly","symbols","filter","sym","push","_objectSpread","forEach","getOwnPropertyDescriptors","defineProperties","SCROLL_POSITION_CHANGE_REASONS","Grid","_React$PureComponent","_disablePointerEventsTimeoutId","setState","isScrolling","needToResetStyleCache","onSectionRendered","_onGridRenderedMemoizer","columnOverscanStartIndex","_columnStartIndex","columnOverscanStopIndex","_columnStopIndex","columnStartIndex","_renderedColumnStartIndex","columnStopIndex","_renderedColumnStopIndex","rowOverscanStartIndex","_rowStartIndex","rowOverscanStopIndex","_rowStopIndex","rowStartIndex","_renderedRowStartIndex","rowStopIndex","_renderedRowStopIndex","_scrollingContainer","event","handleScrollEvent","columnSizeAndPositionManager","columnCount","_wrapSizeGetter","columnWidth","_getEstimatedColumnSize","rowSizeAndPositionManager","rowCount","rowHeight","_getEstimatedRowSize","state","instanceProps","prevColumnWidth","prevRowHeight","prevColumnCount","prevRowCount","prevIsScrolling","prevScrollToColumn","scrollToColumn","prevScrollToRow","scrollToRow","scrollbarSizeMeasured","scrollDirectionHorizontal","scrollDirectionVertical","scrollPositionChangeReason","_initialScrollTop","_getCalculatedScrollTop","_initialScrollLeft","_getCalculatedScrollLeft","_ref$alignment","alignment","_ref$columnIndex","columnIndex","_ref$rowIndex","rowIndex","offsetProps","_ref2$scrollLeft","scrollLeftParam","_ref2$scrollTop","scrollTopParam","_debounceScrollEnded","autoHeight","autoWidth","totalRowsHeight","totalColumnsWidth","newState","_invokeOnScrollMemoizer","_deferredInvalidateColumnIndex","_deferredInvalidateRowIndex","_ref4$columnIndex","_ref4$rowIndex","_this$props3","_recomputeScrollLeftFlag","_recomputeScrollTopFlag","_styleCache","_cellCache","forceUpdate","_updateScrollLeftForScrollToColumn","_updateScrollTopForScrollToRow","_this$props4","getScrollbarSize","_handleInvalidatedGridSize","prevState","stateUpdate","_getScrollToPositionStateUpdate","sizeIsBiggerThanZero","_invokeOnGridRenderedHelper","_maybeCallOnScrollbarPresenceChange","prevProps","_this$props5","_this$state","columnOrRowCountJustIncreasedFromZero","_this$props6","autoContainerWidth","className","containerProps","containerRole","containerStyle","noContentRenderer","role","tabIndex","_this$state2","_isScrolling","gridStyle","boxSizing","direction","WebkitOverflowScrolling","willChange","_resetStyleCache","_calculateChildrenToRender","verticalScrollBarSize","horizontalScrollBarSize","_horizontalScrollBarSize","_verticalScrollBarSize","_scrollbarPresenceChanged","overflowX","overflowY","childrenToDisplay","_childrenToDisplay","showNoContentRenderer","_setScrollingContainerRef","onScroll","_onScroll","maxWidth","maxHeight","pointerEvents","cellRenderer","cellRangeRenderer","deferredMeasurementCache","overscanColumnCount","overscanIndicesGetter","overscanRowCount","isScrollingOptOut","visibleColumnIndices","visibleRowIndices","horizontalOffsetAdjustment","getOffsetAdjustment","verticalOffsetAdjustment","overscanColumnIndices","overscanCellsCount","scrollDirection","startIndex","stopIndex","overscanRowIndices","overscanStartIndex","overscanStopIndex","hasFixedHeight","has","hasFixedWidth","cellCache","parent","styleCache","scrollingResetTimeInterval","_debounceScrollEndedCallback","recomputeGridSize","_onScrollMemoizer","Boolean","onScrollbarPresenceChange","horizontal","vertical","_ref8","_getScrollLeftForScrollToColumnStateUpdate","_getScrollTopForScrollToRowStateUpdate","nextProps","maybeStateA","maybeStateB","estimatedColumnSize","estimatedRowSize","_ref9","finalColumn","scrollBarSize","calculatedScrollLeft","finalRow","calculatedScrollTop","renderedCells","areOffsetsAdjusted","canCacheStyle","rowDatum","columnDatum","isVisible","cellRendererParams","renderedCell","polyfill","ArrowKeyStepper","_getPrototypeOf2","_len","args","_key","disabled","mode","_this$_getScrollState","_getScrollState","scrollToColumnPrevious","scrollToRowPrevious","_this$_getScrollState2","preventDefault","_updateScrollState","children","_this$_getScrollState3","onKeyDown","_onKeyDown","_onSectionRendered","isControlled","onScrollToChange","createDetectElementResize","nonce","hostWindow","_window","attachEvent","g","requestFrame","fn","cancelFrame","resetTriggers","element","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","offsetHeight","scrollListener","__resizeRAF__","__resizeLast__","checkTriggers","__resizeListeners__","animation","keyframeprefix","animationstartevent","domPrefixes","split","startEvents","elm","animationName","toLowerCase","animationKeyframes","animationStyle","addResizeListener","doc","ownerDocument","elementStyle","getComputedStyle","getElementById","css","head","getElementsByTagName","setAttribute","styleSheet","cssText","createTextNode","createStyles","resizeTriggersHtml","trustedTypes","staticPolicy","createPolicy","createHTML","innerHTML","__animationListener__","removeResizeListener","detachEvent","splice","AutoSizer","_React$Component","defaultHeight","defaultWidth","disableHeight","disableWidth","onResize","_parentNode","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","newHeight","newWidth","autoSizer","_autoSizer","parentNode","defaultView","HTMLElement","_detectElementResize","_onResize","outerStyle","childParams","_setRef","CellMeasurer","cache","_this$props$columnInd","_this$props$rowIndex","_this$_getCellMeasure","_getCellMeasurements","getHeight","getWidth","Element","console","warn","_child","_maybeMeasureCell","measure","_measure","registerChild","_registerChild","node","styleWidth","styleHeight","ceil","_this$props2$columnIn","_this$props2$rowIndex","_this$_getCellMeasure2","invalidateCellSizeAfterRender","CellMeasurerCache","_keyMapper","_columnWidthCache","_defaultWidth","_rowHeightCache","_defaultHeight","fixedHeight","fixedWidth","keyMapper","minHeight","minWidth","_hasFixedHeight","_hasFixedWidth","_minHeight","_minWidth","defaultKeyMapper","_cellHeightCache","_cellWidthCache","_updateCachedColumnAndRowSizes","_rowCount","_columnCount","_key2","columnKey","_i","rowKey","CollectionView","cellLayoutManager","_onSectionRenderedMemoizer","getLastRenderedIndices","scrollToCell","scrollPosition","getScrollPositionForCell","cellIndex","_setScrollPosition","_enablePointerEventsAfterDelay","isScrollingChange","_scrollbarSize","_cellLayoutManager$ge","totalHeight","totalWidth","cancelable","_scrollbarSizeMeasured","_calculateSizeAndPositionDataOnNextUpdate","_updateScrollPositionForScrollToCell","_invokeOnSectionRenderedHelper","_cellLayoutManager$ge2","horizontalOverscanSize","verticalOverscanSize","_this$state3","_lastRenderedCellCount","_lastRenderedCellLayoutManager","calculateSizeAndPositionData","_cellLayoutManager$ge3","right","bottom","cellRenderers","collectionStyle","Section","_indexMap","_indices","SectionManager","sectionSize","_sectionSize","_cellMetadata","_sections","getSections","section","getCellIndices","map","sectionXStart","sectionXStop","sectionYStart","sectionYStop","sections","sectionX","sectionY","toString","cellMetadatum","addCellIndex","_ref$align","cellOffset","Collection","context","_lastRenderedCellIndices","_isScrollingChange","bind","_setCollectionViewRef","_collectionView","recomputeCellSizesAndPositions","data","cellSizeAndPositionGetter","cellMetadata","sectionManager","registerCell","_sectionManager","_height","_width","cellGroupRenderer","getCellMetadata","cellRendererProps","ColumnSizer","columnMaxWidth","columnMinWidth","_registeredChild","safeColumnMinWidth","safeColumnMaxWidth","adjustedWidth","getColumnWidth","child","InfiniteLoader","_loadMoreRowsMemoizer","_onRowsRendered","autoReload","_doStuff","_lastRenderedStartIndex","_lastRenderedStopIndex","onRowsRendered","unloadedRanges","loadMoreRows","unloadedRange","promise","lastRenderedStartIndex","lastRenderedStopIndex","currentIndex","recomputeSize","recomputeRowHeights","forceUpdateReactVirtualizedComponent","isRowLoaded","minimumBatchSize","threshold","rangeStartIndex","rangeStopIndex","potentialStopIndex","_index","firstUnloadedRange","_index2","scanForUnloadedRanges","squashedUnloadedRanges","_loadUnloadedRanges","registeredChild","List","rowRenderer","widthDescriptor","getOffsetForCell","measureAllCells","_ref6$columnIndex","_ref6$rowIndex","scrollToPosition","noRowsRenderer","classNames","_cellRenderer","a","c","l","m","_GEP","_GEA","IntervalTreeNode","mid","leftPoints","rightPoints","count","proto","copy","b","rebuild","intervals","ntree","createIntervalTree","rebuildWithInterval","rebuildWithoutInterval","idx","reportLeftRange","arr","hi","cb","r","reportRightRange","lo","reportRange","compareNumbers","compareBegin","compareEnd","pts","sort","leftIntervals","rightIntervals","centerIntervals","s","slice","IntervalTree","root","result","insert","weight","remove","n","queryPoint","queryInterval","tproto","PositionCache","defaultCellHeight","unmeasuredCellCount","tallestColumnSize","renderCallback","_intervalTree","_leftMap","columnSizeMap","_columnSizeMap","columnHeight","Masonry","eventScrollTop","currentTarget","_getEstimatedTotalHeight","_debounceResetIsScrolling","_positionCache","_invalidateOnUpdateStartIndex","_invalidateOnUpdateStopIndex","_populatePositionCache","_checkInvalidateOnUpdate","_invokeOnScrollCallback","_invokeOnCellsRenderedCallback","_debounceResetIsScrollingId","cellMeasurerCache","overscanByPixels","rowDirection","estimateTotalHeight","shortestColumnSize","measuredCellCount","range","_style","batchSize","_startIndex","_stopIndex","_debounceResetIsScrollingCallback","estimatedColumnCount","_onScrollMemoized","_startIndexMemoized","_stopIndexMemoized","onCellsRendered","cellPositioner","_cellPositioner","setPosition","CellMeasurerCacheDecorator","_cellMeasurerCache","_columnIndexOffset","_rowIndexOffset","_params$columnIndexOf","columnIndexOffset","_params$rowIndexOffse","rowIndexOffset","clear","clearAll","MultiGrid","showHorizontalScrollbar","showVerticalScrollbar","_bottomLeftGrid","_bottomRightGrid","rest","fixedRowCount","fixedColumnCount","scrollInfo","_topLeftGrid","_topRightGrid","_fixedColumnCount","_fixedRowCount","_maybeCalculateCachedStyles","_deferredMeasurementCacheBottomLeftGrid","_deferredMeasurementCacheBottomRightGrid","_deferredMeasurementCacheTopRightGrid","_ref7$columnIndex","_ref7$rowIndex","_ref8$columnIndex","_ref8$rowIndex","adjustedColumnIndex","adjustedRowIndex","_leftGridWidth","_topGridHeight","_this$props7","_this$props8","_prepareForRender","_this$state4","_containerOuterStyle","_containerTopStyle","_renderTopLeftGrid","_renderTopRightGrid","_containerBottomStyle","_renderBottomLeftGrid","_renderBottomRightGrid","_getTopGridHeight","leftGridWidth","_getLeftGridWidth","topGridHeight","resetAll","_this$props9","enableFixedColumnScroll","enableFixedRowScroll","styleBottomLeftGrid","styleBottomRightGrid","styleTopLeftGrid","styleTopRightGrid","sizeChange","_lastRenderedHeight","_lastRenderedWidth","leftSizeChange","_lastRenderedColumnWidth","_lastRenderedFixedColumnCount","topSizeChange","_lastRenderedFixedRowCount","_lastRenderedRowHeight","_lastRenderedStyle","_lastRenderedStyleBottomLeftGrid","_bottomLeftGridStyle","_lastRenderedStyleBottomRightGrid","_bottomRightGridStyle","_lastRenderedStyleTopLeftGrid","_topLeftGridStyle","_lastRenderedStyleTopRightGrid","_topRightGridStyle","hideBottomLeftGridScrollbar","additionalRowCount","_getBottomGridHeight","gridWidth","bottomLeftGrid","_cellRendererBottomLeftGrid","classNameBottomLeftGrid","_onScrollTop","_bottomLeftGridRef","_rowHeightBottomGrid","_cellRendererBottomRightGrid","classNameBottomRightGrid","_columnWidthRightGrid","_onScrollbarPresenceChange","_bottomRightGridRef","_getRightGridWidth","classNameTopLeftGrid","_topLeftGridRef","hideTopRightGridScrollbar","_this$state5","additionalColumnCount","additionalHeight","gridHeight","topRightGrid","_cellRendererTopRightGrid","classNameTopRightGrid","_onScrollLeft","_topRightGridRef","defaultHeaderRowRenderer","columns","ScrollSync","SortIndicator","sortDirection","viewBox","fill","defaultHeaderRenderer","dataKey","label","sortBy","showSortIndicator","title","defaultRowRenderer","onRowClick","onRowDoubleClick","onRowMouseOut","onRowMouseOver","onRowRightClick","rowData","a11yProps","onClick","onDoubleClick","onMouseOut","onMouseOver","onContextMenu","Column","cellDataGetter","cellData","String","defaultSortDirection","flexGrow","flexShrink","headerRenderer","Table","scrollbarWidth","_createColumn","_createRow","_ref3$columnIndex","_ref3$rowIndex","_Grid","_setScrollbarWidth","disableHeader","gridClassName","headerHeight","headerRowRenderer","rowClassName","rowStyle","availableRowsHeight","rowClass","rowStyleObject","_cachedColumnStyles","column","flexStyles","_getFlexStyleForColumn","_getHeaderColumns","onColumnClick","_column$props","columnData","headerOnClick","headerOnKeyDown","headerTabIndex","headerAriaSort","headerAriaLabel","headerClassName","headerStyle","onHeaderClick","_column$props2","disableSort","sortEnabled","ReactVirtualized__Table__sortableHeaderColumn","renderedHeader","newSortDirection","rowGetter","flattenedStyle","_getRowHeight","customStyle","flexValue","flex","msFlex","WebkitFlex","_this4","_createHeader","getScrollbarWidth","mountedInstances","originalBodyPointerEvents","disablePointerEventsTimeoutId","enablePointerEventsIfDisabled","enablePointerEventsAfterDelayCallback","__resetIsScrolling","onScrollWindow","maximumTimeout","enablePointerEventsAfterDelay","scrollElement","__handleWindowScrollEvent","registerScrollListener","unregisterScrollListener","isWindow","getBoundingBox","getDimensions","innerHeight","innerWidth","serverHeight","serverWidth","getPositionOffset","documentElement","containerElement","elementRect","containerRect","getScrollOffset","_elementRect","_containerRect","scrollY","scrollX","getWindow","WindowScroller","updatePosition","scrollTo","_positionFromTop","_isMounted","_positionFromLeft","thisNode","dimensions","_registerResizeListener","prevScrollElement","_unregisterResizeListener","onChildScroll","_onChildScroll"],"sourceRoot":""}