{"version":3,"sources":["webpack:///./node_modules/js-image-zoom/js-image-zoom.js","webpack:///./node_modules/@babel/runtime/helpers/toPrimitive.js","webpack:///./node_modules/@babel/runtime/helpers/inherits.js","webpack:///./node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","webpack:///./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:///./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:///./node_modules/core-js/modules/web.immediate.js","webpack:///./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:///./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:///./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:///./node_modules/@babel/runtime/helpers/objectWithoutProperties.js","webpack:///./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:///./node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/createClass.js","webpack:///./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:///./node_modules/core-js/internals/is-integer.js","webpack:///./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:///./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:///./node_modules/react-lifecycles-compat/react-lifecycles-compat.es.js","webpack:///./node_modules/clsx/dist/clsx.m.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/utils/CellSizeAndPositionManager.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/utils/maxElementSize.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/utils/ScalingCellSizeAndPositionManager.js","webpack:///./node_modules/react-virtualized/dist/es/utils/createCallbackMemoizer.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/defaultOverscanIndicesGetter.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/utils/updateScrollIndexHelper.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/defaultCellRangeRenderer.js","webpack:///./node_modules/dom-helpers/esm/canUseDOM.js","webpack:///./node_modules/dom-helpers/esm/scrollbarSize.js","webpack:///./node_modules/react-virtualized/dist/es/utils/animationFrame.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/Grid.js","webpack:///./node_modules/react-virtualized/dist/es/utils/requestAnimationTimeout.js","webpack:///./node_modules/react-virtualized/dist/es/Grid/accessibilityOverscanIndicesGetter.js","webpack:///./node_modules/react-virtualized/dist/es/ArrowKeyStepper/types.js","webpack:///./node_modules/react-virtualized/dist/es/ArrowKeyStepper/ArrowKeyStepper.js","webpack:///./node_modules/react-virtualized/dist/es/AutoSizer/AutoSizer.js","webpack:///./node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurer.js","webpack:///./node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurerCache.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/CollectionView.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/Section.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/SectionManager.js","webpack:///./node_modules/react-virtualized/dist/es/utils/getUpdatedOffsetForIndex.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/Collection.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/utils/calculateSizeAndPositionData.js","webpack:///./node_modules/react-virtualized/dist/es/Collection/index.js","webpack:///./node_modules/react-virtualized/dist/es/ColumnSizer/ColumnSizer.js","webpack:///./node_modules/react-virtualized/dist/es/ColumnSizer/index.js","webpack:///./node_modules/react-virtualized/dist/es/InfiniteLoader/InfiniteLoader.js","webpack:///./node_modules/react-virtualized/dist/es/InfiniteLoader/index.js","webpack:///./node_modules/react-virtualized/dist/es/List/List.js","webpack:///./node_modules/react-virtualized/dist/es/vendor/binarySearchBounds.js","webpack:///./node_modules/react-virtualized/dist/es/vendor/intervalTree.js","webpack:///./node_modules/react-virtualized/dist/es/Masonry/PositionCache.js","webpack:///./node_modules/react-virtualized/dist/es/Masonry/Masonry.js","webpack:///./node_modules/react-virtualized/dist/es/Masonry/createCellPositioner.js","webpack:///./node_modules/react-virtualized/dist/es/Masonry/index.js","webpack:///./node_modules/react-virtualized/dist/es/MultiGrid/CellMeasurerCacheDecorator.js","webpack:///./node_modules/react-virtualized/dist/es/MultiGrid/MultiGrid.js","webpack:///./node_modules/react-virtualized/dist/es/ScrollSync/ScrollSync.js","webpack:///./node_modules/react-virtualized/dist/es/Table/createMultiSort.js","webpack:///./node_modules/react-virtualized/dist/es/Table/defaultCellDataGetter.js","webpack:///./node_modules/react-virtualized/dist/es/Table/defaultCellRenderer.js","webpack:///./node_modules/react-virtualized/dist/es/Table/defaultHeaderRowRenderer.js","webpack:///./node_modules/react-virtualized/dist/es/Table/SortDirection.js","webpack:///./node_modules/react-virtualized/dist/es/Table/SortIndicator.js","webpack:///./node_modules/react-virtualized/dist/es/Table/defaultHeaderRenderer.js","webpack:///./node_modules/react-virtualized/dist/es/Table/defaultRowRenderer.js","webpack:///./node_modules/react-virtualized/dist/es/Table/Column.js","webpack:///./node_modules/react-virtualized/dist/es/Table/Table.js","webpack:///./node_modules/react-virtualized/dist/es/Table/index.js","webpack:///./node_modules/react-virtualized/dist/es/WindowScroller/utils/onScroll.js","webpack:///./node_modules/react-virtualized/dist/es/WindowScroller/utils/dimensions.js","webpack:///./node_modules/react-virtualized/dist/es/WindowScroller/WindowScroller.js","webpack:///./node_modules/react-virtualized/dist/es/index.js","webpack:///./node_modules/@babel/runtime/helpers/typeof.js","webpack:///./node_modules/core-js/modules/es.object.get-own-property-names.js","webpack:///./node_modules/core-js/modules/es.number.is-integer.js","webpack:///./node_modules/core-js/web/immediate.js","webpack:///./node_modules/@babel/runtime/helpers/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:///./node_modules/react-virtualized/dist/es/vendor/detectElementResize.js","webpack:///./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:///./node_modules/@babel/runtime/helpers/toPropertyKey.js","webpack:///./node_modules/@babel/runtime/helpers/extends.js","webpack:///./node_modules/core-js/modules/es.array.last-index-of.js","webpack:///./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack:///./node_modules/react-image-zoom/index.js"],"names":["root","factory","this","container","opts","options","scaleX","scaleY","offset","data","sourceImg","element","width","height","naturalWidth","naturalHeight","zoomedImgOffset","vertical","horizontal","zoomedImg","zoomLens","div","document","createElement","lensDiv","zoomPosition","zoomContainer","events","handleEvent","event","type","handleMouseMove","handleMouseEnter","handleMouseLeave","handleScroll","offsetX","offsetY","backgroundPosition","zoomLensLeft","clientX","left","zoomLensTop","clientY","top","style","cssText","display","getOffset","setup","complete","onSourceImgLoad","onload","kill","_getInstanceInfo","el","elRect","getBoundingClientRect","getPosition","v","min","max","val","getValue","leftMin","topMin","scale","zoomWidth","setZoomedImgSize","backgroundSize","zoomStyle","zoomLensStyle","background","opacity","clientWidth","clientHeight","position","pointerEvents","img","src","appendChild","children","nodeName","querySelector","classList","add","backgroundImage","backgroundRepeat","transform","bottom","right","addEventListener","window","removeEventListener","removeChild","module","exports","ImageZoom","_typeof","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","String","Number","__esModule","setPrototypeOf","subClass","superClass","prototype","Object","create","constructor","value","writable","configurable","defineProperty","source","excluded","key","i","target","sourceKeys","keys","length","indexOf","iter","iterator","Array","from","$","global","task","bind","enumerable","forced","setImmediate","clearImmediate","set","clear","arrayLikeToArray","arr","isArray","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","_getPrototypeOf","o","getPrototypeOf","__proto__","self","ReferenceError","objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","arrayWithoutHoles","iterableToArray","nonIterableSpread","_setPrototypeOf","p","toPropertyKey","_defineProperties","props","descriptor","Constructor","protoProps","staticProps","len","arr2","isObject","floor","Math","it","isFinite","minLen","n","toString","slice","name","test","assertThisInitialized","componentWillMount","state","getDerivedStateFromProps","setState","componentWillReceiveProps","nextProps","prevState","componentWillUpdate","nextState","prevProps","__reactInternalSnapshotFlag","__reactInternalSnapshot","getSnapshotBeforeUpdate","polyfill","Component","isReactComponent","Error","foundWillMountName","foundWillReceivePropsName","foundWillUpdateName","UNSAFE_componentWillMount","UNSAFE_componentWillReceiveProps","UNSAFE_componentWillUpdate","componentName","displayName","newApiName","componentDidUpdate","maybeSnapshot","snapshot","__suppressDeprecationWarning","e","t","f","arguments","calculateSizeAndPositionDataAndUpdateScrollOffset","_ref","cellCount","cellSize","computeMetadataCallback","computeMetadataCallbackProps","nextCellsCount","nextCellSize","nextScrollToIndex","scrollToIndex","updateScrollOffsetForScrollToIndex","CellSizeAndPositionManager","cellSizeGetter","estimatedCellSize","_cellSizeGetter","_cellCount","_estimatedCellSize","_ref2","_lastMeasuredIndex","index","concat","lastMeasuredCellSizeAndPosition","getSizeAndPositionOfLastMeasuredCell","size","isNaN","_cellSizeAndPositionData","_lastBatchedIndex","_ref3","_ref3$align","align","containerSize","currentOffset","targetIndex","idealOffset","datum","getSizeAndPositionOfCell","maxOffset","minOffset","totalSize","getTotalSize","params","start","_findNearestCell","stop","high","low","middle","interval","_binarySearch","lastMeasuredIndex","_exponentialSearch","getMaxElementSize","chrome","ScalingCellSizeAndPositionManager","_ref$maxScrollSize","maxScrollSize","_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","indexChanged","some","cachedValue","join","defaultOverscanIndicesGetter","overscanCellsCount","scrollDirection","startIndex","stopIndex","overscanStartIndex","overscanStopIndex","updateScrollIndexHelper","cellSizeAndPositionManager","previousCellsCount","previousCellSize","previousScrollToAlignment","previousScrollToIndex","previousSize","scrollOffset","scrollToAlignment","sizeJustIncreasedFromZero","updateScrollIndexCallback","hasScrollToIndex","defaultCellRangeRenderer","cellCache","cellRenderer","columnSizeAndPositionManager","columnStartIndex","columnStopIndex","deferredMeasurementCache","horizontalOffsetAdjustment","isScrolling","isScrollingOptOut","parent","rowSizeAndPositionManager","rowStartIndex","rowStopIndex","styleCache","verticalOffsetAdjustment","visibleColumnIndices","visibleRowIndices","renderedCells","areOffsetsAdjusted","canCacheStyle","rowIndex","rowDatum","columnIndex","columnDatum","isVisible","has","cellRendererParams","renderedCell","push","win","recalc","canUseDOM","scrollDiv","overflow","body","offsetWidth","_class","_temp","request","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","setTimeout","cancel","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","oCancelAnimationFrame","msCancelAnimationFrame","id","clearTimeout","raf","caf","frame","delay","Promise","resolve","then","Date","now","timeout","ownKeys","object","enumerableOnly","symbols","filter","sym","getOwnPropertyDescriptor","apply","_objectSpread","forEach","getOwnPropertyDescriptors","defineProperties","SCROLL_POSITION_CHANGE_REASONS","_React$PureComponent","Grid","_this","_disablePointerEventsTimeoutId","needToResetStyleCache","onSectionRendered","_onGridRenderedMemoizer","columnOverscanStartIndex","_columnStartIndex","columnOverscanStopIndex","_columnStopIndex","_renderedColumnStartIndex","_renderedColumnStopIndex","rowOverscanStartIndex","_rowStartIndex","rowOverscanStopIndex","_rowStopIndex","_renderedRowStartIndex","_renderedRowStopIndex","ref","_scrollingContainer","handleScrollEvent","columnCount","_wrapSizeGetter","columnWidth","_getEstimatedColumnSize","rowCount","rowHeight","_getEstimatedRowSize","instanceProps","prevColumnWidth","prevRowHeight","prevColumnCount","prevRowCount","prevIsScrolling","prevScrollToColumn","scrollToColumn","prevScrollToRow","scrollToRow","scrollbarSize","scrollbarSizeMeasured","scrollDirectionHorizontal","scrollDirectionVertical","scrollLeft","scrollTop","scrollPositionChangeReason","_initialScrollTop","_getCalculatedScrollTop","_initialScrollLeft","_getCalculatedScrollLeft","_ref$alignment","alignment","_ref$columnIndex","_ref$rowIndex","offsetProps","_ref2$scrollLeft","scrollLeftParam","_ref2$scrollTop","scrollTopParam","_debounceScrollEnded","_this$props","autoHeight","autoWidth","totalRowsHeight","totalColumnsWidth","newState","_invokeOnScrollMemoizer","_deferredInvalidateColumnIndex","_deferredInvalidateRowIndex","_this$props2","_ref4$columnIndex","_ref4$rowIndex","_this$props3","_recomputeScrollLeftFlag","_recomputeScrollTopFlag","_styleCache","_cellCache","forceUpdate","_updateScrollLeftForScrollToColumn","_updateScrollTopForScrollToRow","_this$props4","getScrollbarSize","_handleInvalidatedGridSize","stateUpdate","_getScrollToPositionStateUpdate","sizeIsBiggerThanZero","_invokeOnGridRenderedHelper","_maybeCallOnScrollbarPresenceChange","_this2","_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","cellRangeRenderer","overscanColumnCount","overscanIndicesGetter","overscanRowCount","getOffsetAdjustment","overscanColumnIndices","overscanRowIndices","hasFixedHeight","hasFixedWidth","scrollingResetTimeInterval","_debounceScrollEndedCallback","recomputeGridSize","_this3","_onScrollMemoizer","_this3$props","scrollHeight","scrollWidth","hasOwnProperty","Boolean","onScrollbarPresenceChange","_ref8","_getScrollLeftForScrollToColumnStateUpdate","_getScrollTopForScrollToRowStateUpdate","assign","maybeStateA","maybeStateB","estimatedColumnSize","estimatedRowSize","_ref9","finalColumn","scrollBarSize","calculatedScrollLeft","finalRow","calculatedScrollTop","ArrowKeyStepper","_getPrototypeOf2","_len","args","_key","disabled","mode","_this$_getScrollState","_getScrollState","scrollToColumnPrevious","scrollToRowPrevious","_this$_getScrollState2","preventDefault","_updateScrollState","_this$_getScrollState3","onKeyDown","_onKeyDown","_onSectionRendered","isControlled","onScrollToChange","_React$Component","AutoSizer","defaultHeight","defaultWidth","disableHeight","disableWidth","onResize","_parentNode","offsetHeight","_window","getComputedStyle","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","newHeight","newWidth","autoSizer","_autoSizer","nonce","parentNode","ownerDocument","defaultView","HTMLElement","_detectElementResize","addResizeListener","_onResize","removeResizeListener","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","get","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","cellRenderers","x","y","collectionStyle","propTypes","Section","_indexMap","_indices","SectionManager","sectionSize","_sectionSize","_cellMetadata","_sections","getSections","section","getCellIndices","map","sectionXStart","sectionXStop","sectionYStart","sectionYStop","sections","sectionX","sectionY","cellMetadatum","addCellIndex","_ref$align","cellOffset","Collection","context","_lastRenderedCellIndices","_isScrollingChange","_setCollectionViewRef","_collectionView","recomputeCellSizesAndPositions","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","component","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","ge","a","c","l","h","m","_GEP","_GEA","gt","_GTP","_GTA","lt","_LTP","_LTA","le","_LEP","_LEA","eq","_EQP","_EQA","IntervalTreeNode","mid","leftPoints","rightPoints","count","proto","copy","b","rebuild","intervals","ntree","createIntervalTree","rebuildWithInterval","rebuildWithoutInterval","idx","splice","reportLeftRange","hi","cb","r","reportRightRange","lo","reportRange","compareNumbers","compareBegin","d","compareEnd","pts","sort","leftIntervals","rightIntervals","centerIntervals","s","IntervalTree","result","insert","weight","remove","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","noop","createCellPositioner","columnHeights","_ref$spacer","spacer","initOrResetDerivedValues","reset","CellMeasurerCacheDecorator","_cellMeasurerCache","_columnIndexOffset","_rowIndexOffset","_params$columnIndexOf","columnIndexOffset","_params$rowIndexOffse","rowIndexOffset","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","ScrollSync","createMultiSort","sortCallback","defaultSortBy","_ref$defaultSortDirec","defaultSortDirection","sortBy","sortDirection","dataKey","shiftKey","ctrlKey","metaKey","defaultCellDataGetter","rowData","defaultCellRenderer","cellData","defaultHeaderRowRenderer","columns","ASC","DESC","SortIndicator","viewBox","fill","defaultHeaderRenderer","label","showSortIndicator","title","defaultRowRenderer","onRowClick","onRowDoubleClick","onRowMouseOut","onRowMouseOver","onRowRightClick","a11yProps","onClick","onDoubleClick","onMouseOut","onMouseOver","onContextMenu","Column","cellDataGetter","flexGrow","flexShrink","headerRenderer","Table","scrollbarWidth","_createColumn","_createRow","_ref3$columnIndex","_ref3$rowIndex","_Grid","_setScrollbarWidth","disableHeader","gridClassName","headerHeight","headerRowRenderer","rowClassName","rowStyle","availableRowsHeight","rowClass","rowStyleObject","_cachedColumnStyles","toArray","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","instance","__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","obj","fails","nativeGetOwnPropertyNames","stat","getOwnPropertyNames","isInteger","path","createDetectElementResize","hostWindow","attachEvent","requestFrame","fn","cancelFrame","resetTriggers","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","scrollListener","__resizeRAF__","__resizeLast__","checkTriggers","__resizeListeners__","animation","keyframeprefix","animationstartevent","domPrefixes","split","startEvents","elm","animationName","toLowerCase","animationKeyframes","animationStyle","doc","elementStyle","getElementById","css","head","getElementsByTagName","setAttribute","styleSheet","createTextNode","createStyles","resizeTriggersHtml","trustedTypes","staticPolicy","createPolicy","createHTML","innerHTML","__animationListener__","detachEvent","_s","_e","_x","_r","_arr","_n","_d","next","done","err","arg","_extends","lastIndexOf","_createClass","_react2","_interopRequireDefault","_propTypes2","_jsImageZoom2","default","ReactImageZoom","_classCallCheck","_possibleConstructorReturn","getRef","_inherits","rerenderImageZoom","imageZoom","JSON","parse","stringify","number","string","oneOf"],"mappings":"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","file":"vendors~desktopRedisMapping.51485e102a4d17078257.js","sourcesContent":["(function (root, factory) {\n    if (typeof module !== 'undefined' && module.exports) {\n        module.exports = factory();\n    } else {\n        root.ImageZoom = factory();\n    }\n}(this, function () {\n    /**\n     * @param {Object} container DOM element, which contains an image to be zoomed (required)\n     * @param {Object} options js-image-zoom options (required)\n     * **width** (number) - width of the source image (optional)\n     * **height** (number) - height of the source image (optional).\n     * **zoomWidth** (number) - width of the zoomed image. Zoomed image height equals source image height (optional)\n     * **img** (string) - url of the source image. Provided if container does not contain img element as a tag (optional)\n     * **scale** (number) - zoom scale. if not provided, scale is calculated as natural image size / image size, provided in params (optional if zoomWidth param is provided)\n     * **offset** (object) - {vertical: number, horizontal: number}. Zoomed image offset (optional)\n     * **zoomContainer** (node) - DOM node reference where zoomedImage will be appended to (default to the container element of image)\n     * **zoomStyle** (string) - custom style applied to the zoomed image (i.e. 'opacity: 0.1;background-color: white;')\n     * **zoomPosition** (string) - position of zoomed image. It can be:  `top`, `left`, `bottom`, `original` or the default `right`.\n     * **zoomLensStyle** (string) custom style applied to to zoom lents (i.e. 'opacity: 0.1;background-color: white;')\n     */\n    return function ImageZoom(container, opts) {\n        \"use strict\";\n        var options = opts;\n        if (!container) {\n            return;\n        }\n        var data = {\n            sourceImg: {\n                element: null,\n                width: 0,\n                height: 0,\n                naturalWidth: 0,\n                naturalHeight: 0\n            },\n            zoomedImgOffset: {\n                vertical: 0,\n                horizontal: 0\n            },\n            zoomedImg: {\n                element: null,\n                width: 0,\n                height: 0\n            },\n            zoomLens: {\n                element: null,\n                width: 0,\n                height: 0\n            }\n        };\n\n        var div = document.createElement('div');\n        var lensDiv = document.createElement('div');\n        var scaleX;\n        var scaleY;\n        var offset;\n        data.zoomedImgOffset = {\n            vertical: options.offset && options.offset.vertical ? options.offset.vertical : 0,\n            horizontal: options.offset && options.offset.horizontal ? options.offset.horizontal : 0\n        };\n        data.zoomPosition = options.zoomPosition || 'right';\n        data.zoomContainer = (options.zoomContainer) ? options.zoomContainer : container;\n        function getOffset(el) {\n            if (el) {\n                var elRect = el.getBoundingClientRect();\n                return {left: elRect.left, top: elRect.top};\n            }\n            return {left: 0, top: 0};\n        }\n\n        function leftLimit(min) {\n            return options.width - min;\n        }\n\n        function topLimit(min) {\n            return options.height - min;\n        }\n\n        function getValue(val, min, max) {\n            if (val < min) {\n                return min;\n            }\n            if (val > max) {\n                return max;\n            }\n            return val;\n        }\n\n        function getPosition(v, min, max) {\n            var value = getValue(v, min, max);\n            return value - min;\n        }\n\n        function zoomLensLeft(left) {\n            var leftMin = data.zoomLens.width / 2;\n            return getPosition(left, leftMin, leftLimit(leftMin));\n        }\n\n        function zoomLensTop(top) {\n            var topMin = data.zoomLens.height / 2;\n            return getPosition(top, topMin, topLimit(topMin));\n        }\n\n        function setZoomedImgSize(options, data) {\n            if (options.scale) {\n                data.zoomedImg.element.style.width = options.width * options.scale + 'px';\n                data.zoomedImg.element.style.height = options.height * options.scale + 'px';\n            } else if (options.zoomWidth) {\n                data.zoomedImg.element.style.width = options.zoomWidth + 'px';\n                data.zoomedImg.element.style.height = data.sourceImg.element.style.height;\n            } else {\n                data.zoomedImg.element.style.width = '100%';\n                data.zoomedImg.element.style.height = '100%';\n            }\n        }\n\n        function onSourceImgLoad() {\n            // use height determined by browser if height is not set in options\n            options.height = options.height || data.sourceImg.element.height;\n            data.sourceImg.element.style.height = options.height + 'px';\n\n            // use width determined by browser if width is not set in options\n            options.width = options.width || data.sourceImg.element.width;\n            data.sourceImg.element.style.width = options.width + 'px';\n\n            setZoomedImgSize(options, data);\n\n            data.sourceImg.naturalWidth = data.sourceImg.element.naturalWidth;\n            data.sourceImg.naturalHeight = data.sourceImg.element.naturalHeight;\n            data.zoomedImg.element.style.backgroundSize = data.sourceImg.naturalWidth + 'px ' + data.sourceImg.naturalHeight + 'px';\n\n            if (options.zoomStyle) {\n                data.zoomedImg.element.style.cssText += options.zoomStyle;\n            }\n            if (options.zoomLensStyle) {\n                data.zoomLens.element.style.cssText += options.zoomLensStyle;\n            } else {\n                data.zoomLens.element.style.background = 'white';\n                data.zoomLens.element.style.opacity = '0.4';\n            }\n\n            scaleX = data.sourceImg.naturalWidth / options.width;\n            scaleY = data.sourceImg.naturalHeight / options.height;\n            offset = getOffset(data.sourceImg.element);\n\n            // set zoomLens dimensions\n            // if custom scale is set\n            if (options.scale) {\n                data.zoomLens.width = options.width / (data.sourceImg.naturalWidth / (options.width * options.scale));\n                data.zoomLens.height = options.height / (data.sourceImg.naturalHeight / (options.height * options.scale));\n            }\n\n            // else if zoomWidth is set\n            else if (options.zoomWidth) {\n                data.zoomLens.width = options.zoomWidth / scaleX;\n                data.zoomLens.height = options.height / scaleY;\n            }\n\n            // else read from the zoomedImg\n            else {\n                data.zoomedImg.element.style.display = 'block';\n                data.zoomLens.width = data.zoomedImg.element.clientWidth / scaleX;\n                data.zoomLens.height = data.zoomedImg.element.clientHeight / scaleY;\n                data.zoomedImg.element.style.display = 'none';\n            }\n\n            data.zoomLens.element.style.position = 'absolute';\n            data.zoomLens.element.style.width = data.zoomLens.width + 'px';\n            data.zoomLens.element.style.height = data.zoomLens.height + 'px';\n            data.zoomLens.element.pointerEvents = 'none';\n        }\n\n        function setup() {\n            // create sourceImg element\n            if (options.img) {\n                var img = document.createElement('img');\n                img.src = options.img;\n                data.sourceImg.element = container.appendChild(img);\n            }\n\n            // or get sourceImg element from specified container\n            else {\n                data.sourceImg.element = container.children[0];\n\n                // if sourceImg is not an img (might be a picture element), try to find one\n                if (data.sourceImg.element.nodeName !== \"IMG\") {\n                    data.sourceImg.element = data.sourceImg.element.querySelector('img');\n                }\n            }\n\n            options = options || {};\n            container.style.position = 'relative';\n            data.sourceImg.element.style.width = options.width ? options.width + 'px' : 'auto';\n            data.sourceImg.element.style.height = options.height ? options.height + 'px' : 'auto';\n\n            data.zoomLens.element = container.appendChild(lensDiv);\n            data.zoomLens.element.style.display = 'none';\n            data.zoomLens.element.classList.add('js-image-zoom__zoomed-area');\n\n            data.zoomedImg.element = data.zoomContainer.appendChild(div);\n            data.zoomedImg.element.classList.add('js-image-zoom__zoomed-image');\n            data.zoomedImg.element.style.backgroundImage = \"url('\" + data.sourceImg.element.src + \"')\";\n            data.zoomedImg.element.style.backgroundRepeat = 'no-repeat';\n            data.zoomedImg.element.style.display = 'none';\n\n            switch (data.zoomPosition) {\n                case 'left':\n                    data.zoomedImg.element.style.position = 'absolute';\n                    data.zoomedImg.element.style.top = data.zoomedImgOffset.vertical + 'px';\n                    data.zoomedImg.element.style.left = data.zoomedImgOffset.horizontal - (data.zoomedImgOffset.horizontal * 2) + 'px';\n                    data.zoomedImg.element.style.transform = 'translateX(-100%)';\n                    break;\n\n                case 'top':\n                    data.zoomedImg.element.style.position = 'absolute';\n                    data.zoomedImg.element.style.top = data.zoomedImgOffset.vertical - (data.zoomedImgOffset.vertical * 2) + 'px';\n                    data.zoomedImg.element.style.left = 'calc(50% + ' + data.zoomedImgOffset.horizontal + 'px)';\n                    data.zoomedImg.element.style.transform = 'translate3d(-50%, -100%, 0)';\n                    break;\n\n                case 'bottom':\n                    data.zoomedImg.element.style.position = 'absolute';\n                    data.zoomedImg.element.style.bottom = data.zoomedImgOffset.vertical - (data.zoomedImgOffset.vertical * 2) + 'px';\n                    data.zoomedImg.element.style.left = 'calc(50% + ' + data.zoomedImgOffset.horizontal + 'px)';\n                    data.zoomedImg.element.style.transform = 'translate3d(-50%, 100%, 0)';\n                    break;\n\n                case 'original':\n                    data.zoomedImg.element.style.position = 'absolute';\n                    data.zoomedImg.element.style.top = '0px';\n                    data.zoomedImg.element.style.left = '0px';\n                    break;\n\n                // Right Position\n                default:\n                    data.zoomedImg.element.style.position = 'absolute';\n                    data.zoomedImg.element.style.top = data.zoomedImgOffset.vertical + 'px';\n                    data.zoomedImg.element.style.right = data.zoomedImgOffset.horizontal - (data.zoomedImgOffset.horizontal * 2) + 'px';\n                    data.zoomedImg.element.style.transform = 'translateX(100%)';\n                    break;\n            }\n\n\n            // setup event listeners\n            container.addEventListener('mousemove', events, false);\n            container.addEventListener('mouseenter', events, false);\n            container.addEventListener('mouseleave', events, false);\n            data.zoomLens.element.addEventListener('mouseenter', events, false);\n            data.zoomLens.element.addEventListener('mouseleave', events, false);\n            window.addEventListener('scroll', events, false);\n\n            return data;\n        }\n\n        function kill() {\n\n            // remove event listeners\n            container.removeEventListener('mousemove', events, false);\n            container.removeEventListener('mouseenter', events, false);\n            container.removeEventListener('mouseleave', events, false);\n            data.zoomLens.element.removeEventListener('mouseenter', events, false);\n            data.zoomLens.element.removeEventListener('mouseleave', events, false);\n            window.removeEventListener('scroll', events, false);\n\n            // remove dom nodes\n            if (data.zoomLens && data.zoomedImg) {\n                container.removeChild(data.zoomLens.element);\n                data.zoomContainer.removeChild(data.zoomedImg.element);\n            }\n\n            if (options.img) {\n                container.removeChild(data.sourceImg.element);\n            } else {\n                data.sourceImg.element.style.width = '';\n                data.sourceImg.element.style.height = '';\n            }\n\n            return data;\n        }\n\n        var events = {\n            handleEvent: function (event) {\n                switch (event.type) {\n                    case 'mousemove':\n                        return this.handleMouseMove(event);\n                    case 'mouseenter':\n                        return this.handleMouseEnter(event);\n                    case 'mouseleave':\n                        return this.handleMouseLeave(event);\n                    case 'scroll':\n                        return this.handleScroll(event);\n                }\n            },\n            handleMouseMove: function (event) {\n                var offsetX;\n                var offsetY;\n                var backgroundTop;\n                var backgroundRight;\n                var backgroundPosition;\n                if (offset) {\n                    offsetX = zoomLensLeft(event.clientX - offset.left);\n                    offsetY = zoomLensTop(event.clientY - offset.top);\n                    backgroundTop = offsetX * scaleX;\n                    backgroundRight = offsetY * scaleY;\n                    backgroundPosition = '-' + backgroundTop + 'px ' + '-' + backgroundRight + 'px';\n                    data.zoomedImg.element.style.backgroundPosition = backgroundPosition;\n                    data.zoomLens.element.style.cssText += 'top:' + offsetY + 'px;' + 'left:' + offsetX + 'px;display: block;';\n\n                }\n            },\n            handleMouseEnter: function () {\n                data.zoomedImg.element.style.display = 'block';\n                data.zoomLens.element.style.display = 'block';\n\n            },\n            handleMouseLeave: function () {\n                data.zoomedImg.element.style.display = 'none';\n                data.zoomLens.element.style.display = 'none';\n            },\n            handleScroll: function () {\n                offset = getOffset(data.sourceImg.element);\n            }\n        };\n\n        // Setup/Initialize library\n        setup();\n\n        if (data.sourceImg.element.complete) {\n            onSourceImgLoad();\n        } else {\n            data.sourceImg.element.onload = onSourceImgLoad;\n        }\n\n        return {\n            setup: function () {\n                setup();\n            },\n            kill: function () {\n                kill();\n            },\n            _getInstanceInfo: function () {\n                return {\n                    setup: setup,\n                    kill: kill,\n                    onSourceImgLoad: onSourceImgLoad,\n                    data: data,\n                    options: options\n                }\n            }\n        }\n    }\n}));\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nmodule.exports = _toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nmodule.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var $ = require('../internals/export');\nvar global = require('../internals/global');\nvar task = require('../internals/task');\n\nvar FORCED = !global.setImmediate || !global.clearImmediate;\n\n// http://w3c.github.io/setImmediate/\n$({ global: true, bind: true, enumerable: true, forced: FORCED }, {\n  // `setImmediate` method\n  // http://w3c.github.io/setImmediate/#si-setImmediate\n  setImmediate: task.set,\n  // `clearImmediate` method\n  // http://w3c.github.io/setImmediate/#si-clearImmediate\n  clearImmediate: task.clear\n});\n","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableRest = require(\"./nonIterableRest.js\");\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var objectWithoutPropertiesLoose = require(\"./objectWithoutPropertiesLoose.js\");\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nmodule.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\nvar iterableToArray = require(\"./iterableToArray.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _setPrototypeOf(o, p);\n}\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `Number.isInteger` method implementation\n// https://tc39.github.io/ecma262/#sec-number.isinteger\nmodule.exports = function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nfunction componentWillMount() {\n  // Call this.constructor.gDSFP to support sub-classes.\n  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);\n  if (state !== null && state !== undefined) {\n    this.setState(state);\n  }\n}\n\nfunction componentWillReceiveProps(nextProps) {\n  // Call this.constructor.gDSFP to support sub-classes.\n  // Use the setState() updater to ensure state isn't stale in certain edge cases.\n  function updater(prevState) {\n    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);\n    return state !== null && state !== undefined ? state : null;\n  }\n  // Binding \"this\" is important for shallow renderer support.\n  this.setState(updater.bind(this));\n}\n\nfunction componentWillUpdate(nextProps, nextState) {\n  try {\n    var prevProps = this.props;\n    var prevState = this.state;\n    this.props = nextProps;\n    this.state = nextState;\n    this.__reactInternalSnapshotFlag = true;\n    this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(\n      prevProps,\n      prevState\n    );\n  } finally {\n    this.props = prevProps;\n    this.state = prevState;\n  }\n}\n\n// React may warn about cWM/cWRP/cWU methods being deprecated.\n// Add a flag to suppress these warnings for this special case.\ncomponentWillMount.__suppressDeprecationWarning = true;\ncomponentWillReceiveProps.__suppressDeprecationWarning = true;\ncomponentWillUpdate.__suppressDeprecationWarning = true;\n\nfunction polyfill(Component) {\n  var prototype = Component.prototype;\n\n  if (!prototype || !prototype.isReactComponent) {\n    throw new Error('Can only polyfill class components');\n  }\n\n  if (\n    typeof Component.getDerivedStateFromProps !== 'function' &&\n    typeof prototype.getSnapshotBeforeUpdate !== 'function'\n  ) {\n    return Component;\n  }\n\n  // If new component APIs are defined, \"unsafe\" lifecycles won't be called.\n  // Error if any of these lifecycles are present,\n  // Because they would work differently between older and newer (16.3+) versions of React.\n  var foundWillMountName = null;\n  var foundWillReceivePropsName = null;\n  var foundWillUpdateName = null;\n  if (typeof prototype.componentWillMount === 'function') {\n    foundWillMountName = 'componentWillMount';\n  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {\n    foundWillMountName = 'UNSAFE_componentWillMount';\n  }\n  if (typeof prototype.componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'componentWillReceiveProps';\n  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';\n  }\n  if (typeof prototype.componentWillUpdate === 'function') {\n    foundWillUpdateName = 'componentWillUpdate';\n  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {\n    foundWillUpdateName = 'UNSAFE_componentWillUpdate';\n  }\n  if (\n    foundWillMountName !== null ||\n    foundWillReceivePropsName !== null ||\n    foundWillUpdateName !== null\n  ) {\n    var componentName = Component.displayName || Component.name;\n    var newApiName =\n      typeof Component.getDerivedStateFromProps === 'function'\n        ? 'getDerivedStateFromProps()'\n        : 'getSnapshotBeforeUpdate()';\n\n    throw Error(\n      'Unsafe legacy lifecycles will not be called for components using new component APIs.\\n\\n' +\n        componentName +\n        ' uses ' +\n        newApiName +\n        ' but also contains the following legacy lifecycles:' +\n        (foundWillMountName !== null ? '\\n  ' + foundWillMountName : '') +\n        (foundWillReceivePropsName !== null\n          ? '\\n  ' + foundWillReceivePropsName\n          : '') +\n        (foundWillUpdateName !== null ? '\\n  ' + foundWillUpdateName : '') +\n        '\\n\\nThe above lifecycles should be removed. Learn more about this warning here:\\n' +\n        'https://fb.me/react-async-component-lifecycle-hooks'\n    );\n  }\n\n  // React <= 16.2 does not support static getDerivedStateFromProps.\n  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.\n  // Newer versions of React will ignore these lifecycles if gDSFP exists.\n  if (typeof Component.getDerivedStateFromProps === 'function') {\n    prototype.componentWillMount = componentWillMount;\n    prototype.componentWillReceiveProps = componentWillReceiveProps;\n  }\n\n  // React <= 16.2 does not support getSnapshotBeforeUpdate.\n  // As a workaround, use cWU to invoke the new lifecycle.\n  // Newer versions of React will ignore that lifecycle if gSBU exists.\n  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {\n    if (typeof prototype.componentDidUpdate !== 'function') {\n      throw new Error(\n        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'\n      );\n    }\n\n    prototype.componentWillUpdate = componentWillUpdate;\n\n    var componentDidUpdate = prototype.componentDidUpdate;\n\n    prototype.componentDidUpdate = function componentDidUpdatePolyfill(\n      prevProps,\n      prevState,\n      maybeSnapshot\n    ) {\n      // 16.3+ will not execute our will-update method;\n      // It will pass a snapshot value to did-update though.\n      // Older versions will require our polyfilled will-update value.\n      // We need to handle both cases, but can't just check for the presence of \"maybeSnapshot\",\n      // Because for <= 15.x versions this might be a \"prevContext\" object.\n      // We also can't just check \"__reactInternalSnapshot\",\n      // Because get-snapshot might return a falsy value.\n      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.\n      var snapshot = this.__reactInternalSnapshotFlag\n        ? this.__reactInternalSnapshot\n        : maybeSnapshot;\n\n      componentDidUpdate.call(this, prevProps, prevState, snapshot);\n    };\n  }\n\n  return Component;\n}\n\nexport { polyfill };\n","function r(e){var t,f,n=\"\";if(\"string\"==typeof e||\"number\"==typeof e)n+=e;else if(\"object\"==typeof e)if(Array.isArray(e))for(t=0;t<e.length;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=\" \"),n+=f);else for(t in e)e[t]&&(n&&(n+=\" \"),n+=t);return n}export function clsx(){for(var e,t,f=0,n=\"\";f<arguments.length;)(e=arguments[f++])&&(t=r(e))&&(n&&(n+=\" \"),n+=t);return n}export default clsx;","/**\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\";","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};","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\";","/**\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}","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\";","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\";","/**\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 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  // 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\";","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;","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 Collection from './Collection';\nexport default Collection;\nexport { Collection };","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 ColumnSizer from './ColumnSizer';\nexport default ColumnSizer;\nexport { ColumnSizer };","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 InfiniteLoader from './InfiniteLoader';\nexport default InfiniteLoader;\nexport { InfiniteLoader };","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 };","export default function createCellPositioner(_ref) {\n  var cellMeasurerCache = _ref.cellMeasurerCache,\n      columnCount = _ref.columnCount,\n      columnWidth = _ref.columnWidth,\n      _ref$spacer = _ref.spacer,\n      spacer = _ref$spacer === void 0 ? 0 : _ref$spacer;\n  var columnHeights;\n  initOrResetDerivedValues();\n\n  function cellPositioner(index) {\n    // Find the shortest column and use it.\n    var columnIndex = 0;\n\n    for (var i = 1; i < columnHeights.length; i++) {\n      if (columnHeights[i] < columnHeights[columnIndex]) {\n        columnIndex = i;\n      }\n    }\n\n    var left = columnIndex * (columnWidth + spacer);\n    var top = columnHeights[columnIndex] || 0;\n    columnHeights[columnIndex] = top + cellMeasurerCache.getHeight(index) + spacer;\n    return {\n      left: left,\n      top: top\n    };\n  }\n\n  function initOrResetDerivedValues() {\n    // Track the height of each column.\n    // Layout algorithm below always inserts into the shortest column.\n    columnHeights = [];\n\n    for (var i = 0; i < columnCount; i++) {\n      columnHeights[i] = 0;\n    }\n  }\n\n  function reset(params) {\n    columnCount = params.columnCount;\n    columnWidth = params.columnWidth;\n    spacer = params.spacer;\n    initOrResetDerivedValues();\n  }\n\n  cellPositioner.reset = reset;\n  return cellPositioner;\n}\nimport { bpfrpt_proptype_CellMeasurerCache } from \"./Masonry\";\nimport { bpfrpt_proptype_Positioner } from \"./Masonry\";","import createCellPositioner from './createCellPositioner';\nimport Masonry from './Masonry';\nexport default Masonry;\nexport { createCellPositioner, Masonry };","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 _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} : {};","export default function createMultiSort(sortCallback) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      defaultSortBy = _ref.defaultSortBy,\n      _ref$defaultSortDirec = _ref.defaultSortDirection,\n      defaultSortDirection = _ref$defaultSortDirec === void 0 ? {} : _ref$defaultSortDirec;\n\n  if (!sortCallback) {\n    throw Error(\"Required parameter \\\"sortCallback\\\" not specified\");\n  }\n\n  var sortBy = defaultSortBy || [];\n  var sortDirection = {};\n  sortBy.forEach(function (dataKey) {\n    sortDirection[dataKey] = defaultSortDirection[dataKey] !== undefined ? defaultSortDirection[dataKey] : 'ASC';\n  });\n\n  function sort(_ref2) {\n    var defaultSortDirection = _ref2.defaultSortDirection,\n        event = _ref2.event,\n        dataKey = _ref2.sortBy;\n\n    if (event.shiftKey) {\n      // Shift + click appends a column to existing criteria\n      if (sortDirection[dataKey] !== undefined) {\n        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';\n      } else {\n        sortDirection[dataKey] = defaultSortDirection;\n        sortBy.push(dataKey);\n      }\n    } else if (event.ctrlKey || event.metaKey) {\n      // Control + click removes column from sort (if pressent)\n      var index = sortBy.indexOf(dataKey);\n\n      if (index >= 0) {\n        sortBy.splice(index, 1);\n        delete sortDirection[dataKey];\n      }\n    } else {\n      // Clear sortBy array of all non-selected keys\n      sortBy.length = 0;\n      sortBy.push(dataKey); // Clear sortDirection object of all non-selected keys\n\n      var sortDirectionKeys = Object.keys(sortDirection);\n      sortDirectionKeys.forEach(function (key) {\n        if (key !== dataKey) delete sortDirection[key];\n      }); // If key is already selected, reverse sort direction.\n      // Else, set sort direction to default direction.\n\n      if (sortDirection[dataKey] !== undefined) {\n        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';\n      } else {\n        sortDirection[dataKey] = defaultSortDirection;\n      }\n    } // Notify application code\n\n\n    sortCallback({\n      sortBy: sortBy,\n      sortDirection: sortDirection\n    });\n  }\n\n  return {\n    sort: sort,\n    sortBy: sortBy,\n    sortDirection: sortDirection\n  };\n}","/**\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 * 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\";","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\";","import createMultiSort from './createMultiSort';\nimport defaultCellDataGetter from './defaultCellDataGetter';\nimport defaultCellRenderer from './defaultCellRenderer';\nimport defaultHeaderRowRenderer from './defaultHeaderRowRenderer.js';\nimport defaultHeaderRenderer from './defaultHeaderRenderer';\nimport defaultRowRenderer from './defaultRowRenderer';\nimport Column from './Column';\nimport SortDirection from './SortDirection';\nimport SortIndicator from './SortIndicator';\nimport Table from './Table';\nexport default Table;\nexport { createMultiSort, defaultCellDataGetter, defaultCellRenderer, defaultHeaderRowRenderer, defaultHeaderRenderer, defaultRowRenderer, Column, SortDirection, SortIndicator, Table };","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\";","export { ArrowKeyStepper } from './ArrowKeyStepper';\nexport { AutoSizer } from './AutoSizer';\nexport { CellMeasurer, CellMeasurerCache } from './CellMeasurer';\nexport { Collection } from './Collection';\nexport { ColumnSizer } from './ColumnSizer';\nexport { accessibilityOverscanIndicesGetter, defaultCellRangeRenderer, defaultOverscanIndicesGetter, Grid } from './Grid';\nexport { InfiniteLoader } from './InfiniteLoader';\nexport { List } from './List';\nexport { createCellPositioner as createMasonryCellPositioner, Masonry } from './Masonry';\nexport { MultiGrid } from './MultiGrid';\nexport { ScrollSync } from './ScrollSync';\nexport { createMultiSort as createTableMultiSort, defaultCellDataGetter as defaultTableCellDataGetter, defaultCellRenderer as defaultTableCellRenderer, defaultHeaderRenderer as defaultTableHeaderRenderer, defaultHeaderRowRenderer as defaultTableHeaderRowRenderer, defaultRowRenderer as defaultTableRowRenderer, Table, Column, SortDirection, SortIndicator } from './Table';\nexport { WindowScroller } from './WindowScroller';","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar nativeGetOwnPropertyNames = require('../internals/object-get-own-property-names-external').f;\n\nvar FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); });\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertynames\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n  getOwnPropertyNames: nativeGetOwnPropertyNames\n});\n","var $ = require('../internals/export');\nvar isInteger = require('../internals/is-integer');\n\n// `Number.isInteger` method\n// https://tc39.github.io/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n  isInteger: isInteger\n});\n","require('../modules/web.immediate');\nvar path = require('../internals/path');\n\nmodule.exports = path;\n","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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}","function _iterableToArrayLimit(arr, i) {\n  var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (null != _i) {\n    var _s,\n      _e,\n      _x,\n      _r,\n      _arr = [],\n      _n = !0,\n      _d = !1;\n    try {\n      if (_x = (_i = _i.call(arr)).next, 0 === i) {\n        if (Object(_i) !== _i) return;\n        _n = !1;\n      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);\n    } catch (err) {\n      _d = !0, _e = err;\n    } finally {\n      try {\n        if (!_n && null != _i[\"return\"] && (_r = _i[\"return\"](), Object(_r) !== _r)) return;\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n}\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}\nmodule.exports = _toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _extends() {\n  module.exports = _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _extends.apply(this, arguments);\n}\nmodule.exports = _extends, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var $ = require('../internals/export');\nvar lastIndexOf = require('../internals/array-last-index-of');\n\n// `Array.prototype.lastIndexOf` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof\n$({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, {\n  lastIndexOf: lastIndexOf\n});\n","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _jsImageZoom = require('js-image-zoom');\n\nvar _jsImageZoom2 = _interopRequireDefault(_jsImageZoom);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar ReactImageZoom = function (_React$Component) {\n  _inherits(ReactImageZoom, _React$Component);\n\n  function ReactImageZoom(props) {\n    _classCallCheck(this, ReactImageZoom);\n\n    var _this = _possibleConstructorReturn(this, (ReactImageZoom.__proto__ || Object.getPrototypeOf(ReactImageZoom)).call(this, props));\n\n    _this.container = undefined;\n    _this.getRef = _this.getRef.bind(_this);\n    return _this;\n  }\n\n  _createClass(ReactImageZoom, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      this.rerenderImageZoom(this.props);\n    }\n  }, {\n    key: 'UNSAFE_componentWillUnmount',\n    value: function UNSAFE_componentWillUnmount() {\n      this.imageZoom.kill();\n      this.imageZoom = void 0;\n    }\n  }, {\n    key: 'UNSAFE_componentWillReceiveProps',\n    value: function UNSAFE_componentWillReceiveProps(nextProps) {\n      if (this.props !== nextProps) {\n        this.kill();\n        this.rerenderImageZoom(nextProps);\n      }\n    }\n  }, {\n    key: 'rerenderImageZoom',\n    value: function rerenderImageZoom(props) {\n      this.imageZoom = new _jsImageZoom2.default(this.container, JSON.parse(JSON.stringify(props)));\n    }\n  }, {\n    key: 'setup',\n    value: function setup() {\n      this.imageZoom.setup();\n    }\n  }, {\n    key: 'kill',\n    value: function kill() {\n      this.imageZoom.kill();\n    }\n  }, {\n    key: 'getRef',\n    value: function getRef(ref) {\n      this.container = ref;\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return _react2.default.createElement('div', { ref: this.getRef });\n    }\n  }]);\n\n  return ReactImageZoom;\n}(_react2.default.Component);\n\nReactImageZoom.propTypes = {\n  width: _propTypes2.default.number,\n  img: _propTypes2.default.string,\n  height: _propTypes2.default.number,\n  zoomWidth: _propTypes2.default.number,\n  scale: _propTypes2.default.number,\n  offset: _propTypes2.default.object,\n  zoomStyle: _propTypes2.default.string,\n  zoomLensStyle: _propTypes2.default.string,\n  zoomPosition: _propTypes2.default.oneOf(['top', 'left', 'bottom', 'right', 'original'])\n};\n\nexports.default = ReactImageZoom;\nmodule.exports = exports['default'];\n"],"sourceRoot":""}