{"version":3,"sources":["../node_modules/@babel/runtime/helpers/interopRequireDefault.js","../node_modules/react-virtualized/dist/commonjs/Grid/types.js","../node_modules/@babel/runtime/helpers/interopRequireWildcard.js","../node_modules/@babel/runtime/helpers/assertThisInitialized.js","../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","../node_modules/@babel/runtime/helpers/getPrototypeOf.js","../node_modules/@babel/runtime/helpers/inherits.js","../node_modules/react-virtualized/dist/commonjs/Grid/utils/ScalingCellSizeAndPositionManager.js","../node_modules/@babel/runtime/helpers/extends.js","../node_modules/react-virtualized/dist/commonjs/Grid/defaultOverscanIndicesGetter.js","../node_modules/react-virtualized/dist/commonjs/Grid/defaultCellRangeRenderer.js","../node_modules/react-virtualized/dist/commonjs/List/types.js","../node_modules/react-virtualized/dist/commonjs/List/List.js","../node_modules/@babel/runtime/helpers/setPrototypeOf.js","../node_modules/react-virtualized/dist/commonjs/Grid/index.js","../node_modules/react-virtualized/dist/commonjs/Grid/Grid.js","../node_modules/react-virtualized/dist/commonjs/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js","../node_modules/react-virtualized/dist/commonjs/Grid/utils/CellSizeAndPositionManager.js","../node_modules/react-virtualized/dist/commonjs/Grid/utils/maxElementSize.js","../node_modules/react-virtualized/dist/commonjs/utils/createCallbackMemoizer.js","../node_modules/react-virtualized/dist/commonjs/Grid/utils/updateScrollIndexHelper.js","../node_modules/react-virtualized/dist/commonjs/utils/requestAnimationTimeout.js","../node_modules/react-virtualized/dist/commonjs/utils/animationFrame.js","../node_modules/react-virtualized/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js","../node_modules/react-virtualized/dist/commonjs/AutoSizer/AutoSizer.js","../node_modules/react-virtualized/dist/commonjs/vendor/detectElementResize.js","../node_modules/dom-helpers/esm/canUseDOM.js","../node_modules/dom-helpers/esm/scrollbarSize.js","../node_modules/clsx/dist/clsx.m.js","../node_modules/react-virtualized/dist/commonjs/List/index.js","../node_modules/react-virtualized/dist/commonjs/AutoSizer/index.js"],"names":["module","exports","obj","__esModule","_interopRequireDefault","require","_interopRequireWildcard","Object","defineProperty","value","bpfrpt_proptype_VisibleCellRange","bpfrpt_proptype_Alignment","bpfrpt_proptype_OverscanIndicesGetter","bpfrpt_proptype_OverscanIndices","bpfrpt_proptype_OverscanIndicesGetterParams","bpfrpt_proptype_RenderedSection","bpfrpt_proptype_ScrollbarPresenceChange","bpfrpt_proptype_Scroll","bpfrpt_proptype_NoContentRenderer","bpfrpt_proptype_CellSize","bpfrpt_proptype_CellSizeGetter","bpfrpt_proptype_CellRangeRenderer","bpfrpt_proptype_CellRangeRendererParams","bpfrpt_proptype_StyleCache","bpfrpt_proptype_CellCache","bpfrpt_proptype_CellRenderer","bpfrpt_proptype_CellRendererParams","bpfrpt_proptype_CellPosition","_typeof","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","cache","has","get","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","self","ReferenceError","assertThisInitialized","TypeError","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","bind","__proto__","subClass","superClass","create","constructor","writable","configurable","_objectWithoutProperties2","_classCallCheck2","_createClass2","_defineProperty2","_CellSizeAndPositionManager","_maxElementSize","ScalingCellSizeAndPositionManager","_ref","_ref$maxScrollSize","maxScrollSize","getMaxElementSize","params","this","_cellSizeAndPositionManager","_maxScrollSize","getTotalSize","configure","getCellCount","getEstimatedCellSize","getLastMeasuredIndex","_ref2","containerSize","offset","totalSize","safeTotalSize","offsetPercentage","_getOffsetPercentage","Math","round","index","getSizeAndPositionOfCell","getSizeAndPositionOfLastMeasuredCell","min","_ref3","_ref3$align","align","currentOffset","targetIndex","_safeOffsetToOffset","getUpdatedOffsetForIndex","_offsetToSafeOffset","_ref4","getVisibleCellRange","resetCell","_ref5","_ref6","_ref7","_extends","assign","target","i","arguments","length","source","apply","cellCount","overscanCellsCount","scrollDirection","startIndex","stopIndex","overscanStartIndex","max","overscanStopIndex","SCROLL_DIRECTION_VERTICAL","SCROLL_DIRECTION_HORIZONTAL","SCROLL_DIRECTION_FORWARD","SCROLL_DIRECTION_BACKWARD","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","start","stop","concat","style","height","left","position","top","width","size","cellRendererParams","renderedCell","push","bpfrpt_proptype_RenderedRows","bpfrpt_proptype_RowRenderer","bpfrpt_proptype_RowRendererParams","_class","_temp","_extends2","_possibleConstructorReturn2","_getPrototypeOf3","_assertThisInitialized2","_inherits2","_Grid","React","_clsx","List","_React$PureComponent","_getPrototypeOf2","_this","_len","args","Array","_key","rowRenderer","props","widthDescriptor","ref","Grid","clientHeight","scrollHeight","scrollTop","onScroll","rowOverscanStartIndex","rowOverscanStopIndex","onRowsRendered","forceUpdate","alignment","getOffsetForCell","invalidateCellSizeAfterRender","measureAllCells","undefined","_ref6$columnIndex","_ref6$rowIndex","recomputeGridSize","scrollToPosition","scrollToCell","_this$props","className","noRowsRenderer","scrollToIndex","classNames","createElement","autoContainerWidth","_cellRenderer","columnWidth","columnCount","noContentRenderer","_onScroll","onSectionRendered","_onSectionRendered","_setRef","scrollToRow","PureComponent","autoHeight","estimatedRowSize","overscanIndicesGetter","accessibilityOverscanIndicesGetter","overscanRowCount","scrollToAlignment","_setPrototypeOf","p","enumerable","_accessibilityOverscanIndicesGetter","_defaultCellRangeRenderer","_defaultOverscanIndicesGetter","_types","DEFAULT_SCROLLING_RESET_TIME_INTERVAL","_calculateSizeAndPositionDataAndUpdateScrollOffset","_ScalingCellSizeAndPositionManager","_createCallbackMemoizer","_updateScrollIndexHelper","_scrollbarSize","_reactLifecyclesCompat","_requestAnimationTimeout","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","_objectSpread","forEach","getOwnPropertyDescriptors","defineProperties","SCROLL_POSITION_CHANGE_REASONS","_disablePointerEventsTimeoutId","setState","needToResetStyleCache","_onGridRenderedMemoizer","callback","indices","columnOverscanStartIndex","_columnStartIndex","columnOverscanStopIndex","_columnStopIndex","_renderedColumnStartIndex","_renderedColumnStopIndex","_rowStartIndex","_rowStopIndex","_renderedRowStartIndex","_renderedRowStopIndex","_scrollingContainer","event","handleScrollEvent","cellSizeGetter","_wrapSizeGetter","estimatedCellSize","_getEstimatedColumnSize","rowCount","rowHeight","_getEstimatedRowSize","state","instanceProps","prevColumnWidth","prevRowHeight","prevColumnCount","prevRowCount","prevIsScrolling","prevScrollToColumn","scrollToColumn","prevScrollToRow","scrollbarSize","scrollbarSizeMeasured","scrollDirectionHorizontal","scrollDirectionVertical","scrollLeft","scrollPositionChangeReason","_initialScrollTop","_getCalculatedScrollTop","_initialScrollLeft","_getCalculatedScrollLeft","_ref$alignment","_ref$columnIndex","_ref$rowIndex","offsetProps","_ref2$scrollLeft","scrollLeftParam","_ref2$scrollTop","scrollTopParam","_debounceScrollEnded","autoWidth","totalRowsHeight","totalColumnsWidth","newState","_invokeOnScrollMemoizer","_deferredInvalidateColumnIndex","_deferredInvalidateRowIndex","_this$props2","_ref4$columnIndex","_ref4$rowIndex","_this$props3","_recomputeScrollLeftFlag","_recomputeScrollTopFlag","_styleCache","_cellCache","_updateScrollLeftForScrollToColumn","_updateScrollTopForScrollToRow","_this$props4","getScrollbarSize","_handleInvalidatedGridSize","prevState","stateUpdate","_getScrollToPositionStateUpdate","sizeIsBiggerThanZero","_invokeOnGridRenderedHelper","_maybeCallOnScrollbarPresenceChange","prevProps","_this2","_this$props5","_this$state","columnOrRowCountJustIncreasedFromZero","sizeJustIncreasedFromZero","cellSizeAndPositionManager","previousCellsCount","previousCellSize","previousScrollToAlignment","previousScrollToIndex","previousSize","scrollOffset","updateScrollIndexCallback","cancelAnimationTimeout","_this$props6","containerProps","containerRole","containerStyle","id","role","tabIndex","_this$state2","_isScrolling","gridStyle","boxSizing","direction","WebkitOverflowScrolling","willChange","_resetStyleCache","_calculateChildrenToRender","verticalScrollBarSize","horizontalScrollBarSize","_horizontalScrollBarSize","_verticalScrollBarSize","_scrollbarPresenceChanged","overflowX","overflowY","childrenToDisplay","_childrenToDisplay","showNoContentRenderer","_setScrollingContainerRef","maxWidth","maxHeight","overflow","pointerEvents","cellRangeRenderer","overscanColumnCount","getOffsetAdjustment","overscanColumnIndices","overscanRowIndices","hasFixedHeight","hasFixedWidth","scrollingResetTimeInterval","requestAnimationTimeout","_debounceScrollEndedCallback","_this3","_onScrollMemoizer","_this3$props","clientWidth","scrollWidth","Boolean","onScrollbarPresenceChange","horizontal","vertical","_ref8","_getScrollLeftForScrollToColumnStateUpdate","_getScrollTopForScrollToRowStateUpdate","nextProps","maybeStateA","maybeStateB","cellSize","computeMetadataCallback","computeMetadataCallbackProps","nextCellsCount","nextCellSize","nextScrollToIndex","updateScrollOffsetForScrollToIndex","estimatedColumnSize","_ref9","finalColumn","scrollBarSize","calculatedScrollLeft","finalRow","calculatedScrollTop","polyfill","_default","CellSizeAndPositionManager","_cellSizeGetter","_cellCount","_estimatedCellSize","_lastMeasuredIndex","Error","lastMeasuredCellSizeAndPosition","isNaN","_cellSizeAndPositionData","_lastBatchedIndex","idealOffset","datum","maxOffset","minOffset","_findNearestCell","high","low","middle","floor","interval","_binarySearch","lastMeasuredIndex","_exponentialSearch","window","chrome","requireAllKeys","cachedIndices","allInitialized","every","isArray","indexChanged","some","cachedValue","join","hasScrollToIndex","sizeHasChanged","bpfrpt_proptype_AnimationTimeoutId","_animationFrame","frame","caf","delay","Promise","resolve","then","Date","now","raf","timeout","win","request","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","setTimeout","cancel","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","oCancelAnimationFrame","msCancelAnimationFrame","clearTimeout","_detectElementResize","AutoSizer","_React$Component","defaultHeight","defaultWidth","disableHeight","disableWidth","onResize","_parentNode","offsetHeight","offsetWidth","_window","getComputedStyle","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","newHeight","newWidth","autoSizer","_autoSizer","nonce","parentNode","ownerDocument","defaultView","HTMLElement","addResizeListener","_onResize","removeResizeListener","children","outerStyle","childParams","Component","hostWindow","global","attachEvent","document","requestFrame","fn","cancelFrame","resetTriggers","element","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","scrollListener","e","indexOf","__resizeRAF__","__resizeLast__","checkTriggers","__resizeListeners__","animation","keyframeprefix","animationstartevent","domPrefixes","split","startEvents","pfx","elm","animationName","toLowerCase","animationKeyframes","animationStyle","doc","elementStyle","getElementById","css","head","getElementsByTagName","type","setAttribute","styleSheet","cssText","appendChild","createTextNode","createStyles","resizeTriggersHtml","trustedTypes","staticPolicy","createPolicy","createHTML","innerHTML","addEventListener","__animationListener__","detachEvent","splice","removeEventListener","removeChild","recalc","canUseDOM","scrollDiv","body","toVal","mix","k","y","str","tmp","x","_List","_AutoSizer"],"mappings":"gGAKAA,EAAOC,QALP,SAAgCC,GAC9B,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CACnC,QAAWA,IAG0BF,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,kCCH9G,IAAIG,EAAyBC,EAAQ,MAEjCC,EAA0BD,EAAQ,MAEtCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAQS,iCAAmCT,EAAQU,0BAA4BV,EAAQW,sCAAwCX,EAAQY,gCAAkCZ,EAAQa,4CAA8Cb,EAAQc,gCAAkCd,EAAQe,wCAA0Cf,EAAQgB,uBAAyBhB,EAAQiB,kCAAoCjB,EAAQkB,yBAA2BlB,EAAQmB,+BAAiCnB,EAAQoB,kCAAoCpB,EAAQqB,wCAA0CrB,EAAQsB,2BAA6BtB,EAAQuB,0BAA4BvB,EAAQwB,6BAA+BxB,EAAQyB,mCAAqCzB,EAAQ0B,kCAA+B,EAE1uBrB,EAAwBD,EAAQ,IAEHD,EAAuBC,EAAQ,OAEvDD,EAAuBC,EAAQ,IAMhDJ,EAAQ0B,6BAJmE,KAc3E1B,EAAQyB,mCATyE,KAWjFzB,EAAQwB,6BADmE,KAG3ExB,EAAQuB,0BADgE,KAGxEvB,EAAQsB,2BADiE,KA2BzEtB,EAAQqB,wCAzB8E,KA2BtFrB,EAAQoB,kCADwE,KAGhFpB,EAAQmB,+BADqE,KAG7EnB,EAAQkB,yBAD+D,KAGvElB,EAAQiB,kCADwE,KAUhFjB,EAAQgB,uBAR6D,KAcrEhB,EAAQe,wCAL8E,KAgBtFf,EAAQc,gCAVsE,KAyB9Ed,EAAQa,4CAdkF,KAmB1Fb,EAAQY,gCAJsE,KAM9EZ,EAAQW,sCAD4E,KAGpFX,EAAQU,0BADgE,KAMxEV,EAAQS,iCAJuE,M,qBC1H/E,IAAIkB,EAAU,EAAQ,KAAwB,QAC9C,SAASC,EAAyBC,GAChC,GAAuB,oBAAZC,QAAwB,OAAO,KAC1C,IAAIC,EAAoB,IAAID,QACxBE,EAAmB,IAAIF,QAC3B,OAAQF,EAA2B,SAAkCC,GACnE,OAAOA,EAAcG,EAAmBD,IACvCF,GAiCL9B,EAAOC,QA/BP,SAAiCC,EAAK4B,GACpC,IAAKA,GAAe5B,GAAOA,EAAIC,WAC7B,OAAOD,EAET,GAAY,OAARA,GAAiC,WAAjB0B,EAAQ1B,IAAoC,oBAARA,EACtD,MAAO,CACL,QAAWA,GAGf,IAAIgC,EAAQL,EAAyBC,GACrC,GAAII,GAASA,EAAMC,IAAIjC,GACrB,OAAOgC,EAAME,IAAIlC,GAEnB,IAAImC,EAAS,GACTC,EAAwB/B,OAAOC,gBAAkBD,OAAOgC,yBAC5D,IAAK,IAAIC,KAAOtC,EACd,GAAY,YAARsC,GAAqBjC,OAAOkC,UAAUC,eAAeC,KAAKzC,EAAKsC,GAAM,CACvE,IAAII,EAAON,EAAwB/B,OAAOgC,yBAAyBrC,EAAKsC,GAAO,KAC3EI,IAASA,EAAKR,KAAOQ,EAAKC,KAC5BtC,OAAOC,eAAe6B,EAAQG,EAAKI,GAEnCP,EAAOG,GAAOtC,EAAIsC,GAQxB,OAJAH,EAAgB,QAAInC,EAChBgC,GACFA,EAAMW,IAAI3C,EAAKmC,GAEVA,GAEiCrC,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,mBClC/GD,EAAOC,QANP,SAAgC6C,GAC9B,QAAa,IAATA,EACF,MAAM,IAAIC,eAAe,6DAE3B,OAAOD,GAEgC9C,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,qBCN9G,IAAI2B,EAAU,EAAQ,KAAwB,QAC1CoB,EAAwB,EAAQ,MASpChD,EAAOC,QARP,SAAoC6C,EAAMH,GACxC,GAAIA,IAA2B,WAAlBf,EAAQe,IAAsC,oBAATA,GAChD,OAAOA,EACF,QAAa,IAATA,EACT,MAAM,IAAIM,UAAU,4DAEtB,OAAOD,EAAsBF,IAEc9C,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,mBCVlH,SAASiD,EAAgBC,GAIvB,OAHAnD,EAAOC,QAAUiD,EAAkB3C,OAAO6C,eAAiB7C,OAAO8C,eAAeC,OAAS,SAAyBH,GACjH,OAAOA,EAAEI,WAAahD,OAAO8C,eAAeF,IAC3CnD,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,QACjEiD,EAAgBC,GAEzBnD,EAAOC,QAAUiD,EAAiBlD,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,qBCNvG,IAAImD,EAAiB,EAAQ,MAiB7BpD,EAAOC,QAhBP,SAAmBuD,EAAUC,GAC3B,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIR,UAAU,sDAEtBO,EAASf,UAAYlC,OAAOmD,OAAOD,GAAcA,EAAWhB,UAAW,CACrEkB,YAAa,CACXlD,MAAO+C,EACPI,UAAU,EACVC,cAAc,KAGlBtD,OAAOC,eAAegD,EAAU,YAAa,CAC3CI,UAAU,IAERH,GAAYL,EAAeI,EAAUC,IAEfzD,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,kCCfjG,IAAIG,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,aAAc,EAErB,IAAI6D,EAA4B1D,EAAuBC,EAAQ,MAE3D0D,EAAmB3D,EAAuBC,EAAQ,MAElD2D,EAAgB5D,EAAuBC,EAAQ,MAE/C4D,EAAmB7D,EAAuBC,EAAQ,KAElD6D,EAA8B9D,EAAuBC,EAAQ,OAE7D8D,EAAkB9D,EAAQ,MAO1B+D,GALS/D,EAAQ,MAOrB,WACE,SAAS+D,EAAkCC,GACzC,IAAIC,EAAqBD,EAAKE,cAC1BA,OAAuC,IAAvBD,GAAgC,EAAIH,EAAgBK,qBAAuBF,EAC3FG,GAAS,EAAIX,EAAyB,SAAaO,EAAM,CAAC,mBAC9D,EAAIN,EAAgB,SAAaW,KAAMN,IACvC,EAAIH,EAAgB,SAAaS,KAAM,mCAA+B,IACtE,EAAIT,EAAgB,SAAaS,KAAM,sBAAkB,GAEzDA,KAAKC,4BAA8B,IAAIT,EAA2B,QAAYO,GAC9EC,KAAKE,eAAiBL,EAyKxB,OAtKA,EAAIP,EAAa,SAAaI,EAAmC,CAAC,CAChE5B,IAAK,qBACL/B,MAAO,WACL,OAAOiE,KAAKC,4BAA4BE,eAAiBH,KAAKE,iBAE/D,CACDpC,IAAK,YACL/B,MAAO,SAAmBgE,GACxBC,KAAKC,4BAA4BG,UAAUL,KAE5C,CACDjC,IAAK,eACL/B,MAAO,WACL,OAAOiE,KAAKC,4BAA4BI,iBAEzC,CACDvC,IAAK,uBACL/B,MAAO,WACL,OAAOiE,KAAKC,4BAA4BK,yBAEzC,CACDxC,IAAK,uBACL/B,MAAO,WACL,OAAOiE,KAAKC,4BAA4BM,yBAOzC,CACDzC,IAAK,sBACL/B,MAAO,SAA6ByE,GAClC,IAAIC,EAAgBD,EAAMC,cACtBC,EAASF,EAAME,OAEfC,EAAYX,KAAKC,4BAA4BE,eAE7CS,EAAgBZ,KAAKG,eAErBU,EAAmBb,KAAKc,qBAAqB,CAC/CL,cAAeA,EACfC,OAAQA,EACRC,UAAWC,IAGb,OAAOG,KAAKC,MAAMH,GAAoBD,EAAgBD,MAEvD,CACD7C,IAAK,2BACL/B,MAAO,SAAkCkF,GACvC,OAAOjB,KAAKC,4BAA4BiB,yBAAyBD,KAElE,CACDnD,IAAK,uCACL/B,MAAO,WACL,OAAOiE,KAAKC,4BAA4BkB,yCAIzC,CACDrD,IAAK,eACL/B,MAAO,WACL,OAAOgF,KAAKK,IAAIpB,KAAKE,eAAgBF,KAAKC,4BAA4BE,kBAIvE,CACDrC,IAAK,2BACL/B,MAAO,SAAkCsF,GACvC,IAAIC,EAAcD,EAAME,MACpBA,OAAwB,IAAhBD,EAAyB,OAASA,EAC1Cb,EAAgBY,EAAMZ,cACtBe,EAAgBH,EAAMG,cACtBC,EAAcJ,EAAMI,YACxBD,EAAgBxB,KAAK0B,oBAAoB,CACvCjB,cAAeA,EACfC,OAAQc,IAGV,IAAId,EAASV,KAAKC,4BAA4B0B,yBAAyB,CACrEJ,MAAOA,EACPd,cAAeA,EACfe,cAAeA,EACfC,YAAaA,IAGf,OAAOzB,KAAK4B,oBAAoB,CAC9BnB,cAAeA,EACfC,OAAQA,MAKX,CACD5C,IAAK,sBACL/B,MAAO,SAA6B8F,GAClC,IAAIpB,EAAgBoB,EAAMpB,cACtBC,EAASmB,EAAMnB,OAKnB,OAJAA,EAASV,KAAK0B,oBAAoB,CAChCjB,cAAeA,EACfC,OAAQA,IAEHV,KAAKC,4BAA4B6B,oBAAoB,CAC1DrB,cAAeA,EACfC,OAAQA,MAGX,CACD5C,IAAK,YACL/B,MAAO,SAAmBkF,GACxBjB,KAAKC,4BAA4B8B,UAAUd,KAE5C,CACDnD,IAAK,uBACL/B,MAAO,SAA8BiG,GACnC,IAAIvB,EAAgBuB,EAAMvB,cACtBC,EAASsB,EAAMtB,OACfC,EAAYqB,EAAMrB,UACtB,OAAOA,GAAaF,EAAgB,EAAIC,GAAUC,EAAYF,KAE/D,CACD3C,IAAK,sBACL/B,MAAO,SAA6BkG,GAClC,IAAIxB,EAAgBwB,EAAMxB,cACtBC,EAASuB,EAAMvB,OAEfC,EAAYX,KAAKC,4BAA4BE,eAE7CS,EAAgBZ,KAAKG,eAEzB,GAAIQ,IAAcC,EAChB,OAAOF,EAEP,IAAIG,EAAmBb,KAAKc,qBAAqB,CAC/CL,cAAeA,EACfC,OAAQA,EACRC,UAAWA,IAGb,OAAOI,KAAKC,MAAMH,GAAoBD,EAAgBH,MAGzD,CACD3C,IAAK,sBACL/B,MAAO,SAA6BmG,GAClC,IAAIzB,EAAgByB,EAAMzB,cACtBC,EAASwB,EAAMxB,OAEfC,EAAYX,KAAKC,4BAA4BE,eAE7CS,EAAgBZ,KAAKG,eAEzB,GAAIQ,IAAcC,EAChB,OAAOF,EAEP,IAAIG,EAAmBb,KAAKc,qBAAqB,CAC/CL,cAAeA,EACfC,OAAQA,EACRC,UAAWC,IAGb,OAAOG,KAAKC,MAAMH,GAAoBF,EAAYF,QAIjDf,EAnLT,IAsLAnE,EAAO,QAAcmE,G,mBClNrB,SAASyC,IAYP,OAXA7G,EAAOC,QAAU4G,EAAWtG,OAAOuG,OAASvG,OAAOuG,OAAOxD,OAAS,SAAUyD,GAC3E,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CACzC,IAAIG,EAASF,UAAUD,GACvB,IAAK,IAAIxE,KAAO2E,EACV5G,OAAOkC,UAAUC,eAAeC,KAAKwE,EAAQ3E,KAC/CuE,EAAOvE,GAAO2E,EAAO3E,IAI3B,OAAOuE,GACN/G,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,QACjE4G,EAASO,MAAM1C,KAAMuC,WAE9BjH,EAAOC,QAAU4G,EAAU7G,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,kCCZhGM,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAmBP,SAAsCoE,GACpC,IAAIgD,EAAYhD,EAAKgD,UACjBC,EAAqBjD,EAAKiD,mBAC1BC,EAAkBlD,EAAKkD,gBACvBC,EAAanD,EAAKmD,WAClBC,EAAYpD,EAAKoD,UAErB,OAnB6B,IAmBzBF,EACK,CACLG,mBAAoBjC,KAAKkC,IAAI,EAAGH,GAChCI,kBAAmBnC,KAAKK,IAAIuB,EAAY,EAAGI,EAAYH,IAGlD,CACLI,mBAAoBjC,KAAKkC,IAAI,EAAGH,EAAaF,GAC7CM,kBAAmBnC,KAAKK,IAAIuB,EAAY,EAAGI,KAjCjDxH,EAAQ4H,0BAA4B5H,EAAQ6H,4BAA8B7H,EAAQ8H,yBAA2B9H,EAAQ+H,+BAA4B,EAEpI3H,EAAQ,MAGrBJ,EAAQ+H,2BADyB,EAGjC/H,EAAQ8H,yBADuB,EAG/B9H,EAAQ6H,4BAD0B,aAQlC7H,EAAQ4H,0BANwB,Y,kCCdhCtH,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAQP,SAAkCoE,GA2BhC,IA1BA,IAAI4D,EAAY5D,EAAK4D,UACjBC,EAAe7D,EAAK6D,aACpBC,EAA+B9D,EAAK8D,6BACpCC,EAAmB/D,EAAK+D,iBACxBC,EAAkBhE,EAAKgE,gBACvBC,EAA2BjE,EAAKiE,yBAChCC,EAA6BlE,EAAKkE,2BAClCC,EAAcnE,EAAKmE,YACnBC,EAAoBpE,EAAKoE,kBACzBC,EAASrE,EAAKqE,OACdC,EAA4BtE,EAAKsE,0BACjCC,EAAgBvE,EAAKuE,cACrBC,EAAexE,EAAKwE,aACpBC,EAAazE,EAAKyE,WAClBC,EAA2B1E,EAAK0E,yBAChCC,EAAuB3E,EAAK2E,qBAC5BC,EAAoB5E,EAAK4E,kBACzBC,EAAgB,GAMhBC,EAAqBhB,EAA6BgB,sBAAwBR,EAA0BQ,qBACpGC,GAAiBZ,IAAgBW,EAE5BE,EAAWT,EAAeS,GAAYR,EAAcQ,IAG3D,IAFA,IAAIC,EAAWX,EAA0B/C,yBAAyByD,GAEzDE,EAAcnB,EAAkBmB,GAAelB,EAAiBkB,IAAe,CACtF,IAAIC,EAAcrB,EAA6BvC,yBAAyB2D,GACpEE,EAAYF,GAAeP,EAAqBU,OAASH,GAAeP,EAAqBW,MAAQN,GAAYJ,EAAkBS,OAASL,GAAYJ,EAAkBU,KAC1KnH,EAAM,GAAGoH,OAAOP,EAAU,KAAKO,OAAOL,GACtCM,OAAQ,EAERT,GAAiBN,EAAWtG,GAC9BqH,EAAQf,EAAWtG,GAIf8F,IAA6BA,EAAyBnG,IAAIkH,EAAUE,GAItEM,EAAQ,CACNC,OAAQ,OACRC,KAAM,EACNC,SAAU,WACVC,IAAK,EACLC,MAAO,SAGTL,EAAQ,CACNC,OAAQR,EAASa,KACjBJ,KAAMP,EAAYpE,OAASmD,EAC3ByB,SAAU,WACVC,IAAKX,EAASlE,OAAS2D,EACvBmB,MAAOV,EAAYW,MAErBrB,EAAWtG,GAAOqH,GAItB,IAAIO,EAAqB,CACvBb,YAAaA,EACbf,YAAaA,EACbiB,UAAWA,EACXjH,IAAKA,EACLkG,OAAQA,EACRW,SAAUA,EACVQ,MAAOA,GAELQ,OAAe,GAWd5B,IAAqBD,GAAiBD,GAA+BQ,EAQxEsB,EAAenC,EAAakC,IAPvBnC,EAAUzF,KACbyF,EAAUzF,GAAO0F,EAAakC,IAGhCC,EAAepC,EAAUzF,IAMP,MAAhB6H,IAAyC,IAAjBA,GAQ5BnB,EAAcoB,KAAKD,GAIvB,OAAOnB,GAjHI7I,EAAQ,O,kCCLrB,IAAID,EAAyBC,EAAQ,MAEjCC,EAA0BD,EAAQ,MAEtCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAQgB,uBAAyBhB,EAAQsK,6BAA+BtK,EAAQuK,4BAA8BvK,EAAQwK,uCAAoC,EAE9InK,EAAwBD,EAAQ,IAE3BD,EAAuBC,EAAQ,IAUhDJ,EAAQwK,kCARwE,KAUhFxK,EAAQuK,4BADkE,KAQ1EvK,EAAQsK,6BANmE,KAY3EtK,EAAQgB,uBAL6D,M,kCC/BrE,IAAIb,EAAyBC,EAAQ,MAEjCC,EAA0BD,EAAQ,MAEtCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,aAAc,EAErB,IA0BIyK,EAAQC,EA1BRC,EAAYxK,EAAuBC,EAAQ,OAE3C0D,EAAmB3D,EAAuBC,EAAQ,MAElD2D,EAAgB5D,EAAuBC,EAAQ,MAE/CwK,EAA8BzK,EAAuBC,EAAQ,OAE7DyK,EAAmB1K,EAAuBC,EAAQ,OAElD0K,EAA0B3K,EAAuBC,EAAQ,OAEzD2K,EAAa5K,EAAuBC,EAAQ,OAE5C4D,EAAmB7D,EAAuBC,EAAQ,KAElD4K,EAAQ3K,EAAwBD,EAAQ,OAExC6K,EAAQ5K,EAAwBD,EAAQ,IAExC8K,EAAQ/K,EAAuBC,EAAQ,MAQvC+K,GANS/K,EAAQ,MAEJD,EAAuBC,EAAQ,IAIpCsK,EAAQD,EAEpB,SAAUW,GAGR,SAASD,IACP,IAAIE,EAEAC,GAEJ,EAAIxH,EAAgB,SAAaW,KAAM0G,GAEvC,IAAK,IAAII,EAAOvE,UAAUC,OAAQuE,EAAO,IAAIC,MAAMF,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC/EF,EAAKE,GAAQ1E,UAAU0E,GA8DzB,OA3DAJ,GAAQ,EAAIV,EAA2B,SAAanG,MAAO4G,GAAmB,EAAIR,EAAgB,SAAaM,IAAOzI,KAAKyE,MAAMkE,EAAkB,CAAC5G,MAAMkF,OAAO6B,MACjK,EAAIxH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,YAAQ,IACzF,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,iBAAiB,SAAUlH,GAC1G,IAAIqE,EAASrE,EAAKqE,OACdW,EAAWhF,EAAKgF,SAChBQ,EAAQxF,EAAKwF,MACbrB,EAAcnE,EAAKmE,YACnBiB,EAAYpF,EAAKoF,UACjBjH,EAAM6B,EAAK7B,IACXoJ,EAAcL,EAAMM,MAAMD,YAM1BE,EAAkBvL,OAAOgC,yBAAyBsH,EAAO,SAQ7D,OANIiC,GAAmBA,EAAgBlI,WAGrCiG,EAAMK,MAAQ,QAGT0B,EAAY,CACjBjG,MAAO0D,EACPQ,MAAOA,EACPrB,YAAaA,EACbiB,UAAWA,EACXjH,IAAKA,EACLkG,OAAQA,QAGZ,EAAIzE,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,WAAW,SAAUQ,GACpGR,EAAMS,KAAOD,MAEf,EAAI9H,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,aAAa,SAAUrG,GACtG,IAAI+G,EAAe/G,EAAM+G,aACrBC,EAAehH,EAAMgH,aACrBC,EAAYjH,EAAMiH,WAEtBC,EADeb,EAAMM,MAAMO,UAClB,CACPH,aAAcA,EACdC,aAAcA,EACdC,UAAWA,QAGf,EAAIlI,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,sBAAsB,SAAUxF,GAC/G,IAAIsG,EAAwBtG,EAAMsG,sBAC9BC,EAAuBvG,EAAMuG,qBAC7B1D,EAAgB7C,EAAM6C,cACtBC,EAAe9C,EAAM8C,cAEzB0D,EADqBhB,EAAMM,MAAMU,gBAClB,CACb7E,mBAAoB2E,EACpBzE,kBAAmB0E,EACnB9E,WAAYoB,EACZnB,UAAWoB,OAGR0C,EAyIT,OAjNA,EAAIP,EAAU,SAAaI,EAAMC,IA2EjC,EAAIrH,EAAa,SAAaoH,EAAM,CAAC,CACnC5I,IAAK,kBACL/B,MAAO,WACDiE,KAAKsH,MACPtH,KAAKsH,KAAKQ,gBAKb,CACDhK,IAAK,kBACL/B,MAAO,SAAyB8F,GAC9B,IAAIkG,EAAYlG,EAAMkG,UAClB9G,EAAQY,EAAMZ,MAElB,OAAIjB,KAAKsH,KACqBtH,KAAKsH,KAAKU,iBAAiB,CACrDD,UAAWA,EACXpD,SAAU1D,EACV4D,YAAa,IAEuB4C,UAKjC,IAIR,CACD3J,IAAK,gCACL/B,MAAO,SAAuCiG,GAC5C,IAAI6C,EAAc7C,EAAM6C,YACpBF,EAAW3C,EAAM2C,SAEjB3E,KAAKsH,MACPtH,KAAKsH,KAAKW,8BAA8B,CACtCtD,SAAUA,EACVE,YAAaA,MAMlB,CACD/G,IAAK,iBACL/B,MAAO,WACDiE,KAAKsH,MACPtH,KAAKsH,KAAKY,oBAKb,CACDpK,IAAK,oBACL/B,MAAO,WACL,IAAIkG,EAAQM,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,GAC5E6F,EAAoBnG,EAAM4C,YAC1BA,OAAoC,IAAtBuD,EAA+B,EAAIA,EACjDC,EAAiBpG,EAAM0C,SACvBA,OAA8B,IAAnB0D,EAA4B,EAAIA,EAE3CrI,KAAKsH,MACPtH,KAAKsH,KAAKgB,kBAAkB,CAC1B3D,SAAUA,EACVE,YAAaA,MAMlB,CACD/G,IAAK,sBACL/B,MAAO,WACL,IAAIkF,EAAQsB,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,EAE5EvC,KAAKsH,MACPtH,KAAKsH,KAAKgB,kBAAkB,CAC1B3D,SAAU1D,EACV4D,YAAa,MAMlB,CACD/G,IAAK,mBACL/B,MAAO,WACL,IAAI0L,EAAYlF,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,EAEhFvC,KAAKsH,MACPtH,KAAKsH,KAAKiB,iBAAiB,CACzBd,UAAWA,MAMhB,CACD3J,IAAK,cACL/B,MAAO,WACL,IAAIkF,EAAQsB,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,EAE5EvC,KAAKsH,MACPtH,KAAKsH,KAAKkB,aAAa,CACrB3D,YAAa,EACbF,SAAU1D,MAIf,CACDnD,IAAK,SACL/B,MAAO,WACL,IAAI0M,EAAczI,KAAKmH,MACnBuB,EAAYD,EAAYC,UACxBC,EAAiBF,EAAYE,eAC7BC,EAAgBH,EAAYG,cAC5BpD,EAAQiD,EAAYjD,MACpBqD,GAAa,EAAIpC,EAAK,SAAa,yBAA0BiC,GACjE,OAAOlC,EAAMsC,cAAcvC,EAAK,SAAa,EAAIL,EAAS,SAAa,GAAIlG,KAAKmH,MAAO,CACrF4B,oBAAoB,EACpBvF,aAAcxD,KAAKgJ,cACnBN,UAAWG,EACXI,YAAazD,EACb0D,YAAa,EACbC,kBAAmBR,EACnBjB,SAAU1H,KAAKoJ,UACfC,kBAAmBrJ,KAAKsJ,mBACxBjC,IAAKrH,KAAKuJ,QACVC,YAAaZ,SAIZlC,EAlNT,CAmNEF,EAAMiD,gBAAgB,EAAIlK,EAAgB,SAAayG,EAAQ,YAAqD,MA8ElHC,GACJ1K,EAAO,QAAcmL,GACrB,EAAInH,EAAgB,SAAamH,EAAM,eAAgB,CACrDgD,YAAY,EACZC,iBAAkB,GAClBjC,SAAU,aACViB,eAAgB,WACd,OAAO,MAETd,eAAgB,aAChB+B,sBAAuBrD,EAAMsD,mCAC7BC,iBAAkB,GAClBC,kBAAmB,OACnBnB,eAAgB,EAChBzD,MAAO,M,mBCxVT,SAAS6E,EAAgBvL,EAAGwL,GAK1B,OAJA3O,EAAOC,QAAUyO,EAAkBnO,OAAO6C,eAAiB7C,OAAO6C,eAAeE,OAAS,SAAyBH,EAAGwL,GAEpH,OADAxL,EAAEI,UAAYoL,EACPxL,GACNnD,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,QACjEyO,EAAgBvL,EAAGwL,GAE5B3O,EAAOC,QAAUyO,EAAiB1O,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S,kCCLvG,IAAIG,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETF,OAAOC,eAAeP,EAAS,UAAW,CACxC2O,YAAY,EACZxM,IAAK,WACH,OAAO6I,EAAK,WAGhB1K,OAAOC,eAAeP,EAAS,OAAQ,CACrC2O,YAAY,EACZxM,IAAK,WACH,OAAO6I,EAAK,WAGhB1K,OAAOC,eAAeP,EAAS,qCAAsC,CACnE2O,YAAY,EACZxM,IAAK,WACH,OAAOyM,EAAmC,WAG9CtO,OAAOC,eAAeP,EAAS,2BAA4B,CACzD2O,YAAY,EACZxM,IAAK,WACH,OAAO0M,EAAyB,WAGpCvO,OAAOC,eAAeP,EAAS,+BAAgC,CAC7D2O,YAAY,EACZxM,IAAK,WACH,OAAO2M,EAA6B,WAGxCxO,OAAOC,eAAeP,EAAS,oCAAqC,CAClE2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAO9N,qCAGlBX,OAAOC,eAAeP,EAAS,4BAA6B,CAC1D2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOrO,6BAGlBJ,OAAOC,eAAeP,EAAS,+BAAgC,CAC7D2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOrN,gCAGlBpB,OAAOC,eAAeP,EAAS,2BAA4B,CACzD2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAO7N,4BAGlBZ,OAAOC,eAAeP,EAAS,wCAAyC,CACtE2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOpO,yCAGlBL,OAAOC,eAAeP,EAAS,kCAAmC,CAChE2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOjO,mCAGlBR,OAAOC,eAAeP,EAAS,qCAAsC,CACnE2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOtN,sCAGlBnB,OAAOC,eAAeP,EAAS,yBAA0B,CACvD2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAO/N,0BAIlB,IAAIgK,EAAQ7K,EAAuBC,EAAQ,OAEvCwO,EAAsCzO,EAAuBC,EAAQ,OAErEyO,EAA4B1O,EAAuBC,EAAQ,OAE3D0O,EAAgC3O,EAAuBC,EAAQ,OAE/D2O,EAAS3O,EAAQ,O,kCC5FrB,IAAID,EAAyBC,EAAQ,MAEjCC,EAA0BD,EAAQ,MAEtCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAAcA,EAAQgP,2CAAwC,EAErE,IA0CIvE,EAAQC,EA1CRC,EAAYxK,EAAuBC,EAAQ,OAE3C0D,EAAmB3D,EAAuBC,EAAQ,MAElD2D,EAAgB5D,EAAuBC,EAAQ,MAE/CwK,EAA8BzK,EAAuBC,EAAQ,OAE7DiL,EAAmBlL,EAAuBC,EAAQ,OAElD0K,EAA0B3K,EAAuBC,EAAQ,OAEzD2K,EAAa5K,EAAuBC,EAAQ,OAE5C4D,EAAmB7D,EAAuBC,EAAQ,KAElD6K,EAAQ5K,EAAwBD,EAAQ,IAExC8K,EAAQ/K,EAAuBC,EAAQ,MAEvC6O,EAAqD9O,EAAuBC,EAAQ,OAEpF8O,EAAqC/O,EAAuBC,EAAQ,OAEpE+O,EAA0BhP,EAAuBC,EAAQ,OAEzD0O,EAAgCzO,EAAwBD,EAAQ,OAEhEgP,EAA2BjP,EAAuBC,EAAQ,OAE1DyO,EAA4B1O,EAAuBC,EAAQ,OAE3DiP,EAAiBlP,EAAuBC,EAAQ,OAEhDkP,EAAyBlP,EAAQ,KAEjCmP,EAA2BnP,EAAQ,MAE1BA,EAAQ,MAEJD,EAAuBC,EAAQ,IAIhD,SAASoP,EAAQC,EAAQC,GAAkB,IAAIC,EAAOrP,OAAOqP,KAAKF,GAAS,GAAInP,OAAOsP,sBAAuB,CAAE,IAAIC,EAAUvP,OAAOsP,sBAAsBH,GAAaC,IAAgBG,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOzP,OAAOgC,yBAAyBmN,EAAQM,GAAKpB,eAAgBgB,EAAKtF,KAAKlD,MAAMwI,EAAME,GAAY,OAAOF,EAE9U,SAASK,EAAclJ,GAAU,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CAAE,IAAIG,EAAyB,MAAhBF,UAAUD,GAAaC,UAAUD,GAAK,GAAQA,EAAI,EAAKyI,EAAQtI,GAAQ,GAAM+I,SAAQ,SAAU1N,IAAO,EAAIyB,EAAgB,SAAa8C,EAAQvE,EAAK2E,EAAO3E,OAAsBjC,OAAO4P,0BAA6B5P,OAAO6P,iBAAiBrJ,EAAQxG,OAAO4P,0BAA0BhJ,IAAmBsI,EAAQtI,GAAQ+I,SAAQ,SAAU1N,GAAOjC,OAAOC,eAAeuG,EAAQvE,EAAKjC,OAAOgC,yBAAyB4E,EAAQ3E,OAAe,OAAOuE,EAY9gB9G,EAAQgP,sCANoC,IAO5C,IAAIoB,EACQ,WADRA,EAES,YAWTrE,GAAQrB,EAAQD,EAEpB,SAAUW,GAIR,SAASW,EAAKH,GACZ,IAAIN,GAEJ,EAAIxH,EAAgB,SAAaW,KAAMsH,GACvCT,GAAQ,EAAIV,EAA2B,SAAanG,MAAM,EAAI4G,EAAgB,SAAaU,GAAMrJ,KAAK+B,KAAMmH,KAC5G,EAAI5H,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,2BAA2B,EAAI6D,EAAuB,aACvI,EAAInL,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,qBAAqB,EAAI6D,EAAuB,UAAa,KAC9I,EAAInL,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,iCAAkC,OACnH,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,8BAA+B,OAChH,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,4BAA4B,IAC7G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,2BAA2B,IAC5G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,2BAA4B,IAC7G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,yBAA0B,IAC3G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,6BAA6B,IAC9G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,2BAAuB,IACxG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,0BAAsB,IACvG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,yBAAqB,IACtG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,wBAAoB,IACrG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,sBAAkB,IACnG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,qBAAiB,IAClG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,4BAA6B,IAC9G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,2BAA4B,IAC7G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,yBAA0B,IAC3G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,wBAAyB,IAC1G,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,yBAAqB,IACtG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,0BAAsB,IACvG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,sCAAkC,IACnH,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,cAAe,KAChG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,aAAc,KAC/F,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,gCAAgC,WAC/GA,EAAM+E,+BAAiC,KAEvC/E,EAAMgF,SAAS,CACb/H,aAAa,EACbgI,uBAAuB,QAG3B,EAAIvM,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,+BAA+B,WAC9G,IAAIwC,EAAoBxC,EAAMM,MAAMkC,kBAEpCxC,EAAMkF,wBAAwB,CAC5BC,SAAU3C,EACV4C,QAAS,CACPC,yBAA0BrF,EAAMsF,kBAChCC,wBAAyBvF,EAAMwF,iBAC/B3I,iBAAkBmD,EAAMyF,0BACxB3I,gBAAiBkD,EAAM0F,yBACvB5E,sBAAuBd,EAAM2F,eAC7B5E,qBAAsBf,EAAM4F,cAC5BvI,cAAe2C,EAAM6F,uBACrBvI,aAAc0C,EAAM8F,6BAI1B,EAAIpN,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,6BAA6B,SAAUQ,GACtHR,EAAM+F,oBAAsBvF,MAE9B,EAAI9H,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,aAAa,SAAUgG,GAIlGA,EAAMxK,SAAWwE,EAAM+F,qBACzB/F,EAAMiG,kBAAkBD,EAAMxK,WAGlC,IAAIoB,EAA+B,IAAIgH,EAAkC,QAAY,CACnF9H,UAAWwE,EAAM+B,YACjB6D,eAAgB,SAAwBhN,GACtC,OAAOuH,EAAK0F,gBAAgB7F,EAAM8B,YAA3B3B,CAAwCvH,IAEjDkN,kBAAmB3F,EAAK4F,wBAAwB/F,KAE9ClD,EAA4B,IAAIwG,EAAkC,QAAY,CAChF9H,UAAWwE,EAAMgG,SACjBJ,eAAgB,SAAwBhN,GACtC,OAAOuH,EAAK0F,gBAAgB7F,EAAMiG,UAA3B9F,CAAsCvH,IAE/CkN,kBAAmB3F,EAAK+F,qBAAqBlG,KAiC/C,OA/BAN,EAAMyG,MAAQ,CACZC,cAAe,CACb9J,6BAA8BA,EAC9BQ,0BAA2BA,EAC3BuJ,gBAAiBrG,EAAM8B,YACvBwE,cAAetG,EAAMiG,UACrBM,gBAAiBvG,EAAM+B,YACvByE,aAAcxG,EAAMgG,SACpBS,iBAAuC,IAAtBzG,EAAMrD,YACvB+J,mBAAoB1G,EAAM2G,eAC1BC,gBAAiB5G,EAAMqC,YACvBwE,cAAe,EACfC,uBAAuB,GAEzBnK,aAAa,EACboK,0BAA2B7D,EAA8BhH,yBACzD8K,wBAAyB9D,EAA8BhH,yBACvD+K,WAAY,EACZ3G,UAAW,EACX4G,2BAA4B,KAC5BvC,uBAAuB,GAGrB3E,EAAMqC,YAAc,IACtB3C,EAAMyH,kBAAoBzH,EAAM0H,wBAAwBpH,EAAON,EAAMyG,QAGnEnG,EAAM2G,eAAiB,IACzBjH,EAAM2H,mBAAqB3H,EAAM4H,yBAAyBtH,EAAON,EAAMyG,QAGlEzG,EA2iCT,OA5pCA,EAAIP,EAAU,SAAagB,EAAMX,IAwHjC,EAAIrH,EAAa,SAAagI,EAAM,CAAC,CACnCxJ,IAAK,mBACL/B,MAAO,WACL,IAAI4D,EAAO4C,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,GAC3EmM,EAAiB/O,EAAKoI,UACtBA,OAA+B,IAAnB2G,EAA4B1O,KAAKmH,MAAM4C,kBAAoB2E,EACvEC,EAAmBhP,EAAKkF,YACxBA,OAAmC,IAArB8J,EAA8B3O,KAAKmH,MAAM2G,eAAiBa,EACxEC,EAAgBjP,EAAKgF,SACrBA,OAA6B,IAAlBiK,EAA2B5O,KAAKmH,MAAMqC,YAAcoF,EAE/DC,EAActD,EAAc,GAAIvL,KAAKmH,MAAO,CAC9C4C,kBAAmBhC,EACnB+F,eAAgBjJ,EAChB2E,YAAa7E,IAGf,MAAO,CACLyJ,WAAYpO,KAAKyO,yBAAyBI,GAC1CpH,UAAWzH,KAAKuO,wBAAwBM,MAO3C,CACD/Q,IAAK,qBACL/B,MAAO,WACL,OAAOiE,KAAKsN,MAAMC,cAActJ,0BAA0B9D,iBAM3D,CACDrC,IAAK,uBACL/B,MAAO,WACL,OAAOiE,KAAKsN,MAAMC,cAAc9J,6BAA6BtD,iBAO9D,CACDrC,IAAK,oBACL/B,MAAO,SAA2ByE,GAChC,IAAIsO,EAAmBtO,EAAM4N,WACzBW,OAAuC,IAArBD,EAA8B,EAAIA,EACpDE,EAAkBxO,EAAMiH,UACxBwH,OAAqC,IAApBD,EAA6B,EAAIA,EAItD,KAAIC,EAAiB,GAArB,CAKAjP,KAAKkP,uBAEL,IAAIzG,EAAczI,KAAKmH,MACnBuC,EAAajB,EAAYiB,WACzByF,EAAY1G,EAAY0G,UACxB/J,EAASqD,EAAYrD,OACrBI,EAAQiD,EAAYjD,MACpB+H,EAAgBvN,KAAKsN,MAAMC,cAK3BS,EAAgBT,EAAcS,cAC9BoB,EAAkB7B,EAActJ,0BAA0B9D,eAC1DkP,EAAoB9B,EAAc9J,6BAA6BtD,eAC/DiO,EAAarN,KAAKK,IAAIL,KAAKkC,IAAI,EAAGoM,EAAoB7J,EAAQwI,GAAgBe,GAC9EtH,EAAY1G,KAAKK,IAAIL,KAAKkC,IAAI,EAAGmM,EAAkBhK,EAAS4I,GAAgBiB,GAKhF,GAAIjP,KAAKsN,MAAMc,aAAeA,GAAcpO,KAAKsN,MAAM7F,YAAcA,EAAW,CAG9E,IAEI6H,EAAW,CACbxL,aAAa,EACboK,0BAJ8BE,IAAepO,KAAKsN,MAAMc,WAAaA,EAAapO,KAAKsN,MAAMc,WAAa/D,EAA8BhH,yBAA2BgH,EAA8B/G,0BAA4BtD,KAAKsN,MAAMY,0BAKxOC,wBAJ4B1G,IAAczH,KAAKsN,MAAM7F,UAAYA,EAAYzH,KAAKsN,MAAM7F,UAAY4C,EAA8BhH,yBAA2BgH,EAA8B/G,0BAA4BtD,KAAKsN,MAAMa,wBAKlOE,2BAA4B1C,GAGzBjC,IACH4F,EAAS7H,UAAYA,GAGlB0H,IACHG,EAASlB,WAAaA,GAGxBkB,EAASxD,uBAAwB,EACjC9L,KAAK6L,SAASyD,GAGhBtP,KAAKuP,wBAAwB,CAC3BnB,WAAYA,EACZ3G,UAAWA,EACX4H,kBAAmBA,EACnBD,gBAAiBA,OAWpB,CACDtR,IAAK,gCACL/B,MAAO,SAAuCsF,GAC5C,IAAIwD,EAAcxD,EAAMwD,YACpBF,EAAWtD,EAAMsD,SACrB3E,KAAKwP,+BAAgF,kBAAxCxP,KAAKwP,+BAA8CzO,KAAKK,IAAIpB,KAAKwP,+BAAgC3K,GAAeA,EAC7J7E,KAAKyP,4BAA0E,kBAArCzP,KAAKyP,4BAA2C1O,KAAKK,IAAIpB,KAAKyP,4BAA6B9K,GAAYA,IAQlJ,CACD7G,IAAK,kBACL/B,MAAO,WACL,IAAI2T,EAAe1P,KAAKmH,MACpB+B,EAAcwG,EAAaxG,YAC3BiE,EAAWuC,EAAavC,SACxBI,EAAgBvN,KAAKsN,MAAMC,cAC/BA,EAAc9J,6BAA6BvC,yBAAyBgI,EAAc,GAClFqE,EAActJ,0BAA0B/C,yBAAyBiM,EAAW,KAQ7E,CACDrP,IAAK,oBACL/B,MAAO,WACL,IAAI8F,EAAQU,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAK,GAC5EoN,EAAoB9N,EAAMgD,YAC1BA,OAAoC,IAAtB8K,EAA+B,EAAIA,EACjDC,EAAiB/N,EAAM8C,SACvBA,OAA8B,IAAnBiL,EAA4B,EAAIA,EAE3CC,EAAe7P,KAAKmH,MACpB2G,EAAiB+B,EAAa/B,eAC9BtE,EAAcqG,EAAarG,YAC3B+D,EAAgBvN,KAAKsN,MAAMC,cAC/BA,EAAc9J,6BAA6B1B,UAAU8C,GACrD0I,EAActJ,0BAA0BlC,UAAU4C,GAIlD3E,KAAK8P,yBAA2BhC,GAAkB,IAAM9N,KAAKsN,MAAMY,4BAA8B7D,EAA8BhH,yBAA2BwB,GAAeiJ,EAAiBjJ,GAAeiJ,GACzM9N,KAAK+P,wBAA0BvG,GAAe,IAAMxJ,KAAKsN,MAAMa,0BAA4B9D,EAA8BhH,yBAA2BsB,GAAY6E,EAAc7E,GAAY6E,GAG1LxJ,KAAKgQ,YAAc,GACnBhQ,KAAKiQ,WAAa,GAClBjQ,KAAK8H,gBAMN,CACDhK,IAAK,eACL/B,MAAO,SAAsBiG,GAC3B,IAAI6C,EAAc7C,EAAM6C,YACpBF,EAAW3C,EAAM2C,SACjBuE,EAAclJ,KAAKmH,MAAM+B,YACzB/B,EAAQnH,KAAKmH,MAGb+B,EAAc,QAAqBf,IAAhBtD,GACrB7E,KAAKkQ,mCAAmC3E,EAAc,GAAIpE,EAAO,CAC/D2G,eAAgBjJ,UAIHsD,IAAbxD,GACF3E,KAAKmQ,+BAA+B5E,EAAc,GAAIpE,EAAO,CAC3DqC,YAAa7E,OAIlB,CACD7G,IAAK,oBACL/B,MAAO,WACL,IAAIqU,EAAepQ,KAAKmH,MACpBkJ,EAAmBD,EAAaC,iBAChCjL,EAASgL,EAAahL,OACtBgJ,EAAagC,EAAahC,WAC1BN,EAAiBsC,EAAatC,eAC9BrG,EAAY2I,EAAa3I,UACzB+B,EAAc4G,EAAa5G,YAC3BhE,EAAQ4K,EAAa5K,MACrB+H,EAAgBvN,KAAKsN,MAAMC,cAsB/B,GApBAvN,KAAKsO,kBAAoB,EACzBtO,KAAKwO,mBAAqB,EAG1BxO,KAAKsQ,6BAIA/C,EAAcU,uBACjBjO,KAAK6L,UAAS,SAAU0E,GACtB,IAAIC,EAAcjF,EAAc,GAAIgF,EAAW,CAC7CzE,uBAAuB,IAKzB,OAFA0E,EAAYjD,cAAcS,cAAgBqC,IAC1CG,EAAYjD,cAAcU,uBAAwB,EAC3CuC,KAIe,kBAAfpC,GAA2BA,GAAc,GAA0B,kBAAd3G,GAA0BA,GAAa,EAAG,CACxG,IAAI+I,EAAclJ,EAAKmJ,gCAAgC,CACrDF,UAAWvQ,KAAKsN,MAChBc,WAAYA,EACZ3G,UAAWA,IAGT+I,IACFA,EAAY1E,uBAAwB,EACpC9L,KAAK6L,SAAS2E,IAKdxQ,KAAK4M,sBAGH5M,KAAK4M,oBAAoBwB,aAAepO,KAAKsN,MAAMc,aACrDpO,KAAK4M,oBAAoBwB,WAAapO,KAAKsN,MAAMc,YAG/CpO,KAAK4M,oBAAoBnF,YAAczH,KAAKsN,MAAM7F,YACpDzH,KAAK4M,oBAAoBnF,UAAYzH,KAAKsN,MAAM7F,YAMpD,IAAIiJ,EAAuBtL,EAAS,GAAKI,EAAQ,EAE7CsI,GAAkB,GAAK4C,GACzB1Q,KAAKkQ,qCAGH1G,GAAe,GAAKkH,GACtB1Q,KAAKmQ,iCAIPnQ,KAAK2Q,8BAGL3Q,KAAKuP,wBAAwB,CAC3BnB,WAAYA,GAAc,EAC1B3G,UAAWA,GAAa,EACxB4H,kBAAmB9B,EAAc9J,6BAA6BtD,eAC9DiP,gBAAiB7B,EAActJ,0BAA0B9D,iBAG3DH,KAAK4Q,wCAQN,CACD9S,IAAK,qBACL/B,MAAO,SAA4B8U,EAAWN,GAC5C,IAAIO,EAAS9Q,KAET+Q,EAAe/Q,KAAKmH,MACpBuC,EAAaqH,EAAarH,WAC1ByF,EAAY4B,EAAa5B,UACzBjG,EAAc6H,EAAa7H,YAC3B9D,EAAS2L,EAAa3L,OACtB+H,EAAW4D,EAAa5D,SACxBpD,EAAoBgH,EAAahH,kBACjC+D,EAAiBiD,EAAajD,eAC9BtE,EAAcuH,EAAavH,YAC3BhE,EAAQuL,EAAavL,MACrBwL,EAAchR,KAAKsN,MACnBc,EAAa4C,EAAY5C,WACzBC,EAA6B2C,EAAY3C,2BACzC5G,EAAYuJ,EAAYvJ,UACxB8F,EAAgByD,EAAYzD,cAGhCvN,KAAKsQ,6BAKL,IAAIW,EAAwC/H,EAAc,GAA+B,IAA1B2H,EAAU3H,aAAqBiE,EAAW,GAA4B,IAAvB0D,EAAU1D,SAMpHkB,IAA+B1C,KAG5BwD,GAAaf,GAAc,IAAMA,IAAepO,KAAK4M,oBAAoBwB,YAAc6C,KAC1FjR,KAAK4M,oBAAoBwB,WAAaA,IAGnC1E,GAAcjC,GAAa,IAAMA,IAAczH,KAAK4M,oBAAoBnF,WAAawJ,KACxFjR,KAAK4M,oBAAoBnF,UAAYA,IAOzC,IAAIyJ,GAAiD,IAApBL,EAAUrL,OAAoC,IAArBqL,EAAUzL,SAAiBA,EAAS,GAAKI,EAAQ,EAqD3G,GAlDIxF,KAAK8P,0BACP9P,KAAK8P,0BAA2B,EAEhC9P,KAAKkQ,mCAAmClQ,KAAKmH,SAE7C,EAAIwD,EAAwB,SAAa,CACvCwG,2BAA4B5D,EAAc9J,6BAC1C2N,mBAAoBP,EAAU3H,YAC9BmI,iBAAkBR,EAAU5H,YAC5BqI,0BAA2BT,EAAU9G,kBACrCwH,sBAAuBV,EAAU/C,eACjC0D,aAAcX,EAAUrL,MACxBiM,aAAcrD,EACdrE,kBAAmBA,EACnBnB,cAAekF,EACfrI,KAAMD,EACN0L,0BAA2BA,EAC3BQ,0BAA2B,WACzB,OAAOZ,EAAOZ,mCAAmCY,EAAO3J,UAK1DnH,KAAK+P,yBACP/P,KAAK+P,yBAA0B,EAE/B/P,KAAKmQ,+BAA+BnQ,KAAKmH,SAEzC,EAAIwD,EAAwB,SAAa,CACvCwG,2BAA4B5D,EAActJ,0BAC1CmN,mBAAoBP,EAAU1D,SAC9BkE,iBAAkBR,EAAUzD,UAC5BkE,0BAA2BT,EAAU9G,kBACrCwH,sBAAuBV,EAAUrH,YACjCgI,aAAcX,EAAUzL,OACxBqM,aAAchK,EACdsC,kBAAmBA,EACnBnB,cAAeY,EACf/D,KAAML,EACN8L,0BAA2BA,EAC3BQ,0BAA2B,WACzB,OAAOZ,EAAOX,+BAA+BW,EAAO3J,UAM1DnH,KAAK2Q,8BAGDvC,IAAemC,EAAUnC,YAAc3G,IAAc8I,EAAU9I,UAAW,CAC5E,IAAI2H,EAAkB7B,EAActJ,0BAA0B9D,eAC1DkP,EAAoB9B,EAAc9J,6BAA6BtD,eAEnEH,KAAKuP,wBAAwB,CAC3BnB,WAAYA,EACZ3G,UAAWA,EACX4H,kBAAmBA,EACnBD,gBAAiBA,IAIrBpP,KAAK4Q,wCAEN,CACD9S,IAAK,uBACL/B,MAAO,WACDiE,KAAK4L,iCACP,EAAId,EAAyB6G,wBAAwB3R,KAAK4L,kCAU7D,CACD9N,IAAK,SACL/B,MAAO,WACL,IAAI6V,EAAe5R,KAAKmH,MACpB4B,EAAqB6I,EAAa7I,mBAClCW,EAAakI,EAAalI,WAC1ByF,EAAYyC,EAAazC,UACzBzG,EAAYkJ,EAAalJ,UACzBmJ,EAAiBD,EAAaC,eAC9BC,EAAgBF,EAAaE,cAC7BC,EAAiBH,EAAaG,eAC9B3M,EAASwM,EAAaxM,OACtB4M,EAAKJ,EAAaI,GAClB7I,EAAoByI,EAAazI,kBACjC8I,EAAOL,EAAaK,KACpB9M,EAAQyM,EAAazM,MACrB+M,EAAWN,EAAaM,SACxB1M,EAAQoM,EAAapM,MACrB2M,EAAenS,KAAKsN,MACpBC,EAAgB4E,EAAa5E,cAC7BzB,EAAwBqG,EAAarG,sBAErChI,EAAc9D,KAAKoS,eAEnBC,EAAY,CACdC,UAAW,aACXC,UAAW,MACXnN,OAAQsE,EAAa,OAAStE,EAC9BE,SAAU,WACVE,MAAO2J,EAAY,OAAS3J,EAC5BgN,wBAAyB,QACzBC,WAAY,aAGV3G,IACF9L,KAAKgQ,YAAc,IAKhBhQ,KAAKsN,MAAMxJ,aACd9D,KAAK0S,mBAIP1S,KAAK2S,2BAA2B3S,KAAKmH,MAAOnH,KAAKsN,OAEjD,IAAI+B,EAAoB9B,EAAc9J,6BAA6BtD,eAC/DiP,EAAkB7B,EAActJ,0BAA0B9D,eAI1DyS,EAAwBxD,EAAkBhK,EAASmI,EAAcS,cAAgB,EACjF6E,EAA0BxD,EAAoB7J,EAAQ+H,EAAcS,cAAgB,EAEpF6E,IAA4B7S,KAAK8S,0BAA4BF,IAA0B5S,KAAK+S,yBAC9F/S,KAAK8S,yBAA2BD,EAChC7S,KAAK+S,uBAAyBH,EAC9B5S,KAAKgT,2BAA4B,GAQnCX,EAAUY,UAAY5D,EAAoBuD,GAAyBpN,EAAQ,SAAW,OACtF6M,EAAUa,UAAY9D,EAAkByD,GAA2BzN,EAAS,SAAW,OACvF,IAAI+N,EAAoBnT,KAAKoT,mBACzBC,EAAqD,IAA7BF,EAAkB3Q,QAAgB4C,EAAS,GAAKI,EAAQ,EACpF,OAAOgB,EAAMsC,cAAc,OAAO,EAAI5C,EAAS,SAAa,CAC1DmB,IAAKrH,KAAKsT,2BACTzB,EAAgB,CACjB,aAAc7R,KAAKmH,MAAM,cACzB,gBAAiBnH,KAAKmH,MAAM,iBAC5BuB,WAAW,EAAIjC,EAAK,SAAa,yBAA0BiC,GAC3DsJ,GAAIA,EACJtK,SAAU1H,KAAKoJ,UACf6I,KAAMA,EACN9M,MAAOoG,EAAc,GAAI8G,EAAW,GAAIlN,GACxC+M,SAAUA,IACRiB,EAAkB3Q,OAAS,GAAKgE,EAAMsC,cAAc,MAAO,CAC7DJ,UAAW,+CACXuJ,KAAMH,EACN3M,MAAOoG,EAAc,CACnB/F,MAAOuD,EAAqB,OAASsG,EACrCjK,OAAQgK,EACRmE,SAAUlE,EACVmE,UAAWpE,EACXqE,SAAU,SACVC,cAAe5P,EAAc,OAAS,GACtCwB,SAAU,YACTyM,IACFoB,GAAoBE,GAAyBlK,OAIjD,CACDrL,IAAK,6BACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MACjF9J,EAAe2D,EAAM3D,aACrBmQ,EAAoBxM,EAAMwM,kBAC1BzK,EAAc/B,EAAM+B,YACpBtF,EAA2BuD,EAAMvD,yBACjCwB,EAAS+B,EAAM/B,OACfwO,EAAsBzM,EAAMyM,oBAC5BhK,EAAwBzC,EAAMyC,sBAC9BE,EAAmB3C,EAAM2C,iBACzBqD,EAAWhG,EAAMgG,SACjB3H,EAAQ2B,EAAM3B,MACdzB,EAAoBoD,EAAMpD,kBAC1BmK,EAA4BZ,EAAMY,0BAClCC,EAA0Bb,EAAMa,wBAChCZ,EAAgBD,EAAMC,cACtB9F,EAAYzH,KAAKsO,kBAAoB,EAAItO,KAAKsO,kBAAoBhB,EAAM7F,UACxE2G,EAAapO,KAAKwO,mBAAqB,EAAIxO,KAAKwO,mBAAqBlB,EAAMc,WAE3EtK,EAAc9D,KAAKoS,aAAajL,EAAOmG,GAI3C,GAFAtN,KAAKoT,mBAAqB,GAEtBhO,EAAS,GAAKI,EAAQ,EAAG,CAC3B,IAAIlB,EAAuBiJ,EAAc9J,6BAA6B3B,oBAAoB,CACxFrB,cAAe+E,EACf9E,OAAQ0N,IAEN7J,EAAoBgJ,EAActJ,0BAA0BnC,oBAAoB,CAClFrB,cAAe2E,EACf1E,OAAQ+G,IAEN5D,EAA6B0J,EAAc9J,6BAA6BoQ,oBAAoB,CAC9FpT,cAAe+E,EACf9E,OAAQ0N,IAEN/J,EAA2BkJ,EAActJ,0BAA0B4P,oBAAoB,CACzFpT,cAAe2E,EACf1E,OAAQ+G,IAGVzH,KAAKsM,0BAA4BhI,EAAqBU,MACtDhF,KAAKuM,yBAA2BjI,EAAqBW,KACrDjF,KAAK0M,uBAAyBnI,EAAkBS,MAChDhF,KAAK2M,sBAAwBpI,EAAkBU,KAC/C,IAAI6O,EAAwBlK,EAAsB,CAChD2I,UAAW,aACX5P,UAAWuG,EACXtG,mBAAoBgR,EACpB/Q,gBAAiBqL,EACjBpL,WAAkD,kBAA/BwB,EAAqBU,MAAqBV,EAAqBU,MAAQ,EAC1FjC,UAAgD,kBAA9BuB,EAAqBW,KAAoBX,EAAqBW,MAAQ,IAEtF8O,EAAqBnK,EAAsB,CAC7C2I,UAAW,WACX5P,UAAWwK,EACXvK,mBAAoBkH,EACpBjH,gBAAiBsL,EACjBrL,WAA+C,kBAA5ByB,EAAkBS,MAAqBT,EAAkBS,MAAQ,EACpFjC,UAA6C,kBAA3BwB,EAAkBU,KAAoBV,EAAkBU,MAAQ,IAGhFvB,EAAmBoQ,EAAsB9Q,mBACzCW,EAAkBmQ,EAAsB5Q,kBACxCgB,EAAgB6P,EAAmB/Q,mBACnCmB,EAAe4P,EAAmB7Q,kBAEtC,GAAIU,EAA0B,CAK5B,IAAKA,EAAyBoQ,iBAC5B,IAAK,IAAIrP,EAAWT,EAAeS,GAAYR,EAAcQ,IAC3D,IAAKf,EAAyBnG,IAAIkH,EAAU,GAAI,CAC9CjB,EAAmB,EACnBC,EAAkBuF,EAAc,EAChC,MASN,IAAKtF,EAAyBqQ,gBAC5B,IAAK,IAAIpP,EAAcnB,EAAkBmB,GAAelB,EAAiBkB,IACvE,IAAKjB,EAAyBnG,IAAI,EAAGoH,GAAc,CACjDX,EAAgB,EAChBC,EAAegJ,EAAW,EAC1B,OAMRnN,KAAKoT,mBAAqBO,EAAkB,CAC1CpQ,UAAWvD,KAAKiQ,WAChBzM,aAAcA,EACdC,6BAA8B8J,EAAc9J,6BAC5CC,iBAAkBA,EAClBC,gBAAiBA,EACjBC,yBAA0BA,EAC1BC,2BAA4BA,EAC5BC,YAAaA,EACbC,kBAAmBA,EACnBC,OAAQhE,KACRiE,0BAA2BsJ,EAActJ,0BACzCC,cAAeA,EACfC,aAAcA,EACdiK,WAAYA,EACZ3G,UAAWA,EACXrD,WAAYpE,KAAKgQ,YACjB3L,yBAA0BA,EAC1BC,qBAAsBA,EACtBC,kBAAmBA,IAGrBvE,KAAKmM,kBAAoBzI,EACzB1D,KAAKqM,iBAAmB1I,EACxB3D,KAAKwM,eAAiBtI,EACtBlE,KAAKyM,cAAgBtI,KASxB,CACDrG,IAAK,uBACL/B,MAAO,WACL,IAAImY,EAA6BlU,KAAKmH,MAAM+M,2BAExClU,KAAK4L,iCACP,EAAId,EAAyB6G,wBAAwB3R,KAAK4L,gCAG5D5L,KAAK4L,gCAAiC,EAAId,EAAyBqJ,yBAAyBnU,KAAKoU,6BAA8BF,KAEhI,CACDpW,IAAK,6BAML/B,MAAO,WACL,GAAmD,kBAAxCiE,KAAKwP,gCAA2F,kBAArCxP,KAAKyP,4BAA0C,CACnH,IAAI5K,EAAc7E,KAAKwP,+BACnB7K,EAAW3E,KAAKyP,4BACpBzP,KAAKwP,+BAAiC,KACtCxP,KAAKyP,4BAA8B,KACnCzP,KAAKsI,kBAAkB,CACrBzD,YAAaA,EACbF,SAAUA,OAIf,CACD7G,IAAK,0BACL/B,MAAO,SAAiCkG,GACtC,IAAIoS,EAASrU,KAEToO,EAAanM,EAAMmM,WACnB3G,EAAYxF,EAAMwF,UAClB4H,EAAoBpN,EAAMoN,kBAC1BD,EAAkBnN,EAAMmN,gBAE5BpP,KAAKsU,kBAAkB,CACrBtI,SAAU,SAAkB9J,GAC1B,IAAIkM,EAAalM,EAAMkM,WACnB3G,EAAYvF,EAAMuF,UAClB8M,EAAeF,EAAOlN,MACtB/B,EAASmP,EAAanP,QAG1BsC,EAFe6M,EAAa7M,UAEnB,CACPH,aAAcnC,EACdoP,YAHUD,EAAa/O,MAIvBgC,aAAc4H,EACdhB,WAAYA,EACZ3G,UAAWA,EACXgN,YAAapF,KAGjBpD,QAAS,CACPmC,WAAYA,EACZ3G,UAAWA,OAIhB,CACD3J,IAAK,eACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MAGrF,OAAOzR,OAAOmC,eAAeC,KAAKkJ,EAAO,eAAiBuN,QAAQvN,EAAMrD,aAAe4Q,QAAQpH,EAAMxJ,eAEtG,CACDhG,IAAK,sCACL/B,MAAO,WACL,GAAIiE,KAAKgT,0BAA2B,CAClC,IAAI2B,EAA4B3U,KAAKmH,MAAMwN,0BAC3C3U,KAAKgT,2BAA4B,EACjC2B,EAA0B,CACxBC,WAAY5U,KAAK8S,yBAA2B,EAC5CrN,KAAMzF,KAAKsN,MAAMC,cAAcS,cAC/B6G,SAAU7U,KAAK+S,uBAAyB,OAI7C,CACDjV,IAAK,mBAML/B,MAAO,SAA0B+Y,GAC/B,IAAI1G,EAAa0G,EAAM1G,WACnB3G,EAAYqN,EAAMrN,UAElB+I,EAAclJ,EAAKmJ,gCAAgC,CACrDF,UAAWvQ,KAAKsN,MAChBc,WAAYA,EACZ3G,UAAWA,IAGT+I,IACFA,EAAY1E,uBAAwB,EACpC9L,KAAK6L,SAAS2E,MAGjB,CACD1S,IAAK,2BACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MACrF,OAAOhG,EAAKmH,yBAAyBtH,EAAOmG,KAE7C,CACDxP,IAAK,qCACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MAEjFkD,EAAclJ,EAAKyN,2CAA2C5N,EAAOmG,GAErEkD,IACFA,EAAY1E,uBAAwB,EACpC9L,KAAK6L,SAAS2E,MAGjB,CACD1S,IAAK,0BACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MACrF,OAAOhG,EAAKiH,wBAAwBpH,EAAOmG,KAE5C,CACDxP,IAAK,mBACL/B,MAAO,WACL,IAAIqI,EAAapE,KAAKgQ,YAClBzM,EAAYvD,KAAKiQ,WACjBlM,EAAoB/D,KAAKmH,MAAMpD,kBAOnC/D,KAAKiQ,WAAa,GAClBjQ,KAAKgQ,YAAc,GAEnB,IAAK,IAAIrL,EAAW3E,KAAKwM,eAAgB7H,GAAY3E,KAAKyM,cAAe9H,IACvE,IAAK,IAAIE,EAAc7E,KAAKmM,kBAAmBtH,GAAe7E,KAAKqM,iBAAkBxH,IAAe,CAClG,IAAI/G,EAAM,GAAGoH,OAAOP,EAAU,KAAKO,OAAOL,GAC1C7E,KAAKgQ,YAAYlS,GAAOsG,EAAWtG,GAE/BiG,IACF/D,KAAKiQ,WAAWnS,GAAOyF,EAAUzF,OAKxC,CACDA,IAAK,iCACL/B,MAAO,WACL,IAAIoL,EAAQ5E,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKmH,MACjFmG,EAAQ/K,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,GAAmBA,UAAU,GAAKvC,KAAKsN,MAEjFkD,EAAclJ,EAAK0N,uCAAuC7N,EAAOmG,GAEjEkD,IACFA,EAAY1E,uBAAwB,EACpC9L,KAAK6L,SAAS2E,OAGhB,CAAC,CACH1S,IAAK,2BACL/B,MAAO,SAAkCkZ,EAAW1E,GAClD,IAAIjB,EAAW,GAEe,IAA1B2F,EAAU/L,aAA8C,IAAzBqH,EAAUnC,YAA2C,IAAvB6G,EAAU9H,UAA0C,IAAxBoD,EAAU9I,WACrG6H,EAASlB,WAAa,EACtBkB,EAAS7H,UAAY,IAEZwN,EAAU7G,aAAemC,EAAUnC,YAAc6G,EAAUnH,eAAiB,GAAKmH,EAAUxN,YAAc8I,EAAU9I,WAAawN,EAAUzL,YAAc,IACjK3N,OAAOuG,OAAOkN,EAAUhI,EAAKmJ,gCAAgC,CAC3DF,UAAWA,EACXnC,WAAY6G,EAAU7G,WACtB3G,UAAWwN,EAAUxN,aAIzB,IAgCIyN,EACAC,EAjCA5H,EAAgBgD,EAAUhD,cAkF9B,OAhFA+B,EAASxD,uBAAwB,EAE7BmJ,EAAUhM,cAAgBsE,EAAcC,iBAAmByH,EAAU7H,YAAcG,EAAcE,gBAEnG6B,EAASxD,uBAAwB,GAGnCyB,EAAc9J,6BAA6BrD,UAAU,CACnDuC,UAAWsS,EAAU/L,YACrB+D,kBAAmB3F,EAAK4F,wBAAwB+H,GAChDlI,eAAgBzF,EAAK0F,gBAAgBiI,EAAUhM,eAEjDsE,EAActJ,0BAA0B7D,UAAU,CAChDuC,UAAWsS,EAAU9H,SACrBF,kBAAmB3F,EAAK+F,qBAAqB4H,GAC7ClI,eAAgBzF,EAAK0F,gBAAgBiI,EAAU7H,aAGX,IAAlCG,EAAcG,iBAAwD,IAA/BH,EAAcI,eACvDJ,EAAcG,gBAAkB,EAChCH,EAAcI,aAAe,GAI3BsH,EAAUvL,aAAwC,IAA1BuL,EAAUnR,cAA2D,IAAlCyJ,EAAcK,iBAC3E/R,OAAOuG,OAAOkN,EAAU,CACtBxL,aAAa,KAMjB,EAAI0G,EAAkD,SAAa,CACjE7H,UAAW4K,EAAcG,gBACzB0H,SAAmD,kBAAlC7H,EAAcC,gBAA+BD,EAAcC,gBAAkB,KAC9F6H,wBAAyB,WACvB,OAAO9H,EAAc9J,6BAA6B1B,UAAU,IAE9DuT,6BAA8BL,EAC9BM,eAAgBN,EAAU/L,YAC1BsM,aAA+C,kBAA1BP,EAAUhM,YAA2BgM,EAAUhM,YAAc,KAClFwM,kBAAmBR,EAAUnH,eAC7BlF,cAAe2E,EAAcM,mBAC7B6H,mCAAoC,WAClCR,EAAc5N,EAAKyN,2CAA2CE,EAAW1E,OAG7E,EAAI/F,EAAkD,SAAa,CACjE7H,UAAW4K,EAAcI,aACzByH,SAAiD,kBAAhC7H,EAAcE,cAA6BF,EAAcE,cAAgB,KAC1F4H,wBAAyB,WACvB,OAAO9H,EAActJ,0BAA0BlC,UAAU,IAE3DuT,6BAA8BL,EAC9BM,eAAgBN,EAAU9H,SAC1BqI,aAA6C,kBAAxBP,EAAU7H,UAAyB6H,EAAU7H,UAAY,KAC9EqI,kBAAmBR,EAAUzL,YAC7BZ,cAAe2E,EAAcQ,gBAC7B2H,mCAAoC,WAClCP,EAAc7N,EAAK0N,uCAAuCC,EAAW1E,MAGzEhD,EAAcG,gBAAkBuH,EAAU/L,YAC1CqE,EAAcC,gBAAkByH,EAAUhM,YAC1CsE,EAAcK,iBAA4C,IAA1BqH,EAAUnR,YAC1CyJ,EAAcI,aAAesH,EAAU9H,SACvCI,EAAcE,cAAgBwH,EAAU7H,UACxCG,EAAcM,mBAAqBoH,EAAUnH,eAC7CP,EAAcQ,gBAAkBkH,EAAUzL,YAE1C+D,EAAcS,cAAgBiH,EAAU5E,wBAEJlI,IAAhCoF,EAAcS,eAChBT,EAAcU,uBAAwB,EACtCV,EAAcS,cAAgB,GAE9BT,EAAcU,uBAAwB,EAGxCqB,EAAS/B,cAAgBA,EAClBhC,EAAc,GAAI+D,EAAU,GAAI4F,EAAa,GAAIC,KAEzD,CACDrX,IAAK,0BACL/B,MAAO,SAAiCoL,GACtC,MAAoC,kBAAtBA,EAAM8B,YAA2B9B,EAAM8B,YAAc9B,EAAMwO,sBAE1E,CACD7X,IAAK,uBACL/B,MAAO,SAA8BoL,GACnC,MAAkC,kBAApBA,EAAMiG,UAAyBjG,EAAMiG,UAAYjG,EAAMwC,mBAEtE,CACD7L,IAAK,kCAML/B,MAAO,SAAyC6Z,GAC9C,IAAIrF,EAAYqF,EAAMrF,UAClBnC,EAAawH,EAAMxH,WACnB3G,EAAYmO,EAAMnO,UAClB6H,EAAW,CACbjB,2BAA4B1C,GAa9B,MAV0B,kBAAfyC,GAA2BA,GAAc,IAClDkB,EAASpB,0BAA4BE,EAAamC,EAAUnC,WAAa/D,EAA8BhH,yBAA2BgH,EAA8B/G,0BAChKgM,EAASlB,WAAaA,GAGC,kBAAd3G,GAA0BA,GAAa,IAChD6H,EAASnB,wBAA0B1G,EAAY8I,EAAU9I,UAAY4C,EAA8BhH,yBAA2BgH,EAA8B/G,0BAC5JgM,EAAS7H,UAAYA,GAGG,kBAAf2G,GAA2BA,GAAc,GAAKA,IAAemC,EAAUnC,YAAmC,kBAAd3G,GAA0BA,GAAa,GAAKA,IAAc8I,EAAU9I,UAClK6H,EAGF,KAER,CACDxR,IAAK,kBACL/B,MAAO,SAAyBA,GAC9B,MAAwB,oBAAVA,EAAuBA,EAAQ,WAC3C,OAAOA,KAGV,CACD+B,IAAK,2BACL/B,MAAO,SAAkCkZ,EAAW1E,GAClD,IAAIrH,EAAc+L,EAAU/L,YACxB9D,EAAS6P,EAAU7P,OACnB2E,EAAoBkL,EAAUlL,kBAC9B+D,EAAiBmH,EAAUnH,eAC3BtI,EAAQyP,EAAUzP,MAClB4I,EAAamC,EAAUnC,WACvBb,EAAgBgD,EAAUhD,cAE9B,GAAIrE,EAAc,EAAG,CACnB,IAAI2M,EAAc3M,EAAc,EAC5BzH,EAAcqM,EAAiB,EAAI+H,EAAc9U,KAAKK,IAAIyU,EAAa/H,GACvEsB,EAAkB7B,EAActJ,0BAA0B9D,eAC1D2V,EAAgBvI,EAAcU,uBAAyBmB,EAAkBhK,EAASmI,EAAcS,cAAgB,EACpH,OAAOT,EAAc9J,6BAA6B9B,yBAAyB,CACzEJ,MAAOwI,EACPtJ,cAAe+E,EAAQsQ,EACvBtU,cAAe4M,EACf3M,YAAaA,IAIjB,OAAO,IAER,CACD3D,IAAK,6CACL/B,MAAO,SAAoDkZ,EAAW1E,GACpE,IAAInC,EAAamC,EAAUnC,WAEvB2H,EAAuBzO,EAAKmH,yBAAyBwG,EAAW1E,GAEpE,MAAoC,kBAAzBwF,GAAqCA,GAAwB,GAAK3H,IAAe2H,EACnFzO,EAAKmJ,gCAAgC,CAC1CF,UAAWA,EACXnC,WAAY2H,EACZtO,WAAY,IAIT,KAER,CACD3J,IAAK,0BACL/B,MAAO,SAAiCkZ,EAAW1E,GACjD,IAAInL,EAAS6P,EAAU7P,OACnB+H,EAAW8H,EAAU9H,SACrBpD,EAAoBkL,EAAUlL,kBAC9BP,EAAcyL,EAAUzL,YACxBhE,EAAQyP,EAAUzP,MAClBiC,EAAY8I,EAAU9I,UACtB8F,EAAgBgD,EAAUhD,cAE9B,GAAIJ,EAAW,EAAG,CAChB,IAAI6I,EAAW7I,EAAW,EACtB1L,EAAc+H,EAAc,EAAIwM,EAAWjV,KAAKK,IAAI4U,EAAUxM,GAC9D6F,EAAoB9B,EAAc9J,6BAA6BtD,eAC/D2V,EAAgBvI,EAAcU,uBAAyBoB,EAAoB7J,EAAQ+H,EAAcS,cAAgB,EACrH,OAAOT,EAActJ,0BAA0BtC,yBAAyB,CACtEJ,MAAOwI,EACPtJ,cAAe2E,EAAS0Q,EACxBtU,cAAeiG,EACfhG,YAAaA,IAIjB,OAAO,IAER,CACD3D,IAAK,yCACL/B,MAAO,SAAgDkZ,EAAW1E,GAChE,IAAI9I,EAAY8I,EAAU9I,UAEtBwO,EAAsB3O,EAAKiH,wBAAwB0G,EAAW1E,GAElE,MAAmC,kBAAxB0F,GAAoCA,GAAuB,GAAKxO,IAAcwO,EAChF3O,EAAKmJ,gCAAgC,CAC1CF,UAAWA,EACXnC,YAAa,EACb3G,UAAWwO,IAIR,OAGJ3O,EA7pCT,CA8pCEd,EAAMiD,gBAAgB,EAAIlK,EAAgB,SAAayG,EAAQ,YAAqD,MAkLlHC,IACJ,EAAI1G,EAAgB,SAAa+H,EAAM,eAAgB,CACrD,aAAc,OACd,iBAAiB,EACjByB,oBAAoB,EACpBW,YAAY,EACZyF,WAAW,EACXwE,kBAAmBvJ,EAAyB,QAC5C0H,cAAe,WACfC,eAAgB,GAChB4D,oBAAqB,IACrBhM,iBAAkB,GAClB0G,iBAAkBzF,EAAc,QAChCzB,kBAv2Ce,WACf,OAAO,MAu2CPzB,SAAU,aACViN,0BAA2B,aAC3BtL,kBAAmB,aACnBuK,oBAAqB,EACrBhK,sBAAuBS,EAA6B,QACpDP,iBAAkB,GAClBmI,KAAM,OACNiC,2BA33C0C,IA43C1CnK,kBAAmB,OACnB+D,gBAAiB,EACjBtE,aAAc,EACdrE,MAAO,GACP+M,SAAU,EACVnO,mBAAmB,KAErB,EAAI8G,EAAuBqL,UAAU5O,GACrC,IAAI6O,EAAW7O,EACf/L,EAAO,QAAc4a,G,kCCl8CrBta,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAKP,SAA2DoE,GACzD,IAAIgD,EAAYhD,EAAKgD,UACjByS,EAAWzV,EAAKyV,SAChBC,EAA0B1V,EAAK0V,wBAC/BC,EAA+B3V,EAAK2V,6BACpCC,EAAiB5V,EAAK4V,eACtBC,EAAe7V,EAAK6V,aACpBC,EAAoB9V,EAAK8V,kBACzB7M,EAAgBjJ,EAAKiJ,cACrB8M,EAAqC/V,EAAK+V,mCAI1C/S,IAAc4S,IAAuC,kBAAbH,GAAiD,kBAAjBI,GAA8BJ,IAAaI,KACrHH,EAAwBC,GAGpB1M,GAAiB,GAAKA,IAAkB6M,GAC1CC,O,kCC1BN,IAAIha,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,aAAc,EAErB,IAAI8D,EAAmB3D,EAAuBC,EAAQ,MAElD2D,EAAgB5D,EAAuBC,EAAQ,MAE/C4D,EAAmB7D,EAAuBC,EAAQ,KAOlDya,GALSza,EAAQ,MAOrB,WAKE,SAASya,EAA2BzW,GAClC,IAAIgD,EAAYhD,EAAKgD,UACjBoK,EAAiBpN,EAAKoN,eACtBE,EAAoBtN,EAAKsN,mBAC7B,EAAI5N,EAAgB,SAAaW,KAAMoW,IACvC,EAAI7W,EAAgB,SAAaS,KAAM,2BAA4B,KACnE,EAAIT,EAAgB,SAAaS,KAAM,sBAAuB,IAC9D,EAAIT,EAAgB,SAAaS,KAAM,qBAAsB,IAC7D,EAAIT,EAAgB,SAAaS,KAAM,kBAAc,IACrD,EAAIT,EAAgB,SAAaS,KAAM,uBAAmB,IAC1D,EAAIT,EAAgB,SAAaS,KAAM,0BAAsB,GAC7DA,KAAKqW,gBAAkBtJ,EACvB/M,KAAKsW,WAAa3T,EAClB3C,KAAKuW,mBAAqBtJ,EAqQ5B,OAlQA,EAAI3N,EAAa,SAAa8W,EAA4B,CAAC,CACzDtY,IAAK,qBACL/B,MAAO,WACL,OAAO,IAER,CACD+B,IAAK,YACL/B,MAAO,SAAmByE,GACxB,IAAImC,EAAYnC,EAAMmC,UAClBsK,EAAoBzM,EAAMyM,kBAC1BF,EAAiBvM,EAAMuM,eAC3B/M,KAAKsW,WAAa3T,EAClB3C,KAAKuW,mBAAqBtJ,EAC1BjN,KAAKqW,gBAAkBtJ,IAExB,CACDjP,IAAK,eACL/B,MAAO,WACL,OAAOiE,KAAKsW,aAEb,CACDxY,IAAK,uBACL/B,MAAO,WACL,OAAOiE,KAAKuW,qBAEb,CACDzY,IAAK,uBACL/B,MAAO,WACL,OAAOiE,KAAKwW,qBAEb,CACD1Y,IAAK,sBACL/B,MAAO,WACL,OAAO,IAOR,CACD+B,IAAK,2BACL/B,MAAO,SAAkCkF,GACvC,GAAIA,EAAQ,GAAKA,GAASjB,KAAKsW,WAC7B,MAAMG,MAAM,mBAAmBvR,OAAOjE,EAAO,4BAA4BiE,OAAOlF,KAAKsW,aAGvF,GAAIrV,EAAQjB,KAAKwW,mBAIf,IAHA,IAAIE,EAAkC1W,KAAKmB,uCACvCT,EAASgW,EAAgChW,OAASgW,EAAgCjR,KAE7EnD,EAAItC,KAAKwW,mBAAqB,EAAGlU,GAAKrB,EAAOqB,IAAK,CACzD,IAAImD,EAAOzF,KAAKqW,gBAAgB,CAC9BpV,MAAOqB,IAKT,QAAa6F,IAAT1C,GAAsBkR,MAAMlR,GAC9B,MAAMgR,MAAM,kCAAkCvR,OAAO5C,EAAG,cAAc4C,OAAOO,IAC3D,OAATA,GACTzF,KAAK4W,yBAAyBtU,GAAK,CACjC5B,OAAQA,EACR+E,KAAM,GAERzF,KAAK6W,kBAAoB5V,IAEzBjB,KAAK4W,yBAAyBtU,GAAK,CACjC5B,OAAQA,EACR+E,KAAMA,GAER/E,GAAU+E,EACVzF,KAAKwW,mBAAqBvV,GAKhC,OAAOjB,KAAK4W,yBAAyB3V,KAEtC,CACDnD,IAAK,uCACL/B,MAAO,WACL,OAAOiE,KAAKwW,oBAAsB,EAAIxW,KAAK4W,yBAAyB5W,KAAKwW,oBAAsB,CAC7F9V,OAAQ,EACR+E,KAAM,KAST,CACD3H,IAAK,eACL/B,MAAO,WACL,IAAI2a,EAAkC1W,KAAKmB,uCAI3C,OAH+BuV,EAAgChW,OAASgW,EAAgCjR,MAC/EzF,KAAKsW,WAAatW,KAAKwW,mBAAqB,GACfxW,KAAKuW,qBAe5D,CACDzY,IAAK,2BACL/B,MAAO,SAAkCsF,GACvC,IAAIC,EAAcD,EAAME,MACpBA,OAAwB,IAAhBD,EAAyB,OAASA,EAC1Cb,EAAgBY,EAAMZ,cACtBe,EAAgBH,EAAMG,cACtBC,EAAcJ,EAAMI,YAExB,GAAIhB,GAAiB,EACnB,OAAO,EAGT,IAGIqW,EAHAC,EAAQ/W,KAAKkB,yBAAyBO,GACtCuV,EAAYD,EAAMrW,OAClBuW,EAAYD,EAAYvW,EAAgBsW,EAAMtR,KAGlD,OAAQlE,GACN,IAAK,QACHuV,EAAcE,EACd,MAEF,IAAK,MACHF,EAAcG,EACd,MAEF,IAAK,SACHH,EAAcE,GAAavW,EAAgBsW,EAAMtR,MAAQ,EACzD,MAEF,QACEqR,EAAc/V,KAAKkC,IAAIgU,EAAWlW,KAAKK,IAAI4V,EAAWxV,IAI1D,IAAIb,EAAYX,KAAKG,eACrB,OAAOY,KAAKkC,IAAI,EAAGlC,KAAKK,IAAIT,EAAYF,EAAeqW,MAExD,CACDhZ,IAAK,sBACL/B,MAAO,SAA6BgE,GAClC,IAAIU,EAAgBV,EAAOU,cACvBC,EAASX,EAAOW,OAGpB,GAAkB,IAFFV,KAAKG,eAGnB,MAAO,GAGT,IAAI6W,EAAYtW,EAASD,EAErBuE,EAAQhF,KAAKkX,iBAAiBxW,GAE9BqW,EAAQ/W,KAAKkB,yBAAyB8D,GAC1CtE,EAASqW,EAAMrW,OAASqW,EAAMtR,KAG9B,IAFA,IAAIR,EAAOD,EAEJtE,EAASsW,GAAa/R,EAAOjF,KAAKsW,WAAa,GACpDrR,IACAvE,GAAUV,KAAKkB,yBAAyB+D,GAAMQ,KAGhD,MAAO,CACLT,MAAOA,EACPC,KAAMA,KAST,CACDnH,IAAK,YACL/B,MAAO,SAAmBkF,GACxBjB,KAAKwW,mBAAqBzV,KAAKK,IAAIpB,KAAKwW,mBAAoBvV,EAAQ,KAErE,CACDnD,IAAK,gBACL/B,MAAO,SAAuBob,EAAMC,EAAK1W,GACvC,KAAO0W,GAAOD,GAAM,CAClB,IAAIE,EAASD,EAAMrW,KAAKuW,OAAOH,EAAOC,GAAO,GACzC5V,EAAgBxB,KAAKkB,yBAAyBmW,GAAQ3W,OAE1D,GAAIc,IAAkBd,EACpB,OAAO2W,EACE7V,EAAgBd,EACzB0W,EAAMC,EAAS,EACN7V,EAAgBd,IACzByW,EAAOE,EAAS,GAIpB,OAAID,EAAM,EACDA,EAAM,EAEN,IAGV,CACDtZ,IAAK,qBACL/B,MAAO,SAA4BkF,EAAOP,GAGxC,IAFA,IAAI6W,EAAW,EAERtW,EAAQjB,KAAKsW,YAActW,KAAKkB,yBAAyBD,GAAOP,OAASA,GAC9EO,GAASsW,EACTA,GAAY,EAGd,OAAOvX,KAAKwX,cAAczW,KAAKK,IAAIH,EAAOjB,KAAKsW,WAAa,GAAIvV,KAAKuW,MAAMrW,EAAQ,GAAIP,KASxF,CACD5C,IAAK,mBACL/B,MAAO,SAA0B2E,GAC/B,GAAIiW,MAAMjW,GACR,MAAM+V,MAAM,kBAAkBvR,OAAOxE,EAAQ,eAK/CA,EAASK,KAAKkC,IAAI,EAAGvC,GACrB,IAAIgW,EAAkC1W,KAAKmB,uCACvCsW,EAAoB1W,KAAKkC,IAAI,EAAGjD,KAAKwW,oBAEzC,OAAIE,EAAgChW,QAAUA,EAErCV,KAAKwX,cAAcC,EAAmB,EAAG/W,GAKzCV,KAAK0X,mBAAmBD,EAAmB/W,OAIjD0V,EAvRT,IA0RA7a,EAAO,QAAc6a,G,kCC9SrBva,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAQuE,uBAAoB,EAsB5BvE,EAAQuE,kBAVgB,WACtB,MARyB,qBAAX6X,QAILA,OAAOC,OAPY,SADC,O,kCCJ/B/b,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAKP,WACE,IAAIsc,IAAiBtV,UAAUC,OAAS,QAAsB2F,IAAjB5F,UAAU,KAAmBA,UAAU,GAChFuV,EAAgB,GACpB,OAAO,SAAUnY,GACf,IAAIqM,EAAWrM,EAAKqM,SAChBC,EAAUtM,EAAKsM,QACff,EAAOrP,OAAOqP,KAAKe,GACnB8L,GAAkBF,GAAkB3M,EAAK8M,OAAM,SAAUla,GAC3D,IAAI/B,EAAQkQ,EAAQnO,GACpB,OAAOkJ,MAAMiR,QAAQlc,GAASA,EAAMyG,OAAS,EAAIzG,GAAS,KAExDmc,EAAehN,EAAK1I,SAAW3G,OAAOqP,KAAK4M,GAAetV,QAAU0I,EAAKiN,MAAK,SAAUra,GAC1F,IAAIsa,EAAcN,EAAcha,GAC5B/B,EAAQkQ,EAAQnO,GACpB,OAAOkJ,MAAMiR,QAAQlc,GAASqc,EAAYC,KAAK,OAAStc,EAAMsc,KAAK,KAAOD,IAAgBrc,KAE5F+b,EAAgB7L,EAEZ8L,GAAkBG,GACpBlM,EAASC,M,kCC3Bf,IAAIvQ,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAMP,SAAiCoE,GAC/B,IAAIyV,EAAWzV,EAAKyV,SAChBjE,EAA6BxR,EAAKwR,2BAClCC,EAAqBzR,EAAKyR,mBAC1BC,EAAmB1R,EAAK0R,iBACxBC,EAA4B3R,EAAK2R,0BACjCC,EAAwB5R,EAAK4R,sBAC7BC,EAAe7R,EAAK6R,aACpBC,EAAe9R,EAAK8R,aACpB1H,EAAoBpK,EAAKoK,kBACzBnB,EAAgBjJ,EAAKiJ,cACrBnD,EAAO9F,EAAK8F,KACZyL,EAA4BvR,EAAKuR,0BACjCQ,EAA4B/R,EAAK+R,0BACjC/O,EAAYwO,EAA2B9Q,eACvCiY,EAAmB1P,GAAiB,GAAKA,EAAgBjG,EACzD4V,EAAiB9S,IAAS+L,GAAgBN,IAA8BG,GAAwC,kBAAb+D,GAAyBA,IAAa/D,EAGzIiH,IAAqBC,GAAkBxO,IAAsBuH,GAA6B1I,IAAkB2I,GAC9GG,EAA0B9I,IAEhB0P,GAAoB3V,EAAY,IAAM8C,EAAO+L,GAAgB7O,EAAYyO,IAK/EK,EAAeN,EAA2BhR,eAAiBsF,GAC7DiM,EAA0B/O,EAAY,IAhCHjH,EAAuBC,EAAQ,OAE3DA,EAAQ,O,kCCTrB,IAAID,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAQid,mCAAqCjd,EAAQ4Y,wBAA0B5Y,EAAQoW,4BAAyB,EAEhH,IAAI8G,EAAkB9c,EAAQ,MAEbD,EAAuBC,EAAQ,IAKhDJ,EAAQid,mCAHyE,KAgBjFjd,EAAQoW,uBAXqB,SAAgC+G,GAC3D,OAAO,EAAID,EAAgBE,KAAKD,EAAM1G,KAiCxCzW,EAAQ4Y,wBArBsB,SAAiCnI,EAAU4M,GACvE,IAAI5T,EAEJ6T,QAAQC,UAAUC,MAAK,WACrB/T,EAAQgU,KAAKC,SAGf,IAQIP,EAAQ,CACV1G,IAAI,EAAIyG,EAAgBS,MATZ,SAASC,IACjBH,KAAKC,MAAQjU,GAAS4T,EACxB5M,EAAS/N,OAETya,EAAM1G,IAAK,EAAIyG,EAAgBS,KAAKC,OAOxC,OAAOT,I,kCC1CT,IAAIU,EALJvd,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAQod,IAAMpd,EAAQ2d,SAAM,EAc5B,IAAIG,GATFD,EADoB,qBAAXzB,OACHA,OACmB,qBAATvZ,KACVA,KAEA,IAKUkb,uBAAyBF,EAAIG,6BAA+BH,EAAII,0BAA4BJ,EAAIK,wBAA0BL,EAAIM,yBAA2B,SAAU1N,GACnL,OAAOoN,EAAIO,WAAW3N,EAAU,IAAO,KAGrC4N,EAASR,EAAIS,sBAAwBT,EAAIU,4BAA8BV,EAAIW,yBAA2BX,EAAIY,uBAAyBZ,EAAIa,wBAA0B,SAAUjI,GAC7KoH,EAAIc,aAAalI,IAGfkH,EAAMG,EACV9d,EAAQ2d,IAAMA,EACd,IAAIP,EAAMiB,EACVre,EAAQod,IAAMA,G,kCC5Bd9c,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAmBP,SAAsCoE,GACpC,IAAIgD,EAAYhD,EAAKgD,UACjBC,EAAqBjD,EAAKiD,mBAC1BC,EAAkBlD,EAAKkD,gBACvBC,EAAanD,EAAKmD,WAClBC,EAAYpD,EAAKoD,UAMrB,OAFAH,EAAqB7B,KAAKkC,IAAI,EAAGL,GArBJ,IAuBzBC,EACK,CACLG,mBAAoBjC,KAAKkC,IAAI,EAAGH,EAAa,GAC7CI,kBAAmBnC,KAAKK,IAAIuB,EAAY,EAAGI,EAAYH,IAGlD,CACLI,mBAAoBjC,KAAKkC,IAAI,EAAGH,EAAaF,GAC7CM,kBAAmBnC,KAAKK,IAAIuB,EAAY,EAAGI,EAAY,KArC7DxH,EAAQ4H,0BAA4B5H,EAAQ6H,4BAA8B7H,EAAQ8H,yBAA2B9H,EAAQ+H,+BAA4B,EAEpI3H,EAAQ,MAGrBJ,EAAQ+H,2BADyB,EAGjC/H,EAAQ8H,yBADuB,EAG/B9H,EAAQ6H,4BAD0B,aAQlC7H,EAAQ4H,0BANwB,Y,kCCdhC,IAAIzH,EAAyBC,EAAQ,MAEjCC,EAA0BD,EAAQ,MAEtCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,aAAc,EAErB,IAoBIyK,EAAQC,EApBR5G,EAAmB3D,EAAuBC,EAAQ,MAElD2D,EAAgB5D,EAAuBC,EAAQ,MAE/CwK,EAA8BzK,EAAuBC,EAAQ,OAE7DyK,EAAmB1K,EAAuBC,EAAQ,OAElD0K,EAA0B3K,EAAuBC,EAAQ,OAEzD2K,EAAa5K,EAAuBC,EAAQ,OAE5C4D,EAAmB7D,EAAuBC,EAAQ,KAElD6K,EAAQ5K,EAAwBD,EAAQ,IAExCwe,EAAuBze,EAAuBC,EAAQ,OAEzCD,EAAuBC,EAAQ,IAIhD,SAASoP,EAAQC,EAAQC,GAAkB,IAAIC,EAAOrP,OAAOqP,KAAKF,GAAS,GAAInP,OAAOsP,sBAAuB,CAAE,IAAIC,EAAUvP,OAAOsP,sBAAsBH,GAAaC,IAAgBG,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOzP,OAAOgC,yBAAyBmN,EAAQM,GAAKpB,eAAgBgB,EAAKtF,KAAKlD,MAAMwI,EAAME,GAAY,OAAOF,EAE9U,SAASK,EAAclJ,GAAU,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CAAE,IAAIG,EAAyB,MAAhBF,UAAUD,GAAaC,UAAUD,GAAK,GAAQA,EAAI,EAAKyI,EAAQtI,GAAQ,GAAM+I,SAAQ,SAAU1N,IAAO,EAAIyB,EAAgB,SAAa8C,EAAQvE,EAAK2E,EAAO3E,OAAsBjC,OAAO4P,0BAA6B5P,OAAO6P,iBAAiBrJ,EAAQxG,OAAO4P,0BAA0BhJ,IAAmBsI,EAAQtI,GAAQ+I,SAAQ,SAAU1N,GAAOjC,OAAOC,eAAeuG,EAAQvE,EAAKjC,OAAOgC,yBAAyB4E,EAAQ3E,OAAe,OAAOuE,EAE9gB,IAAI+X,GAAanU,EAAQD,EAEzB,SAAUqU,GAGR,SAASD,IACP,IAAIxT,EAEAC,GAEJ,EAAIxH,EAAgB,SAAaW,KAAMoa,GAEvC,IAAK,IAAItT,EAAOvE,UAAUC,OAAQuE,EAAO,IAAIC,MAAMF,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC/EF,EAAKE,GAAQ1E,UAAU0E,GAiDzB,OA9CAJ,GAAQ,EAAIV,EAA2B,SAAanG,MAAO4G,GAAmB,EAAIR,EAAgB,SAAagU,IAAYnc,KAAKyE,MAAMkE,EAAkB,CAAC5G,MAAMkF,OAAO6B,MACtK,EAAIxH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,QAAS,CACxFzB,OAAQyB,EAAMM,MAAMmT,eAAiB,EACrC9U,MAAOqB,EAAMM,MAAMoT,cAAgB,KAErC,EAAIhb,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,mBAAe,IAChG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,kBAAc,IAC/F,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,eAAW,IAC5F,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,4BAAwB,IACzG,EAAItH,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,aAAa,WAC5F,IAAI4B,EAAc5B,EAAMM,MACpBqT,EAAgB/R,EAAY+R,cAC5BC,EAAehS,EAAYgS,aAC3BC,EAAWjS,EAAYiS,SAE3B,GAAI7T,EAAM8T,YAAa,CAIrB,IAAIvV,EAASyB,EAAM8T,YAAYC,cAAgB,EAC3CpV,EAAQqB,EAAM8T,YAAYE,aAAe,EAEzC1V,GADM0B,EAAMiU,SAAWnD,QACXoD,iBAAiBlU,EAAM8T,cAAgB,GACnDK,EAAcC,SAAS9V,EAAM6V,YAAa,KAAO,EACjDE,EAAeD,SAAS9V,EAAM+V,aAAc,KAAO,EACnDC,EAAaF,SAAS9V,EAAMgW,WAAY,KAAO,EAC/CC,EAAgBH,SAAS9V,EAAMiW,cAAe,KAAO,EACrDC,EAAYjW,EAAS+V,EAAaC,EAClCE,EAAW9V,EAAQwV,EAAcE,IAEhCV,GAAiB3T,EAAMyG,MAAMlI,SAAWiW,IAAcZ,GAAgB5T,EAAMyG,MAAM9H,QAAU8V,KAC/FzU,EAAMgF,SAAS,CACbzG,OAAQA,EAAS+V,EAAaC,EAC9B5V,MAAOA,EAAQwV,EAAcE,IAG/BR,EAAS,CACPtV,OAAQA,EACRI,MAAOA,UAKf,EAAIjG,EAAgB,UAAa,EAAI8G,EAAuB,SAAaQ,GAAQ,WAAW,SAAU0U,GACpG1U,EAAM2U,WAAaD,KAEd1U,EAgFT,OA3IA,EAAIP,EAAU,SAAa8T,EAAWC,IA8DtC,EAAI/a,EAAa,SAAa8a,EAAW,CAAC,CACxCtc,IAAK,oBACL/B,MAAO,WACL,IAAI0f,EAAQzb,KAAKmH,MAAMsU,MAEnBzb,KAAKwb,YAAcxb,KAAKwb,WAAWE,YAAc1b,KAAKwb,WAAWE,WAAWC,eAAiB3b,KAAKwb,WAAWE,WAAWC,cAAcC,aAAe5b,KAAKwb,WAAWE,sBAAsB1b,KAAKwb,WAAWE,WAAWC,cAAcC,YAAYC,cAIlP7b,KAAK2a,YAAc3a,KAAKwb,WAAWE,WACnC1b,KAAK8a,QAAU9a,KAAKwb,WAAWE,WAAWC,cAAcC,YAGxD5b,KAAKma,sBAAuB,EAAIA,EAAoB,SAAasB,EAAOzb,KAAK8a,SAE7E9a,KAAKma,qBAAqB2B,kBAAkB9b,KAAK2a,YAAa3a,KAAK+b,WAEnE/b,KAAK+b,eAGR,CACDje,IAAK,uBACL/B,MAAO,WACDiE,KAAKma,sBAAwBna,KAAK2a,aACpC3a,KAAKma,qBAAqB6B,qBAAqBhc,KAAK2a,YAAa3a,KAAK+b,aAGzE,CACDje,IAAK,SACL/B,MAAO,WACL,IAAI2T,EAAe1P,KAAKmH,MACpB8U,EAAWvM,EAAauM,SACxBvT,EAAYgH,EAAahH,UACzB8R,EAAgB9K,EAAa8K,cAC7BC,EAAe/K,EAAa+K,aAC5BtV,EAAQuK,EAAavK,MACrB6L,EAAchR,KAAKsN,MACnBlI,EAAS4L,EAAY5L,OACrBI,EAAQwL,EAAYxL,MAIpB0W,EAAa,CACfzI,SAAU,WAER0I,EAAc,GAyBlB,OAvBK3B,IACH0B,EAAW9W,OAAS,EACpB+W,EAAY/W,OAASA,GAGlBqV,IACHyB,EAAW1W,MAAQ,EACnB2W,EAAY3W,MAAQA,GAgBfgB,EAAMsC,cAAc,MAAO,CAChCJ,UAAWA,EACXrB,IAAKrH,KAAKuJ,QACVpE,MAAOoG,EAAc,GAAI2Q,EAAY,GAAI/W,IACxC8W,EAASE,QAGT/B,EA5IT,CA6IE5T,EAAM4V,YAAY,EAAI7c,EAAgB,SAAayG,EAAQ,YAAqD,MA2B9GC,GACJ1K,EAAO,QAAc6e,GACrB,EAAI7a,EAAgB,SAAa6a,EAAW,eAAgB,CAC1DM,SAAU,aACVF,eAAe,EACfC,cAAc,EACdtV,MAAO,M,mCCrNT,YAEAtJ,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETR,EAAO,QAcP,SAAmCkgB,EAAOY,GAExC,IAAIvB,EAGFA,EADwB,qBAAfuB,EACCA,EACiB,qBAAX1E,OACNA,OACe,qBAATvZ,KACNA,KAEAke,EAGZ,IAAIC,EAA0C,qBAArBzB,EAAQ0B,UAA4B1B,EAAQ0B,SAASD,YAE9E,IAAKA,EAAa,CAChB,IAAIE,EAAe,WACjB,IAAIvD,EAAM4B,EAAQxB,uBAAyBwB,EAAQtB,0BAA4BsB,EAAQvB,6BAA+B,SAAUmD,GAC9H,OAAO5B,EAAQnB,WAAW+C,EAAI,KAGhC,OAAO,SAAUA,GACf,OAAOxD,EAAIwD,IANI,GAUfC,EAAc,WAChB,IAAI/C,EAASkB,EAAQjB,sBAAwBiB,EAAQf,yBAA2Be,EAAQhB,4BAA8BgB,EAAQZ,aAC9H,OAAO,SAAUlI,GACf,OAAO4H,EAAO5H,IAHA,GAOd4K,EAAgB,SAAuBC,GACzC,IAAIC,EAAWD,EAAQE,mBACnBC,EAASF,EAASG,kBAClBC,EAAWJ,EAASK,iBACpBC,EAAcJ,EAAOC,kBACzBC,EAAS9O,WAAa8O,EAASzI,YAC/ByI,EAASzV,UAAYyV,EAAS1V,aAC9B4V,EAAYjY,MAAMK,MAAQwX,EAAOnC,YAAc,EAAI,KACnDuC,EAAYjY,MAAMC,OAAS4X,EAAOpC,aAAe,EAAI,KACrDoC,EAAO5O,WAAa4O,EAAOvI,YAC3BuI,EAAOvV,UAAYuV,EAAOxV,cAOxB6V,EAAiB,SAAwBC,GAE3C,KAAIA,EAAEjb,OAAOqG,WAAmD,oBAA/B4U,EAAEjb,OAAOqG,UAAU6U,SAA0BD,EAAEjb,OAAOqG,UAAU6U,QAAQ,oBAAsB,GAAKD,EAAEjb,OAAOqG,UAAU6U,QAAQ,kBAAoB,GAAnL,CAIA,IAAIV,EAAU7c,KACd4c,EAAc5c,MAEVA,KAAKwd,eACPb,EAAY3c,KAAKwd,eAGnBxd,KAAKwd,cAAgBf,GAAa,YAjBhB,SAAuBI,GACzC,OAAOA,EAAQhC,aAAegC,EAAQY,eAAejY,OAASqX,EAAQjC,cAAgBiC,EAAQY,eAAerY,QAiBvGsY,CAAcb,KAChBA,EAAQY,eAAejY,MAAQqX,EAAQhC,YACvCgC,EAAQY,eAAerY,OAASyX,EAAQjC,aAExCiC,EAAQc,oBAAoBnS,SAAQ,SAAUkR,GAC5CA,EAAGze,KAAK4e,EAASS,YAQrBM,GAAY,EACZC,EAAiB,GACjBC,EAAsB,iBACtBC,EAAc,kBAAkBC,MAAM,KACtCC,EAAc,uEAAuED,MAAM,KAC3FE,EAAM,GAEJC,EAAMrD,EAAQ0B,SAAS1T,cAAc,eAMzC,QAJgCX,IAA5BgW,EAAIhZ,MAAMiZ,gBACZR,GAAY,IAGI,IAAdA,EACF,IAAK,IAAItb,EAAI,EAAGA,EAAIyb,EAAYvb,OAAQF,IACtC,QAAoD6F,IAAhDgW,EAAIhZ,MAAM4Y,EAAYzb,GAAK,iBAAgC,CAC7D4b,EAAMH,EAAYzb,GAClBub,EAAiB,IAAMK,EAAIG,cAAgB,IAC3CP,EAAsBG,EAAY3b,GAClCsb,GAAY,EACZ,MAKR,IAAIQ,EAAgB,aAChBE,EAAqB,IAAMT,EAAiB,aAAeO,EAAgB,gDAC3EG,EAAiBV,EAAiB,kBAAoBO,EAAgB,KAmG5E,MAAO,CACLtC,kBA1EsB,SAA2Be,EAASH,GAC1D,GAAIH,EACFM,EAAQN,YAAY,WAAYG,OAC3B,CACL,IAAKG,EAAQE,mBAAoB,CAC/B,IAAIyB,EAAM3B,EAAQlB,cAEd8C,EAAe3D,EAAQC,iBAAiB8B,GAExC4B,GAAyC,UAAzBA,EAAanZ,WAC/BuX,EAAQ1X,MAAMG,SAAW,YAjCd,SAAsBkZ,GACvC,IAAKA,EAAIE,eAAe,uBAAwB,CAE9C,IAAIC,GAAOL,GAA0C,IAAM,uBAAyBC,GAAkC,IAA5G,6VACNK,EAAOJ,EAAII,MAAQJ,EAAIK,qBAAqB,QAAQ,GACpD1Z,EAAQqZ,EAAI1V,cAAc,SAC9B3D,EAAM6M,GAAK,sBACX7M,EAAM2Z,KAAO,WAEA,MAATrD,GACFtW,EAAM4Z,aAAa,QAAStD,GAG1BtW,EAAM6Z,WACR7Z,EAAM6Z,WAAWC,QAAUN,EAE3BxZ,EAAM+Z,YAAYV,EAAIW,eAAeR,IAGvCC,EAAKM,YAAY/Z,IAiBfia,CAAaZ,GACb3B,EAAQY,eAAiB,GACzBZ,EAAQc,oBAAsB,IAC7Bd,EAAQE,mBAAqByB,EAAI1V,cAAc,QAAQJ,UAAY,kBACpE,IAAI2W,EAAqB,oFAEzB,GAAI1H,OAAO2H,aAAc,CACvB,IAAIC,EAAeD,aAAaE,aAAa,+BAAgC,CAC3EC,WAAY,WACV,OAAOJ,KAGXxC,EAAQE,mBAAmB2C,UAAYH,EAAaE,WAAW,SAE/D5C,EAAQE,mBAAmB2C,UAAYL,EAGzCxC,EAAQqC,YAAYrC,EAAQE,oBAC5BH,EAAcC,GACdA,EAAQ8C,iBAAiB,SAAUtC,GAAgB,GAG/CS,IACFjB,EAAQE,mBAAmB6C,sBAAwB,SAA2BtC,GACxEA,EAAEc,eAAiBA,GACrBxB,EAAcC,IAIlBA,EAAQE,mBAAmB4C,iBAAiB7B,EAAqBjB,EAAQE,mBAAmB6C,wBAIhG/C,EAAQc,oBAAoB/X,KAAK8W,KA6BnCV,qBAzByB,SAA8Ba,EAASH,GAChE,GAAIH,EACFM,EAAQgD,YAAY,WAAYnD,QAIhC,GAFAG,EAAQc,oBAAoBmC,OAAOjD,EAAQc,oBAAoBJ,QAAQb,GAAK,IAEvEG,EAAQc,oBAAoBnb,OAAQ,CACvCqa,EAAQkD,oBAAoB,SAAU1C,GAAgB,GAElDR,EAAQE,mBAAmB6C,wBAC7B/C,EAAQE,mBAAmBgD,oBAAoBjC,EAAqBjB,EAAQE,mBAAmB6C,uBAE/F/C,EAAQE,mBAAmB6C,sBAAwB,MAGrD,IACE/C,EAAQE,oBAAsBF,EAAQmD,YAAYnD,EAAQE,oBAC1D,MAAOO,W,mGCzNF,ICCX7X,EDDW,IAAqB,qBAAXkS,SAA0BA,OAAO6E,WAAY7E,OAAO6E,SAAS1T,eCEvE,SAASkF,EAAciS,GACpC,KAAKxa,GAAiB,IAATA,GAAcwa,IACrBC,EAAW,CACb,IAAIC,EAAY3D,SAAS1T,cAAc,OACvCqX,EAAUhb,MAAMG,SAAW,WAC3B6a,EAAUhb,MAAMI,IAAM,UACtB4a,EAAUhb,MAAMK,MAAQ,OACxB2a,EAAUhb,MAAMC,OAAS,OACzB+a,EAAUhb,MAAMsO,SAAW,SAC3B+I,SAAS4D,KAAKlB,YAAYiB,GAC1B1a,EAAO0a,EAAUtF,YAAcsF,EAAU3L,YACzCgI,SAAS4D,KAAKJ,YAAYG,GAI9B,OAAO1a,I,iCCjBT,SAAS4a,EAAMC,GACd,IAAIC,EAAGC,EAAGC,EAAI,GAEd,GAAmB,kBAARH,GAAmC,kBAARA,EACrCG,GAAOH,OACD,GAAmB,kBAARA,EACjB,GAAItZ,MAAMiR,QAAQqI,GACjB,IAAKC,EAAE,EAAGA,EAAID,EAAI9d,OAAQ+d,IACrBD,EAAIC,KACHC,EAAIH,EAAMC,EAAIC,OACjBE,IAAQA,GAAO,KACfA,GAAOD,QAKV,IAAKD,KAAKD,EACLA,EAAIC,KACPE,IAAQA,GAAO,KACfA,GAAOF,GAMX,OAAOE,EAzBR,OA4Be,qBAEd,IADA,IAASC,EAAKC,EAAVre,EAAE,EAAWme,EAAI,GACdne,EAAIC,UAAUC,SAChBke,EAAMne,UAAUD,QACfqe,EAAIN,EAAMK,MACbD,IAAQA,GAAO,KACfA,GAAOE,GAIV,OAAOF,I,iCCpCR,IAAI/kB,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETF,OAAOC,eAAeP,EAAS,UAAW,CACxC2O,YAAY,EACZxM,IAAK,WACH,OAAOkjB,EAAK,WAGhB/kB,OAAOC,eAAeP,EAAS,OAAQ,CACrC2O,YAAY,EACZxM,IAAK,WACH,OAAOkjB,EAAK,WAGhB/kB,OAAOC,eAAeP,EAAS,oCAAqC,CAClE2O,YAAY,EACZxM,IAAK,WACH,OAAO4M,EAAOvE,qCAIlB,IAAI6a,EAAQllB,EAAuBC,EAAQ,OAEvC2O,EAAS3O,EAAQ,O,iCC1BrB,IAAID,EAAyBC,EAAQ,MAErCE,OAAOC,eAAeP,EAAS,aAAc,CAC3CQ,OAAO,IAETF,OAAOC,eAAeP,EAAS,UAAW,CACxC2O,YAAY,EACZxM,IAAK,WACH,OAAOmjB,EAAU,WAGrBhlB,OAAOC,eAAeP,EAAS,YAAa,CAC1C2O,YAAY,EACZxM,IAAK,WACH,OAAOmjB,EAAU,WAIrB,IAAIA,EAAanlB,EAAuBC,EAAQ","file":"static/js/0.a38fd80d.chunk.js","sourcesContent":["function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bpfrpt_proptype_VisibleCellRange = exports.bpfrpt_proptype_Alignment = exports.bpfrpt_proptype_OverscanIndicesGetter = exports.bpfrpt_proptype_OverscanIndices = exports.bpfrpt_proptype_OverscanIndicesGetterParams = exports.bpfrpt_proptype_RenderedSection = exports.bpfrpt_proptype_ScrollbarPresenceChange = exports.bpfrpt_proptype_Scroll = exports.bpfrpt_proptype_NoContentRenderer = exports.bpfrpt_proptype_CellSize = exports.bpfrpt_proptype_CellSizeGetter = exports.bpfrpt_proptype_CellRangeRenderer = exports.bpfrpt_proptype_CellRangeRendererParams = exports.bpfrpt_proptype_StyleCache = exports.bpfrpt_proptype_CellCache = exports.bpfrpt_proptype_CellRenderer = exports.bpfrpt_proptype_CellRendererParams = exports.bpfrpt_proptype_CellPosition = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _ScalingCellSizeAndPositionManager = _interopRequireDefault(require(\"./utils/ScalingCellSizeAndPositionManager\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar bpfrpt_proptype_CellPosition = process.env.NODE_ENV === 'production' ? null : {\n  \"columnIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowIndex\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_CellPosition = bpfrpt_proptype_CellPosition;\nvar bpfrpt_proptype_CellRendererParams = process.env.NODE_ENV === 'production' ? null : {\n  \"columnIndex\": _propTypes[\"default\"].number.isRequired,\n  \"isScrolling\": _propTypes[\"default\"].bool.isRequired,\n  \"isVisible\": _propTypes[\"default\"].bool.isRequired,\n  \"key\": _propTypes[\"default\"].string.isRequired,\n  \"parent\": _propTypes[\"default\"].object.isRequired,\n  \"rowIndex\": _propTypes[\"default\"].number.isRequired,\n  \"style\": _propTypes[\"default\"].object.isRequired\n};\nexports.bpfrpt_proptype_CellRendererParams = bpfrpt_proptype_CellRendererParams;\nvar bpfrpt_proptype_CellRenderer = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_CellRenderer = bpfrpt_proptype_CellRenderer;\nvar bpfrpt_proptype_CellCache = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].objectOf(_propTypes[\"default\"].node.isRequired);\nexports.bpfrpt_proptype_CellCache = bpfrpt_proptype_CellCache;\nvar bpfrpt_proptype_StyleCache = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].objectOf(_propTypes[\"default\"].object.isRequired);\nexports.bpfrpt_proptype_StyleCache = bpfrpt_proptype_StyleCache;\nvar bpfrpt_proptype_CellRangeRendererParams = process.env.NODE_ENV === 'production' ? null : {\n  \"cellCache\": _propTypes[\"default\"].objectOf(_propTypes[\"default\"].node.isRequired).isRequired,\n  \"cellRenderer\": _propTypes[\"default\"].func.isRequired,\n  \"columnSizeAndPositionManager\": function columnSizeAndPositionManager() {\n    return (typeof _ScalingCellSizeAndPositionManager[\"default\"] === \"function\" ? _propTypes[\"default\"].instanceOf(_ScalingCellSizeAndPositionManager[\"default\"]).isRequired : _propTypes[\"default\"].any.isRequired).apply(this, arguments);\n  },\n  \"columnStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"columnStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"deferredMeasurementCache\": _propTypes[\"default\"].object,\n  \"horizontalOffsetAdjustment\": _propTypes[\"default\"].number.isRequired,\n  \"isScrolling\": _propTypes[\"default\"].bool.isRequired,\n  \"isScrollingOptOut\": _propTypes[\"default\"].bool.isRequired,\n  \"parent\": _propTypes[\"default\"].object.isRequired,\n  \"rowSizeAndPositionManager\": function rowSizeAndPositionManager() {\n    return (typeof _ScalingCellSizeAndPositionManager[\"default\"] === \"function\" ? _propTypes[\"default\"].instanceOf(_ScalingCellSizeAndPositionManager[\"default\"]).isRequired : _propTypes[\"default\"].any.isRequired).apply(this, arguments);\n  },\n  \"rowStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"scrollLeft\": _propTypes[\"default\"].number.isRequired,\n  \"scrollTop\": _propTypes[\"default\"].number.isRequired,\n  \"styleCache\": _propTypes[\"default\"].objectOf(_propTypes[\"default\"].object.isRequired).isRequired,\n  \"verticalOffsetAdjustment\": _propTypes[\"default\"].number.isRequired,\n  \"visibleColumnIndices\": _propTypes[\"default\"].object.isRequired,\n  \"visibleRowIndices\": _propTypes[\"default\"].object.isRequired\n};\nexports.bpfrpt_proptype_CellRangeRendererParams = bpfrpt_proptype_CellRangeRendererParams;\nvar bpfrpt_proptype_CellRangeRenderer = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_CellRangeRenderer = bpfrpt_proptype_CellRangeRenderer;\nvar bpfrpt_proptype_CellSizeGetter = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_CellSizeGetter = bpfrpt_proptype_CellSizeGetter;\nvar bpfrpt_proptype_CellSize = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].oneOfType([_propTypes[\"default\"].func, _propTypes[\"default\"].number]);\nexports.bpfrpt_proptype_CellSize = bpfrpt_proptype_CellSize;\nvar bpfrpt_proptype_NoContentRenderer = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_NoContentRenderer = bpfrpt_proptype_NoContentRenderer;\nvar bpfrpt_proptype_Scroll = process.env.NODE_ENV === 'production' ? null : {\n  \"clientHeight\": _propTypes[\"default\"].number.isRequired,\n  \"clientWidth\": _propTypes[\"default\"].number.isRequired,\n  \"scrollHeight\": _propTypes[\"default\"].number.isRequired,\n  \"scrollLeft\": _propTypes[\"default\"].number.isRequired,\n  \"scrollTop\": _propTypes[\"default\"].number.isRequired,\n  \"scrollWidth\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_Scroll = bpfrpt_proptype_Scroll;\nvar bpfrpt_proptype_ScrollbarPresenceChange = process.env.NODE_ENV === 'production' ? null : {\n  \"horizontal\": _propTypes[\"default\"].bool.isRequired,\n  \"vertical\": _propTypes[\"default\"].bool.isRequired,\n  \"size\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_ScrollbarPresenceChange = bpfrpt_proptype_ScrollbarPresenceChange;\nvar bpfrpt_proptype_RenderedSection = process.env.NODE_ENV === 'production' ? null : {\n  \"columnOverscanStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"columnOverscanStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"columnStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"columnStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowOverscanStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowOverscanStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"rowStopIndex\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_RenderedSection = bpfrpt_proptype_RenderedSection;\nvar bpfrpt_proptype_OverscanIndicesGetterParams = process.env.NODE_ENV === 'production' ? null : {\n  // One of SCROLL_DIRECTION_HORIZONTAL or SCROLL_DIRECTION_VERTICAL\n  \"direction\": _propTypes[\"default\"].oneOf([\"horizontal\", \"vertical\"]).isRequired,\n  // One of SCROLL_DIRECTION_BACKWARD or SCROLL_DIRECTION_FORWARD\n  \"scrollDirection\": _propTypes[\"default\"].oneOf([-1, 1]).isRequired,\n  // Number of rows or columns in the current axis\n  \"cellCount\": _propTypes[\"default\"].number.isRequired,\n  // Maximum number of cells to over-render in either direction\n  \"overscanCellsCount\": _propTypes[\"default\"].number.isRequired,\n  // Begin of range of visible cells\n  \"startIndex\": _propTypes[\"default\"].number.isRequired,\n  // End of range of visible cells\n  \"stopIndex\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_OverscanIndicesGetterParams = bpfrpt_proptype_OverscanIndicesGetterParams;\nvar bpfrpt_proptype_OverscanIndices = process.env.NODE_ENV === 'production' ? null : {\n  \"overscanStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"overscanStopIndex\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_OverscanIndices = bpfrpt_proptype_OverscanIndices;\nvar bpfrpt_proptype_OverscanIndicesGetter = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_OverscanIndicesGetter = bpfrpt_proptype_OverscanIndicesGetter;\nvar bpfrpt_proptype_Alignment = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].oneOf([\"auto\", \"end\", \"start\", \"center\"]);\nexports.bpfrpt_proptype_Alignment = bpfrpt_proptype_Alignment;\nvar bpfrpt_proptype_VisibleCellRange = process.env.NODE_ENV === 'production' ? null : {\n  \"start\": _propTypes[\"default\"].number,\n  \"stop\": _propTypes[\"default\"].number\n};\nexports.bpfrpt_proptype_VisibleCellRange = bpfrpt_proptype_VisibleCellRange;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _getRequireWildcardCache(nodeInterop) {\n  if (typeof WeakMap !== \"function\") return null;\n  var cacheBabelInterop = new WeakMap();\n  var cacheNodeInterop = new WeakMap();\n  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {\n    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n  })(nodeInterop);\n}\nfunction _interopRequireWildcard(obj, nodeInterop) {\n  if (!nodeInterop && obj && obj.__esModule) {\n    return obj;\n  }\n  if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") {\n    return {\n      \"default\": obj\n    };\n  }\n  var cache = _getRequireWildcardCache(nodeInterop);\n  if (cache && cache.has(obj)) {\n    return cache.get(obj);\n  }\n  var newObj = {};\n  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n  for (var key in obj) {\n    if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) {\n      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n      if (desc && (desc.get || desc.set)) {\n        Object.defineProperty(newObj, key, desc);\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n  }\n  newObj[\"default\"] = obj;\n  if (cache) {\n    cache.set(obj, newObj);\n  }\n  return newObj;\n}\nmodule.exports = _interopRequireWildcard, 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 _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;","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;","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;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _objectWithoutProperties2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutProperties\"));\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar _CellSizeAndPositionManager = _interopRequireDefault(require(\"./CellSizeAndPositionManager\"));\n\nvar _maxElementSize = require(\"./maxElementSize.js\");\n\nvar _types = require(\"../types\");\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 ? (0, _maxElementSize.getMaxElementSize)() : _ref$maxScrollSize,\n        params = (0, _objectWithoutProperties2[\"default\"])(_ref, [\"maxScrollSize\"]);\n    (0, _classCallCheck2[\"default\"])(this, ScalingCellSizeAndPositionManager);\n    (0, _defineProperty2[\"default\"])(this, \"_cellSizeAndPositionManager\", void 0);\n    (0, _defineProperty2[\"default\"])(this, \"_maxScrollSize\", void 0);\n    // Favor composition over inheritance to simplify IE10 support\n    this._cellSizeAndPositionManager = new _CellSizeAndPositionManager[\"default\"](params);\n    this._maxScrollSize = maxScrollSize;\n  }\n\n  (0, _createClass2[\"default\"])(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  return ScalingCellSizeAndPositionManager;\n}();\n\nexports[\"default\"] = ScalingCellSizeAndPositionManager;","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;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = defaultOverscanIndicesGetter;\nexports.SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_BACKWARD = void 0;\n\nvar _types = require(\"./types\");\n\nvar SCROLL_DIRECTION_BACKWARD = -1;\nexports.SCROLL_DIRECTION_BACKWARD = SCROLL_DIRECTION_BACKWARD;\nvar SCROLL_DIRECTION_FORWARD = 1;\nexports.SCROLL_DIRECTION_FORWARD = SCROLL_DIRECTION_FORWARD;\nvar SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexports.SCROLL_DIRECTION_HORIZONTAL = SCROLL_DIRECTION_HORIZONTAL;\nvar 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\nexports.SCROLL_DIRECTION_VERTICAL = SCROLL_DIRECTION_VERTICAL;\n\nfunction 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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = defaultCellRangeRenderer;\n\nvar _types = require(\"./types\");\n\n/**\n * Default implementation of cellRangeRenderer used by Grid.\n * This renderer supports cell-caching while the user is scrolling.\n */\nfunction 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}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bpfrpt_proptype_Scroll = exports.bpfrpt_proptype_RenderedRows = exports.bpfrpt_proptype_RowRenderer = exports.bpfrpt_proptype_RowRendererParams = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar bpfrpt_proptype_RowRendererParams = process.env.NODE_ENV === 'production' ? null : {\n  \"index\": _propTypes[\"default\"].number.isRequired,\n  \"isScrolling\": _propTypes[\"default\"].bool.isRequired,\n  \"isVisible\": _propTypes[\"default\"].bool.isRequired,\n  \"key\": _propTypes[\"default\"].string.isRequired,\n  \"parent\": _propTypes[\"default\"].object.isRequired,\n  \"style\": _propTypes[\"default\"].object.isRequired\n};\nexports.bpfrpt_proptype_RowRendererParams = bpfrpt_proptype_RowRendererParams;\nvar bpfrpt_proptype_RowRenderer = process.env.NODE_ENV === 'production' ? null : _propTypes[\"default\"].func;\nexports.bpfrpt_proptype_RowRenderer = bpfrpt_proptype_RowRenderer;\nvar bpfrpt_proptype_RenderedRows = process.env.NODE_ENV === 'production' ? null : {\n  \"overscanStartIndex\": _propTypes[\"default\"].number.isRequired,\n  \"overscanStopIndex\": _propTypes[\"default\"].number.isRequired,\n  \"startIndex\": _propTypes[\"default\"].number.isRequired,\n  \"stopIndex\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_RenderedRows = bpfrpt_proptype_RenderedRows;\nvar bpfrpt_proptype_Scroll = process.env.NODE_ENV === 'production' ? null : {\n  \"clientHeight\": _propTypes[\"default\"].number.isRequired,\n  \"scrollHeight\": _propTypes[\"default\"].number.isRequired,\n  \"scrollTop\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_Scroll = bpfrpt_proptype_Scroll;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf3 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar _Grid = _interopRequireWildcard(require(\"../Grid\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\n\nvar _types = require(\"./types\");\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _class, _temp;\n\nvar List = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  (0, _inherits2[\"default\"])(List, _React$PureComponent);\n\n  function List() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    (0, _classCallCheck2[\"default\"])(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 = (0, _possibleConstructorReturn2[\"default\"])(this, (_getPrototypeOf2 = (0, _getPrototypeOf3[\"default\"])(List)).call.apply(_getPrototypeOf2, [this].concat(args)));\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"Grid\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_setRef\", function (ref) {\n      _this.Grid = ref;\n    });\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    return _this;\n  }\n\n  (0, _createClass2[\"default\"])(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 = (0, _clsx[\"default\"])('ReactVirtualized__List', className);\n      return React.createElement(_Grid[\"default\"], (0, _extends2[\"default\"])({}, 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  return List;\n}(React.PureComponent), (0, _defineProperty2[\"default\"])(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": _propTypes[\"default\"].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[\"default\"].bool.isRequired,\n\n  /** Optional CSS class name */\n  \"className\": _propTypes[\"default\"].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[\"default\"].number.isRequired,\n\n  /** Height constraint for list (determines how many actual rows are rendered) */\n  \"height\": _propTypes[\"default\"].number.isRequired,\n\n  /** Optional renderer to be used in place of rows when rowCount is 0 */\n  \"noRowsRenderer\": function noRowsRenderer() {\n    return (typeof _Grid.bpfrpt_proptype_NoContentRenderer === \"function\" ? _Grid.bpfrpt_proptype_NoContentRenderer.isRequired ? _Grid.bpfrpt_proptype_NoContentRenderer.isRequired : _Grid.bpfrpt_proptype_NoContentRenderer : _propTypes[\"default\"].shape(_Grid.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[\"default\"].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[\"default\"].func.isRequired,\n\n  /** See Grid#overscanIndicesGetter */\n  \"overscanIndicesGetter\": function overscanIndicesGetter() {\n    return (typeof _Grid.bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? _Grid.bpfrpt_proptype_OverscanIndicesGetter.isRequired ? _Grid.bpfrpt_proptype_OverscanIndicesGetter.isRequired : _Grid.bpfrpt_proptype_OverscanIndicesGetter : _propTypes[\"default\"].shape(_Grid.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[\"default\"].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 _Grid.bpfrpt_proptype_CellSize === \"function\" ? _Grid.bpfrpt_proptype_CellSize.isRequired ? _Grid.bpfrpt_proptype_CellSize.isRequired : _Grid.bpfrpt_proptype_CellSize : _propTypes[\"default\"].shape(_Grid.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 _types.bpfrpt_proptype_RowRenderer === \"function\" ? _types.bpfrpt_proptype_RowRenderer.isRequired ? _types.bpfrpt_proptype_RowRenderer.isRequired : _types.bpfrpt_proptype_RowRenderer : _propTypes[\"default\"].shape(_types.bpfrpt_proptype_RowRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in list. */\n  \"rowCount\": _propTypes[\"default\"].number.isRequired,\n\n  /** See Grid#scrollToAlignment */\n  \"scrollToAlignment\": function scrollToAlignment() {\n    return (typeof _Grid.bpfrpt_proptype_Alignment === \"function\" ? _Grid.bpfrpt_proptype_Alignment.isRequired ? _Grid.bpfrpt_proptype_Alignment.isRequired : _Grid.bpfrpt_proptype_Alignment : _propTypes[\"default\"].shape(_Grid.bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToIndex\": _propTypes[\"default\"].number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": _propTypes[\"default\"].number,\n\n  /** Optional inline style */\n  \"style\": _propTypes[\"default\"].object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": _propTypes[\"default\"].number,\n\n  /** Width of list */\n  \"width\": _propTypes[\"default\"].number.isRequired\n}), _temp);\nexports[\"default\"] = List;\n(0, _defineProperty2[\"default\"])(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: _Grid.accessibilityOverscanIndicesGetter,\n  overscanRowCount: 10,\n  scrollToAlignment: 'auto',\n  scrollToIndex: -1,\n  style: {}\n});","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;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"default\", {\n  enumerable: true,\n  get: function get() {\n    return _Grid[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"Grid\", {\n  enumerable: true,\n  get: function get() {\n    return _Grid[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"accessibilityOverscanIndicesGetter\", {\n  enumerable: true,\n  get: function get() {\n    return _accessibilityOverscanIndicesGetter[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"defaultCellRangeRenderer\", {\n  enumerable: true,\n  get: function get() {\n    return _defaultCellRangeRenderer[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"defaultOverscanIndicesGetter\", {\n  enumerable: true,\n  get: function get() {\n    return _defaultOverscanIndicesGetter[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_NoContentRenderer\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_NoContentRenderer;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_Alignment\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_Alignment;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_CellPosition\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_CellPosition;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_CellSize\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_CellSize;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_OverscanIndicesGetter\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_OverscanIndicesGetter;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_RenderedSection\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_RenderedSection;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_CellRendererParams\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_CellRendererParams;\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_Scroll\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_Scroll;\n  }\n});\n\nvar _Grid = _interopRequireDefault(require(\"./Grid\"));\n\nvar _accessibilityOverscanIndicesGetter = _interopRequireDefault(require(\"./accessibilityOverscanIndicesGetter\"));\n\nvar _defaultCellRangeRenderer = _interopRequireDefault(require(\"./defaultCellRangeRenderer\"));\n\nvar _defaultOverscanIndicesGetter = _interopRequireDefault(require(\"./defaultOverscanIndicesGetter\"));\n\nvar _types = require(\"./types\");","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = void 0;\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\n\nvar _calculateSizeAndPositionDataAndUpdateScrollOffset = _interopRequireDefault(require(\"./utils/calculateSizeAndPositionDataAndUpdateScrollOffset\"));\n\nvar _ScalingCellSizeAndPositionManager = _interopRequireDefault(require(\"./utils/ScalingCellSizeAndPositionManager\"));\n\nvar _createCallbackMemoizer = _interopRequireDefault(require(\"../utils/createCallbackMemoizer\"));\n\nvar _defaultOverscanIndicesGetter = _interopRequireWildcard(require(\"./defaultOverscanIndicesGetter\"));\n\nvar _updateScrollIndexHelper = _interopRequireDefault(require(\"./utils/updateScrollIndexHelper\"));\n\nvar _defaultCellRangeRenderer = _interopRequireDefault(require(\"./defaultCellRangeRenderer\"));\n\nvar _scrollbarSize = _interopRequireDefault(require(\"dom-helpers/scrollbarSize\"));\n\nvar _reactLifecyclesCompat = require(\"react-lifecycles-compat\");\n\nvar _requestAnimationTimeout = require(\"../utils/requestAnimationTimeout\");\n\nvar _types = require(\"./types\");\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\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) { (0, _defineProperty2[\"default\"])(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\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 */\nvar 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\nexports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = DEFAULT_SCROLLING_RESET_TIME_INTERVAL;\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  (0, _inherits2[\"default\"])(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    (0, _classCallCheck2[\"default\"])(this, Grid);\n    _this = (0, _possibleConstructorReturn2[\"default\"])(this, (0, _getPrototypeOf2[\"default\"])(Grid).call(this, props));\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_onGridRenderedMemoizer\", (0, _createCallbackMemoizer[\"default\"])());\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_onScrollMemoizer\", (0, _createCallbackMemoizer[\"default\"])(false));\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_deferredInvalidateColumnIndex\", null);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_deferredInvalidateRowIndex\", null);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_recomputeScrollLeftFlag\", false);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_recomputeScrollTopFlag\", false);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_horizontalScrollBarSize\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_verticalScrollBarSize\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_scrollbarPresenceChanged\", false);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_scrollingContainer\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_childrenToDisplay\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_columnStartIndex\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_columnStopIndex\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_rowStartIndex\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_rowStopIndex\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_renderedColumnStartIndex\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_renderedColumnStopIndex\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_renderedRowStartIndex\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_renderedRowStopIndex\", 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_initialScrollTop\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_initialScrollLeft\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_disablePointerEventsTimeoutId\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_styleCache\", {});\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_cellCache\", {});\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    var columnSizeAndPositionManager = new _ScalingCellSizeAndPositionManager[\"default\"]({\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[\"default\"]({\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: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD,\n      scrollDirectionVertical: _defaultOverscanIndicesGetter.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  (0, _createClass2[\"default\"])(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 ? _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD : _defaultOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionHorizontal;\n        var scrollDirectionVertical = scrollTop !== this.state.scrollTop ? scrollTop > this.state.scrollTop ? _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD : _defaultOverscanIndicesGetter.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 === _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD ? columnIndex <= scrollToColumn : columnIndex >= scrollToColumn);\n      this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === _defaultOverscanIndicesGetter.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        (0, _updateScrollIndexHelper[\"default\"])({\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        (0, _updateScrollIndexHelper[\"default\"])({\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        (0, _requestAnimationTimeout.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\", (0, _extends2[\"default\"])({\n        ref: this._setScrollingContainerRef\n      }, containerProps, {\n        \"aria-label\": this.props['aria-label'],\n        \"aria-readonly\": this.props['aria-readonly'],\n        className: (0, _clsx[\"default\"])('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        (0, _requestAnimationTimeout.cancelAnimationTimeout)(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = (0, _requestAnimationTimeout.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      (0, _calculateSizeAndPositionDataAndUpdateScrollOffset[\"default\"])({\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      (0, _calculateSizeAndPositionDataAndUpdateScrollOffset[\"default\"])({\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 ? _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD : _defaultOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD;\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (typeof scrollTop === 'number' && scrollTop >= 0) {\n        newState.scrollDirectionVertical = scrollTop > prevState.scrollTop ? _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD : _defaultOverscanIndicesGetter.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  return Grid;\n}(React.PureComponent), (0, _defineProperty2[\"default\"])(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": _propTypes[\"default\"].string.isRequired,\n  \"aria-readonly\": _propTypes[\"default\"].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[\"default\"].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[\"default\"].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[\"default\"].bool.isRequired,\n\n  /** Responsible for rendering a cell given an row and column index.  */\n  \"cellRenderer\": function cellRenderer() {\n    return (typeof _types.bpfrpt_proptype_CellRenderer === \"function\" ? _types.bpfrpt_proptype_CellRenderer.isRequired ? _types.bpfrpt_proptype_CellRenderer.isRequired : _types.bpfrpt_proptype_CellRenderer : _propTypes[\"default\"].shape(_types.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 _types.bpfrpt_proptype_CellRangeRenderer === \"function\" ? _types.bpfrpt_proptype_CellRangeRenderer.isRequired ? _types.bpfrpt_proptype_CellRangeRenderer.isRequired : _types.bpfrpt_proptype_CellRangeRenderer : _propTypes[\"default\"].shape(_types.bpfrpt_proptype_CellRangeRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Optional custom CSS class name to attach to root Grid element.  */\n  \"className\": _propTypes[\"default\"].string,\n\n  /** Number of columns in grid.  */\n  \"columnCount\": _propTypes[\"default\"].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 _types.bpfrpt_proptype_CellSize === \"function\" ? _types.bpfrpt_proptype_CellSize.isRequired ? _types.bpfrpt_proptype_CellSize.isRequired : _types.bpfrpt_proptype_CellSize : _propTypes[\"default\"].shape(_types.bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Unfiltered props for the Grid container. */\n  \"containerProps\": _propTypes[\"default\"].object,\n\n  /** ARIA role for the cell-container.  */\n  \"containerRole\": _propTypes[\"default\"].string.isRequired,\n\n  /** Optional inline style applied to inner cell-container */\n  \"containerStyle\": _propTypes[\"default\"].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[\"default\"].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[\"default\"].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[\"default\"].number.isRequired,\n\n  /** Exposed for testing purposes only.  */\n  \"getScrollbarSize\": _propTypes[\"default\"].func.isRequired,\n\n  /** Height of Grid; this property determines the number of visible (vs virtualized) rows.  */\n  \"height\": _propTypes[\"default\"].number.isRequired,\n\n  /** Optional custom id to attach to root Grid element.  */\n  \"id\": _propTypes[\"default\"].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[\"default\"].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[\"default\"].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 _types.bpfrpt_proptype_NoContentRenderer === \"function\" ? _types.bpfrpt_proptype_NoContentRenderer.isRequired ? _types.bpfrpt_proptype_NoContentRenderer.isRequired : _types.bpfrpt_proptype_NoContentRenderer : _propTypes[\"default\"].shape(_types.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[\"default\"].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[\"default\"].func.isRequired,\n\n  /** Callback invoked with information about the section of the Grid that was just rendered.  */\n  \"onSectionRendered\": _propTypes[\"default\"].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[\"default\"].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 _types.bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? _types.bpfrpt_proptype_OverscanIndicesGetter.isRequired ? _types.bpfrpt_proptype_OverscanIndicesGetter.isRequired : _types.bpfrpt_proptype_OverscanIndicesGetter : _propTypes[\"default\"].shape(_types.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[\"default\"].number.isRequired,\n\n  /** ARIA role for the grid element.  */\n  \"role\": _propTypes[\"default\"].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 _types.bpfrpt_proptype_CellSize === \"function\" ? _types.bpfrpt_proptype_CellSize.isRequired ? _types.bpfrpt_proptype_CellSize.isRequired : _types.bpfrpt_proptype_CellSize : _propTypes[\"default\"].shape(_types.bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in grid.  */\n  \"rowCount\": _propTypes[\"default\"].number.isRequired,\n\n  /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */\n  \"scrollingResetTimeInterval\": _propTypes[\"default\"].number.isRequired,\n\n  /** Horizontal offset. */\n  \"scrollLeft\": _propTypes[\"default\"].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 _types.bpfrpt_proptype_Alignment === \"function\" ? _types.bpfrpt_proptype_Alignment.isRequired ? _types.bpfrpt_proptype_Alignment.isRequired : _types.bpfrpt_proptype_Alignment : _propTypes[\"default\"].shape(_types.bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Column index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToColumn\": _propTypes[\"default\"].number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": _propTypes[\"default\"].number,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToRow\": _propTypes[\"default\"].number.isRequired,\n\n  /** Optional inline style */\n  \"style\": _propTypes[\"default\"].object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": _propTypes[\"default\"].number,\n\n  /** Width of Grid; this property determines the number of visible (vs virtualized) columns.  */\n  \"width\": _propTypes[\"default\"].number.isRequired\n}), _temp);\n(0, _defineProperty2[\"default\"])(Grid, \"defaultProps\", {\n  'aria-label': 'grid',\n  'aria-readonly': true,\n  autoContainerWidth: false,\n  autoHeight: false,\n  autoWidth: false,\n  cellRangeRenderer: _defaultCellRangeRenderer[\"default\"],\n  containerRole: 'rowgroup',\n  containerStyle: {},\n  estimatedColumnSize: 100,\n  estimatedRowSize: 30,\n  getScrollbarSize: _scrollbarSize[\"default\"],\n  noContentRenderer: renderNull,\n  onScroll: function onScroll() {},\n  onScrollbarPresenceChange: function onScrollbarPresenceChange() {},\n  onSectionRendered: function onSectionRendered() {},\n  overscanColumnCount: 0,\n  overscanIndicesGetter: _defaultOverscanIndicesGetter[\"default\"],\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(0, _reactLifecyclesCompat.polyfill)(Grid);\nvar _default = Grid;\nexports[\"default\"] = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = calculateSizeAndPositionDataAndUpdateScrollOffset;\n\n/**\n * Helper method that determines when to recalculate row or column metadata.\n */\nfunction 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}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar _types = require(\"../types\");\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    (0, _classCallCheck2[\"default\"])(this, CellSizeAndPositionManager);\n    (0, _defineProperty2[\"default\"])(this, \"_cellSizeAndPositionData\", {});\n    (0, _defineProperty2[\"default\"])(this, \"_lastMeasuredIndex\", -1);\n    (0, _defineProperty2[\"default\"])(this, \"_lastBatchedIndex\", -1);\n    (0, _defineProperty2[\"default\"])(this, \"_cellCount\", void 0);\n    (0, _defineProperty2[\"default\"])(this, \"_cellSizeGetter\", void 0);\n    (0, _defineProperty2[\"default\"])(this, \"_estimatedCellSize\", void 0);\n    this._cellSizeGetter = cellSizeGetter;\n    this._cellCount = cellCount;\n    this._estimatedCellSize = estimatedCellSize;\n  }\n\n  (0, _createClass2[\"default\"])(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  return CellSizeAndPositionManager;\n}();\n\nexports[\"default\"] = CellSizeAndPositionManager;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getMaxElementSize = void 0;\nvar 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\nvar getMaxElementSize = function getMaxElementSize() {\n  if (isBrowser()) {\n    if (isChrome()) {\n      return CHROME_MAX_ELEMENT_SIZE;\n    }\n  }\n\n  return DEFAULT_MAX_ELEMENT_SIZE;\n};\n\nexports.getMaxElementSize = getMaxElementSize;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = createCallbackMemoizer;\n\n/**\n * Helper utility that updates the specified callback whenever any of the specified indices have changed.\n */\nfunction 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}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = updateScrollIndexHelper;\n\nvar _ScalingCellSizeAndPositionManager = _interopRequireDefault(require(\"./ScalingCellSizeAndPositionManager.js\"));\n\nvar _types = require(\"../types\");\n\nfunction 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}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bpfrpt_proptype_AnimationTimeoutId = exports.requestAnimationTimeout = exports.cancelAnimationTimeout = void 0;\n\nvar _animationFrame = require(\"./animationFrame\");\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar bpfrpt_proptype_AnimationTimeoutId = process.env.NODE_ENV === 'production' ? null : {\n  \"id\": _propTypes[\"default\"].number.isRequired\n};\nexports.bpfrpt_proptype_AnimationTimeoutId = bpfrpt_proptype_AnimationTimeoutId;\n\nvar cancelAnimationTimeout = function cancelAnimationTimeout(frame) {\n  return (0, _animationFrame.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\n\nexports.cancelAnimationTimeout = cancelAnimationTimeout;\n\nvar 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 = (0, _animationFrame.raf)(timeout);\n    }\n  };\n\n  var frame = {\n    id: (0, _animationFrame.raf)(timeout)\n  };\n  return frame;\n};\n\nexports.requestAnimationTimeout = requestAnimationTimeout;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.caf = exports.raf = void 0;\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\nvar raf = request;\nexports.raf = raf;\nvar caf = cancel;\nexports.caf = caf;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = defaultOverscanIndicesGetter;\nexports.SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_BACKWARD = void 0;\n\nvar _types = require(\"./types\");\n\nvar SCROLL_DIRECTION_BACKWARD = -1;\nexports.SCROLL_DIRECTION_BACKWARD = SCROLL_DIRECTION_BACKWARD;\nvar SCROLL_DIRECTION_FORWARD = 1;\nexports.SCROLL_DIRECTION_FORWARD = SCROLL_DIRECTION_FORWARD;\nvar SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexports.SCROLL_DIRECTION_HORIZONTAL = SCROLL_DIRECTION_HORIZONTAL;\nvar 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\nexports.SCROLL_DIRECTION_VERTICAL = SCROLL_DIRECTION_VERTICAL;\n\nfunction 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}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf3 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _detectElementResize = _interopRequireDefault(require(\"../vendor/detectElementResize\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\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) { (0, _defineProperty2[\"default\"])(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\nvar AutoSizer = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$Component) {\n  (0, _inherits2[\"default\"])(AutoSizer, _React$Component);\n\n  function AutoSizer() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    (0, _classCallCheck2[\"default\"])(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 = (0, _possibleConstructorReturn2[\"default\"])(this, (_getPrototypeOf2 = (0, _getPrototypeOf3[\"default\"])(AutoSizer)).call.apply(_getPrototypeOf2, [this].concat(args)));\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"state\", {\n      height: _this.props.defaultHeight || 0,\n      width: _this.props.defaultWidth || 0\n    });\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_parentNode\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_autoSizer\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_window\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_detectElementResize\", void 0);\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_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    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_setRef\", function (autoSizer) {\n      _this._autoSizer = autoSizer;\n    });\n    return _this;\n  }\n\n  (0, _createClass2[\"default\"])(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 = (0, _detectElementResize[\"default\"])(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  return AutoSizer;\n}(React.Component), (0, _defineProperty2[\"default\"])(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  /** Function responsible for rendering children.*/\n  \"children\": _propTypes[\"default\"].func.isRequired,\n\n  /** Optional custom CSS class name to attach to root AutoSizer element.  */\n  \"className\": _propTypes[\"default\"].string,\n\n  /** Default height to use for initial render; useful for SSR */\n  \"defaultHeight\": _propTypes[\"default\"].number,\n\n  /** Default width to use for initial render; useful for SSR */\n  \"defaultWidth\": _propTypes[\"default\"].number,\n\n  /** Disable dynamic :height property */\n  \"disableHeight\": _propTypes[\"default\"].bool.isRequired,\n\n  /** Disable dynamic :width property */\n  \"disableWidth\": _propTypes[\"default\"].bool.isRequired,\n\n  /** Nonce of the inlined stylesheet for Content Security Policy */\n  \"nonce\": _propTypes[\"default\"].string,\n\n  /** Callback to be invoked on-resize */\n  \"onResize\": _propTypes[\"default\"].func.isRequired,\n\n  /** Optional inline style */\n  \"style\": _propTypes[\"default\"].object\n}), _temp);\nexports[\"default\"] = AutoSizer;\n(0, _defineProperty2[\"default\"])(AutoSizer, \"defaultProps\", {\n  onResize: function onResize() {},\n  disableHeight: false,\n  disableWidth: false,\n  style: {}\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = createDetectElementResize;\n\n/**\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 **/\nfunction 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}","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}","function toVal(mix) {\n\tvar k, y, str='';\n\n\tif (typeof mix === 'string' || typeof mix === 'number') {\n\t\tstr += mix;\n\t} else if (typeof mix === 'object') {\n\t\tif (Array.isArray(mix)) {\n\t\t\tfor (k=0; k < mix.length; k++) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tif (y = toVal(mix[k])) {\n\t\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\t\tstr += y;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (k in mix) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\tstr += k;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn str;\n}\n\nexport default function () {\n\tvar i=0, tmp, x, str='';\n\twhile (i < arguments.length) {\n\t\tif (tmp = arguments[i++]) {\n\t\t\tif (x = toVal(tmp)) {\n\t\t\t\tstr && (str += ' ');\n\t\t\t\tstr += x\n\t\t\t}\n\t\t}\n\t}\n\treturn str;\n}\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"default\", {\n  enumerable: true,\n  get: function get() {\n    return _List[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"List\", {\n  enumerable: true,\n  get: function get() {\n    return _List[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"bpfrpt_proptype_RowRendererParams\", {\n  enumerable: true,\n  get: function get() {\n    return _types.bpfrpt_proptype_RowRendererParams;\n  }\n});\n\nvar _List = _interopRequireDefault(require(\"./List\"));\n\nvar _types = require(\"./types\");","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"default\", {\n  enumerable: true,\n  get: function get() {\n    return _AutoSizer[\"default\"];\n  }\n});\nObject.defineProperty(exports, \"AutoSizer\", {\n  enumerable: true,\n  get: function get() {\n    return _AutoSizer[\"default\"];\n  }\n});\n\nvar _AutoSizer = _interopRequireDefault(require(\"./AutoSizer\"));"],"sourceRoot":""}