{"version":3,"sources":["webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/set-interval.js","webpack:///./node_modules/core-js/modules/es.string.link.js","webpack:///./node_modules/react-virtualized-auto-sizer/dist/index.esm.js","webpack:///./node_modules/react-router-dom/esm/react-router-dom.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/core-js-pure/stable/set-interval.js","webpack:///./node_modules/raf/index.js","webpack:///./node_modules/shallowequal/index.js","webpack:///./node_modules/classnames/index.js","webpack:///./node_modules/performance-now/lib/performance-now.js","webpack:///./node_modules/memoize-one/dist/memoize-one.esm.js","webpack:///./node_modules/react-window/dist/index.esm.js"],"names":["module","exports","$","createHTML","target","proto","forced","forcedStringHTMLMethod","link","url","this","createDetectElementResize","nonce","_window","window","self","global","cancel","raf","attachEvent","document","requestFrame","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","fn","setTimeout","cancelFrame","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","clearTimeout","id","resetTriggers","element","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","scrollLeft","scrollWidth","scrollTop","scrollHeight","style","width","offsetWidth","height","offsetHeight","scrollListener","e","className","indexOf","__resizeRAF__","__resizeLast__","checkTriggers","__resizeListeners__","forEach","call","animation","keyframeprefix","animationstartevent","domPrefixes","split","startEvents","elm","createElement","undefined","animationName","i","length","toLowerCase","animationKeyframes","animationStyle","addResizeListener","doc","ownerDocument","elementStyle","getComputedStyle","position","getElementById","css","head","getElementsByTagName","type","setAttribute","styleSheet","cssText","appendChild","createTextNode","createStyles","innerHTML","addEventListener","__animationListener__","push","removeResizeListener","detachEvent","splice","removeEventListener","removeChild","classCallCheck","instance","Constructor","TypeError","createClass","defineProperties","props","descriptor","enumerable","configurable","writable","Object","defineProperty","key","protoProps","staticProps","prototype","_extends","assign","arguments","source","hasOwnProperty","possibleConstructorReturn","ReferenceError","AutoSizer","_React$PureComponent","_ref","_temp","_this","_len","args","Array","_key","__proto__","getPrototypeOf","apply","concat","state","defaultHeight","defaultWidth","_onResize","_this$props","disableHeight","disableWidth","onResize","_parentNode","_height","_width","_style","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","newHeight","newWidth","setState","_setRef","autoSizer","_autoSizer","subClass","superClass","create","constructor","value","setPrototypeOf","inherits","parentNode","defaultView","HTMLElement","_detectElementResize","_props","children","_state","outerStyle","overflow","childParams","bailoutOnChildren","ref","defaultProps","BrowserRouter","_React$Component","history","render","Component","resolveToLocation","to","currentLocation","normalizeToLocation","forwardRefShim","C","forwardRef","LinkAnchor","forwardedRef","innerRef","navigate","_onClick","onClick","rest","event","ex","preventDefault","defaultPrevented","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","Link","_ref2","_ref2$component","component","replace","Consumer","context","location","href","createHref","forwardRefShim$1","forwardRef$1","_ref$ariaCurrent","ariaCurrent","_ref$activeClassName","activeClassName","activeStyle","classNameProp","exact","isActiveProp","isActive","locationProp","sensitive","strict","styleProp","toLocation","path","pathname","escapedPath","match","classnames","filter","join","joinClassnames","MapShim","Map","getIndex","arr","result","some","entry","index","class_1","__entries__","get","set","delete","entries","has","clear","callback","ctx","_i","_a","isBrowser","global$1","Math","Function","requestAnimationFrame$1","bind","Date","now","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","addObserver","observer","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","gatherActive","hasActive","broadcastActive","observe","attributes","childList","characterData","subtree","disconnect","_b","propertyName","getInstance","instance_","defineConfigurable","keys","getWindowOf","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","reduce","size","getHTMLElementContentRect","clientWidth","clientHeight","paddings","positions_1","getPaddings","horizPad","left","right","vertPad","top","bottom","boxSizing","round","documentElement","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","getBBox","getContentRect","bbox","getSVGContentRect","x","y","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","rect","broadcastRect","ResizeObserverEntry","rectInit","Constr","contentRect","DOMRectReadOnly","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","observation","map","WeakMap","ResizeObserver","method","setInterval","root","vendors","suffix","caf","last","queue","_now","next","max","cp","slice","cancelled","handle","polyfill","object","objA","objB","compare","compareContext","ret","keysA","keysB","bHasOwnProperty","idx","valueA","valueB","hasOwn","classNames","classes","arg","argType","isArray","inner","default","getNanoSeconds","hrtime","loadTime","moduleLoadTime","nodeLoadTime","upTime","performance","process","hr","uptime","getTime","areInputsEqual","newInputs","lastInputs","resultFn","isEqual","lastThis","lastResult","lastArgs","calledOnce","newArgs","cancelTimeout","timeoutID","requestTimeout","start","tick","cachedRTLResult","getRTLOffsetType","recalculate","outerDiv","direction","innerDiv","innerStyle","body","defaultItemKey$1","data","createListComponent","_class","getItemOffset","getEstimatedTotalSize","getItemSize","getOffsetForIndexAndAlignment","getStartIndexForOffset","getStopIndexForStartIndex","initInstanceProps","shouldResetStyleCacheOnItemSizeChange","validateProps","_PureComponent","List","_instanceProps","_outerRef","_resetIsScrollingTimeoutId","isScrolling","scrollDirection","scrollOffset","initialScrollOffset","scrollUpdateWasRequested","_callOnItemsRendered","overscanStartIndex","overscanStopIndex","visibleStartIndex","visibleStopIndex","onItemsRendered","_callOnScroll","onScroll","_getItemStyle","itemSize","layout","itemStyleCache","_getItemStyleCache","_offset","isHorizontal","isRtl","offsetHorizontal","_","__","___","_onScrollHorizontal","_event$currentTarget","currentTarget","prevState","min","_resetIsScrollingDebounced","_onScrollVertical","_event$currentTarget2","_outerRefSetter","outerRef","current","_resetIsScrolling","getDerivedStateFromProps","nextProps","validateSharedProps$1","_proto","scrollTo","scrollToItem","align","itemCount","componentDidMount","_this$props2","_callPropsCallbacks","componentDidUpdate","_this$props3","_this$state","componentWillUnmount","_this$props4","innerElementType","innerTagName","itemData","_this$props4$itemKey","itemKey","outerElementType","outerTagName","useIsScrolling","_this$_getRangeToRend","_getRangeToRender","startIndex","stopIndex","items","_index","estimatedTotalSize","WebkitOverflowScrolling","willChange","pointerEvents","_this$_getRangeToRend2","_overscanStartIndex","_overscanStopIndex","_visibleStartIndex","_visibleStopIndex","_this$state2","_scrollDirection","_scrollOffset","_scrollUpdateWasRequested","_this$props5","overscanCount","_this$state3","overscanBackward","overscanForward","_ref3","FixedSizeList","_ref4","lastItemOffset","maxOffset","minOffset","middleOffset","ceil","floor","_ref5","offset","_ref6","numVisibleItems","_ref7"],"mappings":"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","file":"script/chunks/chunk.11.ca83e9be88.js","sourcesContent":["module.exports = require(\"core-js-pure/stable/set-interval\");","'use strict';\nvar $ = require('../internals/export');\nvar createHTML = require('../internals/create-html');\nvar forcedStringHTMLMethod = require('../internals/string-html-forced');\n\n// `String.prototype.link` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.link\n$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, {\n  link: function link(url) {\n    return createHTML(this, 'a', 'href', url);\n  }\n});\n","import { createElement, PureComponent } from 'react';\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 **/\n\nfunction createDetectElementResize(nonce) {\n  // Check `document` and `window` in case of server-side rendering\n  var _window;\n  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 document !== 'undefined' && 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      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.indexOf('contract-trigger') < 0 && e.target.className.indexOf('expand-trigger') < 0) {\n        return;\n      }\n\n      var element = this;\n      resetTriggers(this);\n      if (this.__resizeRAF__) {\n        cancelFrame(this.__resizeRAF__);\n      }\n      this.__resizeRAF__ = requestFrame(function () {\n        if (checkTriggers(element)) {\n          element.__resizeLast__.width = element.offsetWidth;\n          element.__resizeLast__.height = element.offsetHeight;\n          element.__resizeListeners__.forEach(function (fn) {\n            fn.call(element, e);\n          });\n        }\n      });\n    };\n\n    /* Detect CSS Animations support to detect element display/re-attach */\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 = document.createElement('fakeelement');\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\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\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        var elementStyle = _window.getComputedStyle(element);\n        if (elementStyle && elementStyle.position == 'static') {\n          element.style.position = 'relative';\n        }\n        createStyles(doc);\n        element.__resizeLast__ = {};\n        element.__resizeListeners__ = [];\n        (element.__resizeTriggers__ = doc.createElement('div')).className = 'resize-triggers';\n        element.__resizeTriggers__.innerHTML = '<div class=\"expand-trigger\"><div></div></div>' + '<div class=\"contract-trigger\"></div>';\n        element.appendChild(element.__resizeTriggers__);\n        resetTriggers(element);\n        element.addEventListener('scroll', scrollListener, true);\n\n        /* Listen for a css animation to detect element display/re-attach */\n        if (animationstartevent) {\n          element.__resizeTriggers__.__animationListener__ = function animationListener(e) {\n            if (e.animationName == animationName) {\n              resetTriggers(element);\n            }\n          };\n          element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\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      if (!element.__resizeListeners__.length) {\n        element.removeEventListener('scroll', scrollListener, true);\n        if (element.__resizeTriggers__.__animationListener__) {\n          element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\n          element.__resizeTriggers__.__animationListener__ = null;\n        }\n        try {\n          element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);\n        } catch (e) {\n          // Preact compat; see developit/preact-compat/issues/228\n        }\n      }\n    }\n  };\n\n  return {\n    addResizeListener: addResizeListener,\n    removeResizeListener: removeResizeListener\n  };\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar AutoSizer = function (_React$PureComponent) {\n  inherits(AutoSizer, _React$PureComponent);\n\n  function AutoSizer() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    classCallCheck(this, AutoSizer);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = possibleConstructorReturn(this, (_ref = AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      height: _this.props.defaultHeight || 0,\n      width: _this.props.defaultWidth || 0\n    }, _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\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\n        var _height = _this._parentNode.offsetHeight || 0;\n        var _width = _this._parentNode.offsetWidth || 0;\n\n        var _style = window.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\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({ height: _height, width: _width });\n        }\n      }\n    }, _this._setRef = function (autoSizer) {\n      _this._autoSizer = autoSizer;\n    }, _temp), possibleConstructorReturn(_this, _ret);\n  }\n\n  createClass(AutoSizer, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var nonce = this.props.nonce;\n\n      if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {\n        // Delay access of parentNode until mount.\n        // This handles edge-cases where the component has already been unmounted before its ref has been set,\n        // As well as libraries like react-lite which have a slightly different lifecycle.\n        this._parentNode = this._autoSizer.parentNode;\n\n        // Defer requiring resize handler in order to support server-side rendering.\n        // See issue #41\n        this._detectElementResize = createDetectElementResize(nonce);\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 _props = this.props,\n          children = _props.children,\n          className = _props.className,\n          disableHeight = _props.disableHeight,\n          disableWidth = _props.disableWidth,\n          style = _props.style;\n      var _state = this.state,\n          height = _state.height,\n          width = _state.width;\n\n      // 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 = { overflow: 'visible' };\n      var childParams = {};\n\n      // Avoid rendering children before the initial measurements have been collected.\n      // At best this would just be wasting cycles.\n      var bailoutOnChildren = false;\n\n      if (!disableHeight) {\n        if (height === 0) {\n          bailoutOnChildren = true;\n        }\n        outerStyle.height = 0;\n        childParams.height = height;\n      }\n\n      if (!disableWidth) {\n        if (width === 0) {\n          bailoutOnChildren = true;\n        }\n        outerStyle.width = 0;\n        childParams.width = width;\n      }\n\n      return createElement(\n        'div',\n        {\n          className: className,\n          ref: this._setRef,\n          style: _extends({}, outerStyle, style) },\n        !bailoutOnChildren && children(childParams)\n      );\n    }\n  }]);\n  return AutoSizer;\n}(PureComponent);\n\nAutoSizer.defaultProps = {\n  onResize: function onResize() {},\n  disableHeight: false,\n  disableWidth: false,\n  style: {}\n};\n\nexport default AutoSizer;\n","import { Router, __RouterContext, matchPath } from 'react-router';\nexport { MemoryRouter, Prompt, Redirect, Route, Router, StaticRouter, Switch, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter } from 'react-router';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React from 'react';\nimport { createBrowserHistory, createHashHistory, createLocation } from 'history';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport invariant from 'tiny-invariant';\n\n/**\n * The public API for a <Router> that uses HTML5 history.\n */\n\nvar BrowserRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(BrowserRouter, _React$Component);\n\n  function BrowserRouter() {\n    var _this;\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 = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createBrowserHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = BrowserRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return BrowserRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  BrowserRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    forceRefresh: PropTypes.bool,\n    getUserConfirmation: PropTypes.func,\n    keyLength: PropTypes.number\n  };\n\n  BrowserRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<BrowserRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { BrowserRouter as Router }`.\") : void 0;\n  };\n}\n\n/**\n * The public API for a <Router> that uses window.location.hash.\n */\n\nvar HashRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(HashRouter, _React$Component);\n\n  function HashRouter() {\n    var _this;\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 = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createHashHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = HashRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return HashRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  HashRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    getUserConfirmation: PropTypes.func,\n    hashType: PropTypes.oneOf([\"hashbang\", \"noslash\", \"slash\"])\n  };\n\n  HashRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<HashRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { HashRouter as Router }`.\") : void 0;\n  };\n}\n\nvar resolveToLocation = function resolveToLocation(to, currentLocation) {\n  return typeof to === \"function\" ? to(currentLocation) : to;\n};\nvar normalizeToLocation = function normalizeToLocation(to, currentLocation) {\n  return typeof to === \"string\" ? createLocation(to, null, null, currentLocation) : to;\n};\n\nvar forwardRefShim = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef = React.forwardRef;\n\nif (typeof forwardRef === \"undefined\") {\n  forwardRef = forwardRefShim;\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nvar LinkAnchor = forwardRef(function (_ref, forwardedRef) {\n  var innerRef = _ref.innerRef,\n      navigate = _ref.navigate,\n      _onClick = _ref.onClick,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"innerRef\", \"navigate\", \"onClick\"]);\n\n  var target = rest.target;\n\n  var props = _extends({}, rest, {\n    onClick: function onClick(event) {\n      try {\n        if (_onClick) _onClick(event);\n      } catch (ex) {\n        event.preventDefault();\n        throw ex;\n      }\n\n      if (!event.defaultPrevented && // onClick prevented default\n      event.button === 0 && ( // ignore everything but left clicks\n      !target || target === \"_self\") && // let browser handle \"target=_blank\" etc.\n      !isModifiedEvent(event) // ignore clicks with modifier keys\n      ) {\n          event.preventDefault();\n          navigate();\n        }\n    }\n  }); // React 15 compat\n\n\n  if (forwardRefShim !== forwardRef) {\n    props.ref = forwardedRef || innerRef;\n  } else {\n    props.ref = innerRef;\n  }\n  /* eslint-disable-next-line jsx-a11y/anchor-has-content */\n\n\n  return React.createElement(\"a\", props);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  LinkAnchor.displayName = \"LinkAnchor\";\n}\n/**\n * The public API for rendering a history-aware <a>.\n */\n\n\nvar Link = forwardRef(function (_ref2, forwardedRef) {\n  var _ref2$component = _ref2.component,\n      component = _ref2$component === void 0 ? LinkAnchor : _ref2$component,\n      replace = _ref2.replace,\n      to = _ref2.to,\n      innerRef = _ref2.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref2, [\"component\", \"replace\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Link> outside a <Router>\") : invariant(false) : void 0;\n    var history = context.history;\n    var location = normalizeToLocation(resolveToLocation(to, context.location), context.location);\n    var href = location ? history.createHref(location) : \"\";\n\n    var props = _extends({}, rest, {\n      href: href,\n      navigate: function navigate() {\n        var location = resolveToLocation(to, context.location);\n        var method = replace ? history.replace : history.push;\n        method(location);\n      }\n    }); // React 15 compat\n\n\n    if (forwardRefShim !== forwardRef) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(component, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  var toType = PropTypes.oneOfType([PropTypes.string, PropTypes.object, PropTypes.func]);\n  var refType = PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.shape({\n    current: PropTypes.any\n  })]);\n  Link.displayName = \"Link\";\n  Link.propTypes = {\n    innerRef: refType,\n    onClick: PropTypes.func,\n    replace: PropTypes.bool,\n    target: PropTypes.string,\n    to: toType.isRequired\n  };\n}\n\nvar forwardRefShim$1 = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef$1 = React.forwardRef;\n\nif (typeof forwardRef$1 === \"undefined\") {\n  forwardRef$1 = forwardRefShim$1;\n}\n\nfunction joinClassnames() {\n  for (var _len = arguments.length, classnames = new Array(_len), _key = 0; _key < _len; _key++) {\n    classnames[_key] = arguments[_key];\n  }\n\n  return classnames.filter(function (i) {\n    return i;\n  }).join(\" \");\n}\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\n\n\nvar NavLink = forwardRef$1(function (_ref, forwardedRef) {\n  var _ref$ariaCurrent = _ref[\"aria-current\"],\n      ariaCurrent = _ref$ariaCurrent === void 0 ? \"page\" : _ref$ariaCurrent,\n      _ref$activeClassName = _ref.activeClassName,\n      activeClassName = _ref$activeClassName === void 0 ? \"active\" : _ref$activeClassName,\n      activeStyle = _ref.activeStyle,\n      classNameProp = _ref.className,\n      exact = _ref.exact,\n      isActiveProp = _ref.isActive,\n      locationProp = _ref.location,\n      sensitive = _ref.sensitive,\n      strict = _ref.strict,\n      styleProp = _ref.style,\n      to = _ref.to,\n      innerRef = _ref.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"aria-current\", \"activeClassName\", \"activeStyle\", \"className\", \"exact\", \"isActive\", \"location\", \"sensitive\", \"strict\", \"style\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <NavLink> outside a <Router>\") : invariant(false) : void 0;\n    var currentLocation = locationProp || context.location;\n    var toLocation = normalizeToLocation(resolveToLocation(to, currentLocation), currentLocation);\n    var path = toLocation.pathname; // Regex taken from: https://github.com/pillarjs/path-to-regexp/blob/master/index.js#L202\n\n    var escapedPath = path && path.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n    var match = escapedPath ? matchPath(currentLocation.pathname, {\n      path: escapedPath,\n      exact: exact,\n      sensitive: sensitive,\n      strict: strict\n    }) : null;\n    var isActive = !!(isActiveProp ? isActiveProp(match, currentLocation) : match);\n    var className = isActive ? joinClassnames(classNameProp, activeClassName) : classNameProp;\n    var style = isActive ? _extends({}, styleProp, {}, activeStyle) : styleProp;\n\n    var props = _extends({\n      \"aria-current\": isActive && ariaCurrent || null,\n      className: className,\n      style: style,\n      to: toLocation\n    }, rest); // React 15 compat\n\n\n    if (forwardRefShim$1 !== forwardRef$1) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(Link, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n  var ariaCurrentType = PropTypes.oneOf([\"page\", \"step\", \"location\", \"date\", \"time\", \"true\"]);\n  NavLink.propTypes = _extends({}, Link.propTypes, {\n    \"aria-current\": ariaCurrentType,\n    activeClassName: PropTypes.string,\n    activeStyle: PropTypes.object,\n    className: PropTypes.string,\n    exact: PropTypes.bool,\n    isActive: PropTypes.func,\n    location: PropTypes.object,\n    sensitive: PropTypes.bool,\n    strict: PropTypes.bool,\n    style: PropTypes.object\n  });\n}\n\nexport { BrowserRouter, HashRouter, Link, NavLink };\n//# sourceMappingURL=react-router-dom.js.map\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","require('../modules/web.timers');\nvar path = require('../internals/path');\n\nmodule.exports = path.setInterval;\n","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n","//\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n\n  if (ret !== void 0) {\n    return !!ret;\n  }\n\n  if (objA === objB) {\n    return true;\n  }\n\n  if (typeof objA !== \"object\" || !objA || typeof objB !== \"object\" || !objB) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n\n  // Test for A's keys different from B.\n  for (var idx = 0; idx < keysA.length; idx++) {\n    var key = keysA[idx];\n\n    if (!bHasOwnProperty(key)) {\n      return false;\n    }\n\n    var valueA = objA[key];\n    var valueB = objB[key];\n\n    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n\n    if (ret === false || (ret === void 0 && valueA !== valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n","function areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (newInputs[i] !== lastInputs[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var lastThis;\n    var lastArgs = [];\n    var lastResult;\n    var calledOnce = false;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n            return lastResult;\n        }\n        lastResult = resultFn.apply(this, newArgs);\n        calledOnce = true;\n        lastThis = this;\n        lastArgs = newArgs;\n        return lastResult;\n    }\n    return memoized;\n}\n\nexport default memoizeOne;\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\nimport memoizeOne from 'memoize-one';\nimport { createElement, PureComponent } from 'react';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\n\n// Animation frame based implementation of setTimeout.\n// Inspired by Joe Lambert, https://gist.github.com/joelambert/1002116#file-requesttimeout-js\nvar hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';\nvar now = hasNativePerformanceNow ? function () {\n  return performance.now();\n} : function () {\n  return Date.now();\n};\nfunction cancelTimeout(timeoutID) {\n  cancelAnimationFrame(timeoutID.id);\n}\nfunction requestTimeout(callback, delay) {\n  var start = now();\n\n  function tick() {\n    if (now() - start >= delay) {\n      callback.call(null);\n    } else {\n      timeoutID.id = requestAnimationFrame(tick);\n    }\n  }\n\n  var timeoutID = {\n    id: requestAnimationFrame(tick)\n  };\n  return timeoutID;\n}\n\nvar size = -1; // This utility copied from \"dom-helpers\" package.\n\nfunction getScrollbarSize(recalculate) {\n  if (recalculate === void 0) {\n    recalculate = false;\n  }\n\n  if (size === -1 || recalculate) {\n    var div = document.createElement('div');\n    var style = div.style;\n    style.width = '50px';\n    style.height = '50px';\n    style.overflow = 'scroll';\n    document.body.appendChild(div);\n    size = div.offsetWidth - div.clientWidth;\n    document.body.removeChild(div);\n  }\n\n  return size;\n}\nvar cachedRTLResult = null; // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n// Chrome does not seem to adhere; its scrollLeft values are positive (measured relative to the left).\n// Safari's elastic bounce makes detecting this even more complicated wrt potential false positives.\n// The safest way to check this is to intentionally set a negative offset,\n// and then verify that the subsequent \"scroll\" event matches the negative offset.\n// If it does not match, then we can assume a non-standard RTL scroll implementation.\n\nfunction getRTLOffsetType(recalculate) {\n  if (recalculate === void 0) {\n    recalculate = false;\n  }\n\n  if (cachedRTLResult === null || recalculate) {\n    var outerDiv = document.createElement('div');\n    var outerStyle = outerDiv.style;\n    outerStyle.width = '50px';\n    outerStyle.height = '50px';\n    outerStyle.overflow = 'scroll';\n    outerStyle.direction = 'rtl';\n    var innerDiv = document.createElement('div');\n    var innerStyle = innerDiv.style;\n    innerStyle.width = '100px';\n    innerStyle.height = '100px';\n    outerDiv.appendChild(innerDiv);\n    document.body.appendChild(outerDiv);\n\n    if (outerDiv.scrollLeft > 0) {\n      cachedRTLResult = 'positive-descending';\n    } else {\n      outerDiv.scrollLeft = 1;\n\n      if (outerDiv.scrollLeft === 0) {\n        cachedRTLResult = 'negative';\n      } else {\n        cachedRTLResult = 'positive-ascending';\n      }\n    }\n\n    document.body.removeChild(outerDiv);\n    return cachedRTLResult;\n  }\n\n  return cachedRTLResult;\n}\n\nvar IS_SCROLLING_DEBOUNCE_INTERVAL = 150;\n\nvar defaultItemKey = function defaultItemKey(_ref) {\n  var columnIndex = _ref.columnIndex,\n      data = _ref.data,\n      rowIndex = _ref.rowIndex;\n  return rowIndex + \":\" + columnIndex;\n}; // In DEV mode, this Set helps us only log a warning once per component instance.\n// This avoids spamming the console every time a render happens.\n\n\nvar devWarningsOverscanCount = null;\nvar devWarningsOverscanRowsColumnsCount = null;\nvar devWarningsTagName = null;\n\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsOverscanCount =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsOverscanRowsColumnsCount =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsTagName =\n    /*#__PURE__*/\n    new WeakSet();\n  }\n}\n\nfunction createGridComponent(_ref2) {\n  var _class, _temp;\n\n  var getColumnOffset = _ref2.getColumnOffset,\n      getColumnStartIndexForOffset = _ref2.getColumnStartIndexForOffset,\n      getColumnStopIndexForStartIndex = _ref2.getColumnStopIndexForStartIndex,\n      getColumnWidth = _ref2.getColumnWidth,\n      getEstimatedTotalHeight = _ref2.getEstimatedTotalHeight,\n      getEstimatedTotalWidth = _ref2.getEstimatedTotalWidth,\n      getOffsetForColumnAndAlignment = _ref2.getOffsetForColumnAndAlignment,\n      getOffsetForRowAndAlignment = _ref2.getOffsetForRowAndAlignment,\n      getRowHeight = _ref2.getRowHeight,\n      getRowOffset = _ref2.getRowOffset,\n      getRowStartIndexForOffset = _ref2.getRowStartIndexForOffset,\n      getRowStopIndexForStartIndex = _ref2.getRowStopIndexForStartIndex,\n      initInstanceProps = _ref2.initInstanceProps,\n      shouldResetStyleCacheOnItemSizeChange = _ref2.shouldResetStyleCacheOnItemSizeChange,\n      validateProps = _ref2.validateProps;\n  return _temp = _class =\n  /*#__PURE__*/\n  function (_PureComponent) {\n    _inheritsLoose(Grid, _PureComponent);\n\n    // Always use explicit constructor for React components.\n    // It produces less code after transpilation. (#26)\n    // eslint-disable-next-line no-useless-constructor\n    function Grid(props) {\n      var _this;\n\n      _this = _PureComponent.call(this, props) || this;\n      _this._instanceProps = initInstanceProps(_this.props, _assertThisInitialized(_assertThisInitialized(_this)));\n      _this._resetIsScrollingTimeoutId = null;\n      _this._outerRef = void 0;\n      _this.state = {\n        instance: _assertThisInitialized(_assertThisInitialized(_this)),\n        isScrolling: false,\n        horizontalScrollDirection: 'forward',\n        scrollLeft: typeof _this.props.initialScrollLeft === 'number' ? _this.props.initialScrollLeft : 0,\n        scrollTop: typeof _this.props.initialScrollTop === 'number' ? _this.props.initialScrollTop : 0,\n        scrollUpdateWasRequested: false,\n        verticalScrollDirection: 'forward'\n      };\n      _this._callOnItemsRendered = void 0;\n      _this._callOnItemsRendered = memoizeOne(function (overscanColumnStartIndex, overscanColumnStopIndex, overscanRowStartIndex, overscanRowStopIndex, visibleColumnStartIndex, visibleColumnStopIndex, visibleRowStartIndex, visibleRowStopIndex) {\n        return _this.props.onItemsRendered({\n          overscanColumnStartIndex: overscanColumnStartIndex,\n          overscanColumnStopIndex: overscanColumnStopIndex,\n          overscanRowStartIndex: overscanRowStartIndex,\n          overscanRowStopIndex: overscanRowStopIndex,\n          visibleColumnStartIndex: visibleColumnStartIndex,\n          visibleColumnStopIndex: visibleColumnStopIndex,\n          visibleRowStartIndex: visibleRowStartIndex,\n          visibleRowStopIndex: visibleRowStopIndex\n        });\n      });\n      _this._callOnScroll = void 0;\n      _this._callOnScroll = memoizeOne(function (scrollLeft, scrollTop, horizontalScrollDirection, verticalScrollDirection, scrollUpdateWasRequested) {\n        return _this.props.onScroll({\n          horizontalScrollDirection: horizontalScrollDirection,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          verticalScrollDirection: verticalScrollDirection,\n          scrollUpdateWasRequested: scrollUpdateWasRequested\n        });\n      });\n      _this._getItemStyle = void 0;\n\n      _this._getItemStyle = function (rowIndex, columnIndex) {\n        var _this$props = _this.props,\n            columnWidth = _this$props.columnWidth,\n            direction = _this$props.direction,\n            rowHeight = _this$props.rowHeight;\n\n        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && columnWidth, shouldResetStyleCacheOnItemSizeChange && direction, shouldResetStyleCacheOnItemSizeChange && rowHeight);\n\n        var key = rowIndex + \":\" + columnIndex;\n        var style;\n\n        if (itemStyleCache.hasOwnProperty(key)) {\n          style = itemStyleCache[key];\n        } else {\n          var _offset = getColumnOffset(_this.props, columnIndex, _this._instanceProps);\n\n          var isRtl = direction === 'rtl';\n          itemStyleCache[key] = style = {\n            position: 'absolute',\n            left: isRtl ? undefined : _offset,\n            right: isRtl ? _offset : undefined,\n            top: getRowOffset(_this.props, rowIndex, _this._instanceProps),\n            height: getRowHeight(_this.props, rowIndex, _this._instanceProps),\n            width: getColumnWidth(_this.props, columnIndex, _this._instanceProps)\n          };\n        }\n\n        return style;\n      };\n\n      _this._getItemStyleCache = void 0;\n      _this._getItemStyleCache = memoizeOne(function (_, __, ___) {\n        return {};\n      });\n\n      _this._onScroll = function (event) {\n        var _event$currentTarget = event.currentTarget,\n            clientHeight = _event$currentTarget.clientHeight,\n            clientWidth = _event$currentTarget.clientWidth,\n            scrollLeft = _event$currentTarget.scrollLeft,\n            scrollTop = _event$currentTarget.scrollTop,\n            scrollHeight = _event$currentTarget.scrollHeight,\n            scrollWidth = _event$currentTarget.scrollWidth;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          }\n\n          var direction = _this.props.direction; // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n          // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n          // It's also easier for this component if we convert offsets to the same format as they would be in for ltr.\n          // So the simplest solution is to determine which browser behavior we're dealing with, and convert based on it.\n\n          var calculatedScrollLeft = scrollLeft;\n\n          if (direction === 'rtl') {\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                calculatedScrollLeft = -scrollLeft;\n                break;\n\n              case 'positive-descending':\n                calculatedScrollLeft = scrollWidth - clientWidth - scrollLeft;\n                break;\n            }\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          calculatedScrollLeft = Math.max(0, Math.min(calculatedScrollLeft, scrollWidth - clientWidth));\n          var calculatedScrollTop = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));\n          return {\n            isScrolling: true,\n            horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n            scrollLeft: calculatedScrollLeft,\n            scrollTop: calculatedScrollTop,\n            verticalScrollDirection: prevState.scrollTop < scrollTop ? 'forward' : 'backward',\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._outerRefSetter = function (ref) {\n        var outerRef = _this.props.outerRef;\n        _this._outerRef = ref;\n\n        if (typeof outerRef === 'function') {\n          outerRef(ref);\n        } else if (outerRef != null && typeof outerRef === 'object' && outerRef.hasOwnProperty('current')) {\n          outerRef.current = ref;\n        }\n      };\n\n      _this._resetIsScrollingDebounced = function () {\n        if (_this._resetIsScrollingTimeoutId !== null) {\n          cancelTimeout(_this._resetIsScrollingTimeoutId);\n        }\n\n        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL);\n      };\n\n      _this._resetIsScrolling = function () {\n        _this._resetIsScrollingTimeoutId = null;\n\n        _this.setState({\n          isScrolling: false\n        }, function () {\n          // Clear style cache after state update has been committed.\n          // This way we don't break pure sCU for items that don't use isScrolling param.\n          _this._getItemStyleCache(-1);\n        });\n      };\n\n      return _this;\n    }\n\n    Grid.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      validateSharedProps(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    };\n\n    var _proto = Grid.prototype;\n\n    _proto.scrollTo = function scrollTo(_ref3) {\n      var scrollLeft = _ref3.scrollLeft,\n          scrollTop = _ref3.scrollTop;\n\n      if (scrollLeft !== undefined) {\n        scrollLeft = Math.max(0, scrollLeft);\n      }\n\n      if (scrollTop !== undefined) {\n        scrollTop = Math.max(0, scrollTop);\n      }\n\n      this.setState(function (prevState) {\n        if (scrollLeft === undefined) {\n          scrollLeft = prevState.scrollLeft;\n        }\n\n        if (scrollTop === undefined) {\n          scrollTop = prevState.scrollTop;\n        }\n\n        if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {\n          return null;\n        }\n\n        return {\n          horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          scrollUpdateWasRequested: true,\n          verticalScrollDirection: prevState.scrollTop < scrollTop ? 'forward' : 'backward'\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _proto.scrollToItem = function scrollToItem(_ref4) {\n      var _ref4$align = _ref4.align,\n          align = _ref4$align === void 0 ? 'auto' : _ref4$align,\n          columnIndex = _ref4.columnIndex,\n          rowIndex = _ref4.rowIndex;\n      var _this$props2 = this.props,\n          columnCount = _this$props2.columnCount,\n          height = _this$props2.height,\n          rowCount = _this$props2.rowCount,\n          width = _this$props2.width;\n      var _this$state = this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop;\n      var scrollbarSize = getScrollbarSize();\n\n      if (columnIndex !== undefined) {\n        columnIndex = Math.max(0, Math.min(columnIndex, columnCount - 1));\n      }\n\n      if (rowIndex !== undefined) {\n        rowIndex = Math.max(0, Math.min(rowIndex, rowCount - 1));\n      }\n\n      var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);\n      var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps); // The scrollbar size should be considered when scrolling an item into view,\n      // to ensure it's fully visible.\n      // But we only need to account for its size when it's actually visible.\n\n      var horizontalScrollbarSize = estimatedTotalWidth > width ? scrollbarSize : 0;\n      var verticalScrollbarSize = estimatedTotalHeight > height ? scrollbarSize : 0;\n      this.scrollTo({\n        scrollLeft: columnIndex !== undefined ? getOffsetForColumnAndAlignment(this.props, columnIndex, align, scrollLeft, this._instanceProps, verticalScrollbarSize) : scrollLeft,\n        scrollTop: rowIndex !== undefined ? getOffsetForRowAndAlignment(this.props, rowIndex, align, scrollTop, this._instanceProps, horizontalScrollbarSize) : scrollTop\n      });\n    };\n\n    _proto.componentDidMount = function componentDidMount() {\n      var _this$props3 = this.props,\n          initialScrollLeft = _this$props3.initialScrollLeft,\n          initialScrollTop = _this$props3.initialScrollTop;\n\n      if (this._outerRef != null) {\n        var outerRef = this._outerRef;\n\n        if (typeof initialScrollLeft === 'number') {\n          outerRef.scrollLeft = initialScrollLeft;\n        }\n\n        if (typeof initialScrollTop === 'number') {\n          outerRef.scrollTop = initialScrollTop;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate() {\n      var direction = this.props.direction;\n      var _this$state2 = this.state,\n          scrollLeft = _this$state2.scrollLeft,\n          scrollTop = _this$state2.scrollTop,\n          scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;\n\n      if (scrollUpdateWasRequested && this._outerRef != null) {\n        // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n        // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n        // So we need to determine which browser behavior we're dealing with, and mimic it.\n        var outerRef = this._outerRef;\n\n        if (direction === 'rtl') {\n          switch (getRTLOffsetType()) {\n            case 'negative':\n              outerRef.scrollLeft = -scrollLeft;\n              break;\n\n            case 'positive-ascending':\n              outerRef.scrollLeft = scrollLeft;\n              break;\n\n            default:\n              var clientWidth = outerRef.clientWidth,\n                  scrollWidth = outerRef.scrollWidth;\n              outerRef.scrollLeft = scrollWidth - clientWidth - scrollLeft;\n              break;\n          }\n        } else {\n          outerRef.scrollLeft = Math.max(0, scrollLeft);\n        }\n\n        outerRef.scrollTop = Math.max(0, scrollTop);\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    };\n\n    _proto.render = function render() {\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          className = _this$props4.className,\n          columnCount = _this$props4.columnCount,\n          direction = _this$props4.direction,\n          height = _this$props4.height,\n          innerRef = _this$props4.innerRef,\n          innerElementType = _this$props4.innerElementType,\n          innerTagName = _this$props4.innerTagName,\n          itemData = _this$props4.itemData,\n          _this$props4$itemKey = _this$props4.itemKey,\n          itemKey = _this$props4$itemKey === void 0 ? defaultItemKey : _this$props4$itemKey,\n          outerElementType = _this$props4.outerElementType,\n          outerTagName = _this$props4.outerTagName,\n          rowCount = _this$props4.rowCount,\n          style = _this$props4.style,\n          useIsScrolling = _this$props4.useIsScrolling,\n          width = _this$props4.width;\n      var isScrolling = this.state.isScrolling;\n\n      var _this$_getHorizontalR = this._getHorizontalRangeToRender(),\n          columnStartIndex = _this$_getHorizontalR[0],\n          columnStopIndex = _this$_getHorizontalR[1];\n\n      var _this$_getVerticalRan = this._getVerticalRangeToRender(),\n          rowStartIndex = _this$_getVerticalRan[0],\n          rowStopIndex = _this$_getVerticalRan[1];\n\n      var items = [];\n\n      if (columnCount > 0 && rowCount) {\n        for (var _rowIndex = rowStartIndex; _rowIndex <= rowStopIndex; _rowIndex++) {\n          for (var _columnIndex = columnStartIndex; _columnIndex <= columnStopIndex; _columnIndex++) {\n            items.push(createElement(children, {\n              columnIndex: _columnIndex,\n              data: itemData,\n              isScrolling: useIsScrolling ? isScrolling : undefined,\n              key: itemKey({\n                columnIndex: _columnIndex,\n                data: itemData,\n                rowIndex: _rowIndex\n              }),\n              rowIndex: _rowIndex,\n              style: this._getItemStyle(_rowIndex, _columnIndex)\n            }));\n          }\n        }\n      } // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n\n\n      var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);\n      var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps);\n      return createElement(outerElementType || outerTagName || 'div', {\n        className: className,\n        onScroll: this._onScroll,\n        ref: this._outerRefSetter,\n        style: _extends({\n          position: 'relative',\n          height: height,\n          width: width,\n          overflow: 'auto',\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform',\n          direction: direction\n        }, style)\n      }, createElement(innerElementType || innerTagName || 'div', {\n        children: items,\n        ref: innerRef,\n        style: {\n          height: estimatedTotalHeight,\n          pointerEvents: isScrolling ? 'none' : undefined,\n          width: estimatedTotalWidth\n        }\n      }));\n    };\n\n    _proto._callPropsCallbacks = function _callPropsCallbacks() {\n      var _this$props5 = this.props,\n          columnCount = _this$props5.columnCount,\n          onItemsRendered = _this$props5.onItemsRendered,\n          onScroll = _this$props5.onScroll,\n          rowCount = _this$props5.rowCount;\n\n      if (typeof onItemsRendered === 'function') {\n        if (columnCount > 0 && rowCount > 0) {\n          var _this$_getHorizontalR2 = this._getHorizontalRangeToRender(),\n              _overscanColumnStartIndex = _this$_getHorizontalR2[0],\n              _overscanColumnStopIndex = _this$_getHorizontalR2[1],\n              _visibleColumnStartIndex = _this$_getHorizontalR2[2],\n              _visibleColumnStopIndex = _this$_getHorizontalR2[3];\n\n          var _this$_getVerticalRan2 = this._getVerticalRangeToRender(),\n              _overscanRowStartIndex = _this$_getVerticalRan2[0],\n              _overscanRowStopIndex = _this$_getVerticalRan2[1],\n              _visibleRowStartIndex = _this$_getVerticalRan2[2],\n              _visibleRowStopIndex = _this$_getVerticalRan2[3];\n\n          this._callOnItemsRendered(_overscanColumnStartIndex, _overscanColumnStopIndex, _overscanRowStartIndex, _overscanRowStopIndex, _visibleColumnStartIndex, _visibleColumnStopIndex, _visibleRowStartIndex, _visibleRowStopIndex);\n        }\n      }\n\n      if (typeof onScroll === 'function') {\n        var _this$state3 = this.state,\n            _horizontalScrollDirection = _this$state3.horizontalScrollDirection,\n            _scrollLeft = _this$state3.scrollLeft,\n            _scrollTop = _this$state3.scrollTop,\n            _scrollUpdateWasRequested = _this$state3.scrollUpdateWasRequested,\n            _verticalScrollDirection = _this$state3.verticalScrollDirection;\n\n        this._callOnScroll(_scrollLeft, _scrollTop, _horizontalScrollDirection, _verticalScrollDirection, _scrollUpdateWasRequested);\n      }\n    }; // Lazily create and cache item styles while scrolling,\n    // So that pure component sCU will prevent re-renders.\n    // We maintain this cache, and pass a style prop rather than index,\n    // So that List can clear cached styles and force item re-render if necessary.\n\n\n    _proto._getHorizontalRangeToRender = function _getHorizontalRangeToRender() {\n      var _this$props6 = this.props,\n          columnCount = _this$props6.columnCount,\n          overscanColumnCount = _this$props6.overscanColumnCount,\n          overscanColumnsCount = _this$props6.overscanColumnsCount,\n          overscanCount = _this$props6.overscanCount,\n          rowCount = _this$props6.rowCount;\n      var _this$state4 = this.state,\n          horizontalScrollDirection = _this$state4.horizontalScrollDirection,\n          isScrolling = _this$state4.isScrolling,\n          scrollLeft = _this$state4.scrollLeft;\n      var overscanCountResolved = overscanColumnCount || overscanColumnsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getColumnStartIndexForOffset(this.props, scrollLeft, this._instanceProps);\n      var stopIndex = getColumnStopIndexForStartIndex(this.props, startIndex, scrollLeft, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || horizontalScrollDirection === 'backward' ? Math.max(1, overscanCountResolved) : 1;\n      var overscanForward = !isScrolling || horizontalScrollDirection === 'forward' ? Math.max(1, overscanCountResolved) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(columnCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    _proto._getVerticalRangeToRender = function _getVerticalRangeToRender() {\n      var _this$props7 = this.props,\n          columnCount = _this$props7.columnCount,\n          overscanCount = _this$props7.overscanCount,\n          overscanRowCount = _this$props7.overscanRowCount,\n          overscanRowsCount = _this$props7.overscanRowsCount,\n          rowCount = _this$props7.rowCount;\n      var _this$state5 = this.state,\n          isScrolling = _this$state5.isScrolling,\n          verticalScrollDirection = _this$state5.verticalScrollDirection,\n          scrollTop = _this$state5.scrollTop;\n      var overscanCountResolved = overscanRowCount || overscanRowsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getRowStartIndexForOffset(this.props, scrollTop, this._instanceProps);\n      var stopIndex = getRowStopIndexForStartIndex(this.props, startIndex, scrollTop, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || verticalScrollDirection === 'backward' ? Math.max(1, overscanCountResolved) : 1;\n      var overscanForward = !isScrolling || verticalScrollDirection === 'forward' ? Math.max(1, overscanCountResolved) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(rowCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    return Grid;\n  }(PureComponent), _class.defaultProps = {\n    direction: 'ltr',\n    itemData: undefined,\n    useIsScrolling: false\n  }, _temp;\n}\n\nvar validateSharedProps = function validateSharedProps(_ref5, _ref6) {\n  var children = _ref5.children,\n      direction = _ref5.direction,\n      height = _ref5.height,\n      innerTagName = _ref5.innerTagName,\n      outerTagName = _ref5.outerTagName,\n      overscanColumnsCount = _ref5.overscanColumnsCount,\n      overscanCount = _ref5.overscanCount,\n      overscanRowsCount = _ref5.overscanRowsCount,\n      width = _ref5.width;\n  var instance = _ref6.instance;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof overscanCount === 'number') {\n      if (devWarningsOverscanCount && !devWarningsOverscanCount.has(instance)) {\n        devWarningsOverscanCount.add(instance);\n        console.warn('The overscanCount prop has been deprecated. ' + 'Please use the overscanColumnCount and overscanRowCount props instead.');\n      }\n    }\n\n    if (typeof overscanColumnsCount === 'number' || typeof overscanRowsCount === 'number') {\n      if (devWarningsOverscanRowsColumnsCount && !devWarningsOverscanRowsColumnsCount.has(instance)) {\n        devWarningsOverscanRowsColumnsCount.add(instance);\n        console.warn('The overscanColumnsCount and overscanRowsCount props have been deprecated. ' + 'Please use the overscanColumnCount and overscanRowCount props instead.');\n      }\n    }\n\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName && !devWarningsTagName.has(instance)) {\n        devWarningsTagName.add(instance);\n        console.warn('The innerTagName and outerTagName props have been deprecated. ' + 'Please use the innerElementType and outerElementType props instead.');\n      }\n    }\n\n    if (children == null) {\n      throw Error('An invalid \"children\" prop has been specified. ' + 'Value should be a React component. ' + (\"\\\"\" + (children === null ? 'null' : typeof children) + \"\\\" was specified.\"));\n    }\n\n    switch (direction) {\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"direction\" prop has been specified. ' + 'Value should be either \"ltr\" or \"rtl\". ' + (\"\\\"\" + direction + \"\\\" was specified.\"));\n    }\n\n    if (typeof width !== 'number') {\n      throw Error('An invalid \"width\" prop has been specified. ' + 'Grids must specify a number for width. ' + (\"\\\"\" + (width === null ? 'null' : typeof width) + \"\\\" was specified.\"));\n    }\n\n    if (typeof height !== 'number') {\n      throw Error('An invalid \"height\" prop has been specified. ' + 'Grids must specify a number for height. ' + (\"\\\"\" + (height === null ? 'null' : typeof height) + \"\\\" was specified.\"));\n    }\n  }\n};\n\nvar DEFAULT_ESTIMATED_ITEM_SIZE = 50;\n\nvar getEstimatedTotalHeight = function getEstimatedTotalHeight(_ref, _ref2) {\n  var rowCount = _ref.rowCount;\n  var rowMetadataMap = _ref2.rowMetadataMap,\n      estimatedRowHeight = _ref2.estimatedRowHeight,\n      lastMeasuredRowIndex = _ref2.lastMeasuredRowIndex;\n  var totalSizeOfMeasuredRows = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredRowIndex >= rowCount) {\n    lastMeasuredRowIndex = rowCount - 1;\n  }\n\n  if (lastMeasuredRowIndex >= 0) {\n    var itemMetadata = rowMetadataMap[lastMeasuredRowIndex];\n    totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = rowCount - lastMeasuredRowIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedRowHeight;\n  return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;\n};\n\nvar getEstimatedTotalWidth = function getEstimatedTotalWidth(_ref3, _ref4) {\n  var columnCount = _ref3.columnCount;\n  var columnMetadataMap = _ref4.columnMetadataMap,\n      estimatedColumnWidth = _ref4.estimatedColumnWidth,\n      lastMeasuredColumnIndex = _ref4.lastMeasuredColumnIndex;\n  var totalSizeOfMeasuredRows = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredColumnIndex >= columnCount) {\n    lastMeasuredColumnIndex = columnCount - 1;\n  }\n\n  if (lastMeasuredColumnIndex >= 0) {\n    var itemMetadata = columnMetadataMap[lastMeasuredColumnIndex];\n    totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = columnCount - lastMeasuredColumnIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedColumnWidth;\n  return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;\n};\n\nvar getItemMetadata = function getItemMetadata(itemType, props, index, instanceProps) {\n  var itemMetadataMap, itemSize, lastMeasuredIndex;\n\n  if (itemType === 'column') {\n    itemMetadataMap = instanceProps.columnMetadataMap;\n    itemSize = props.columnWidth;\n    lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;\n  } else {\n    itemMetadataMap = instanceProps.rowMetadataMap;\n    itemSize = props.rowHeight;\n    lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;\n  }\n\n  if (index > lastMeasuredIndex) {\n    var offset = 0;\n\n    if (lastMeasuredIndex >= 0) {\n      var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n      offset = itemMetadata.offset + itemMetadata.size;\n    }\n\n    for (var i = lastMeasuredIndex + 1; i <= index; i++) {\n      var size = itemSize(i);\n      itemMetadataMap[i] = {\n        offset: offset,\n        size: size\n      };\n      offset += size;\n    }\n\n    if (itemType === 'column') {\n      instanceProps.lastMeasuredColumnIndex = index;\n    } else {\n      instanceProps.lastMeasuredRowIndex = index;\n    }\n  }\n\n  return itemMetadataMap[index];\n};\n\nvar findNearestItem = function findNearestItem(itemType, props, instanceProps, offset) {\n  var itemMetadataMap, lastMeasuredIndex;\n\n  if (itemType === 'column') {\n    itemMetadataMap = instanceProps.columnMetadataMap;\n    lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;\n  } else {\n    itemMetadataMap = instanceProps.rowMetadataMap;\n    lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;\n  }\n\n  var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;\n\n  if (lastMeasuredItemOffset >= offset) {\n    // If we've already measured items within this range just use a binary search as it's faster.\n    return findNearestItemBinarySearch(itemType, props, instanceProps, 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 items as a binary search would.\n    // The overall complexity for this approach is O(log n).\n    return findNearestItemExponentialSearch(itemType, props, instanceProps, Math.max(0, lastMeasuredIndex), offset);\n  }\n};\n\nvar findNearestItemBinarySearch = function findNearestItemBinarySearch(itemType, props, instanceProps, high, low, offset) {\n  while (low <= high) {\n    var middle = low + Math.floor((high - low) / 2);\n    var currentOffset = getItemMetadata(itemType, props, middle, instanceProps).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\nvar findNearestItemExponentialSearch = function findNearestItemExponentialSearch(itemType, props, instanceProps, index, offset) {\n  var itemCount = itemType === 'column' ? props.columnCount : props.rowCount;\n  var interval = 1;\n\n  while (index < itemCount && getItemMetadata(itemType, props, index, instanceProps).offset < offset) {\n    index += interval;\n    interval *= 2;\n  }\n\n  return findNearestItemBinarySearch(itemType, props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);\n};\n\nvar getOffsetForIndexAndAlignment = function getOffsetForIndexAndAlignment(itemType, props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n  var size = itemType === 'column' ? props.width : props.height;\n  var itemMetadata = getItemMetadata(itemType, props, index, instanceProps); // Get estimated total size after ItemMetadata is computed,\n  // To ensure it reflects actual measurements instead of just estimates.\n\n  var estimatedTotalSize = itemType === 'column' ? getEstimatedTotalWidth(props, instanceProps) : getEstimatedTotalHeight(props, instanceProps);\n  var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));\n  var minOffset = Math.max(0, itemMetadata.offset - size + scrollbarSize + itemMetadata.size);\n\n  if (align === 'smart') {\n    if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n      align = 'auto';\n    } else {\n      align = 'center';\n    }\n  }\n\n  switch (align) {\n    case 'start':\n      return maxOffset;\n\n    case 'end':\n      return minOffset;\n\n    case 'center':\n      return Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n    case 'auto':\n    default:\n      if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n        return scrollOffset;\n      } else if (minOffset > maxOffset) {\n        // Because we only take into account the scrollbar size when calculating minOffset\n        // this value can be larger than maxOffset when at the end of the list\n        return minOffset;\n      } else if (scrollOffset < minOffset) {\n        return minOffset;\n      } else {\n        return maxOffset;\n      }\n\n  }\n};\n\nvar VariableSizeGrid =\n/*#__PURE__*/\ncreateGridComponent({\n  getColumnOffset: function getColumnOffset(props, index, instanceProps) {\n    return getItemMetadata('column', props, index, instanceProps).offset;\n  },\n  getColumnStartIndexForOffset: function getColumnStartIndexForOffset(props, scrollLeft, instanceProps) {\n    return findNearestItem('column', props, instanceProps, scrollLeft);\n  },\n  getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, instanceProps) {\n    var columnCount = props.columnCount,\n        width = props.width;\n    var itemMetadata = getItemMetadata('column', props, startIndex, instanceProps);\n    var maxOffset = scrollLeft + width;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < columnCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata('column', props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  getColumnWidth: function getColumnWidth(props, index, instanceProps) {\n    return instanceProps.columnMetadataMap[index].size;\n  },\n  getEstimatedTotalHeight: getEstimatedTotalHeight,\n  getEstimatedTotalWidth: getEstimatedTotalWidth,\n  getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n    return getOffsetForIndexAndAlignment('column', props, index, align, scrollOffset, instanceProps, scrollbarSize);\n  },\n  getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n    return getOffsetForIndexAndAlignment('row', props, index, align, scrollOffset, instanceProps, scrollbarSize);\n  },\n  getRowOffset: function getRowOffset(props, index, instanceProps) {\n    return getItemMetadata('row', props, index, instanceProps).offset;\n  },\n  getRowHeight: function getRowHeight(props, index, instanceProps) {\n    return instanceProps.rowMetadataMap[index].size;\n  },\n  getRowStartIndexForOffset: function getRowStartIndexForOffset(props, scrollTop, instanceProps) {\n    return findNearestItem('row', props, instanceProps, scrollTop);\n  },\n  getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(props, startIndex, scrollTop, instanceProps) {\n    var rowCount = props.rowCount,\n        height = props.height;\n    var itemMetadata = getItemMetadata('row', props, startIndex, instanceProps);\n    var maxOffset = scrollTop + height;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < rowCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata('row', props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  initInstanceProps: function initInstanceProps(props, instance) {\n    var _ref5 = props,\n        estimatedColumnWidth = _ref5.estimatedColumnWidth,\n        estimatedRowHeight = _ref5.estimatedRowHeight;\n    var instanceProps = {\n      columnMetadataMap: {},\n      estimatedColumnWidth: estimatedColumnWidth || DEFAULT_ESTIMATED_ITEM_SIZE,\n      estimatedRowHeight: estimatedRowHeight || DEFAULT_ESTIMATED_ITEM_SIZE,\n      lastMeasuredColumnIndex: -1,\n      lastMeasuredRowIndex: -1,\n      rowMetadataMap: {}\n    };\n\n    instance.resetAfterColumnIndex = function (columnIndex, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instance.resetAfterIndices({\n        columnIndex: columnIndex,\n        shouldForceUpdate: shouldForceUpdate\n      });\n    };\n\n    instance.resetAfterRowIndex = function (rowIndex, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instance.resetAfterIndices({\n        rowIndex: rowIndex,\n        shouldForceUpdate: shouldForceUpdate\n      });\n    };\n\n    instance.resetAfterIndices = function (_ref6) {\n      var columnIndex = _ref6.columnIndex,\n          rowIndex = _ref6.rowIndex,\n          _ref6$shouldForceUpda = _ref6.shouldForceUpdate,\n          shouldForceUpdate = _ref6$shouldForceUpda === void 0 ? true : _ref6$shouldForceUpda;\n\n      if (typeof columnIndex === 'number') {\n        instanceProps.lastMeasuredColumnIndex = Math.min(instanceProps.lastMeasuredColumnIndex, columnIndex - 1);\n      }\n\n      if (typeof rowIndex === 'number') {\n        instanceProps.lastMeasuredRowIndex = Math.min(instanceProps.lastMeasuredRowIndex, rowIndex - 1);\n      } // We could potentially optimize further by only evicting styles after this index,\n      // But since styles are only cached while scrolling is in progress-\n      // It seems an unnecessary optimization.\n      // It's unlikely that resetAfterIndex() will be called while a user is scrolling.\n\n\n      instance._getItemStyleCache(-1);\n\n      if (shouldForceUpdate) {\n        instance.forceUpdate();\n      }\n    };\n\n    return instanceProps;\n  },\n  shouldResetStyleCacheOnItemSizeChange: false,\n  validateProps: function validateProps(_ref7) {\n    var columnWidth = _ref7.columnWidth,\n        rowHeight = _ref7.rowHeight;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof columnWidth !== 'function') {\n        throw Error('An invalid \"columnWidth\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (columnWidth === null ? 'null' : typeof columnWidth) + \"\\\" was specified.\"));\n      } else if (typeof rowHeight !== 'function') {\n        throw Error('An invalid \"rowHeight\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (rowHeight === null ? 'null' : typeof rowHeight) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar IS_SCROLLING_DEBOUNCE_INTERVAL$1 = 150;\n\nvar defaultItemKey$1 = function defaultItemKey(index, data) {\n  return index;\n}; // In DEV mode, this Set helps us only log a warning once per component instance.\n// This avoids spamming the console every time a render happens.\n\n\nvar devWarningsDirection = null;\nvar devWarningsTagName$1 = null;\n\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsDirection =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsTagName$1 =\n    /*#__PURE__*/\n    new WeakSet();\n  }\n}\n\nfunction createListComponent(_ref) {\n  var _class, _temp;\n\n  var getItemOffset = _ref.getItemOffset,\n      getEstimatedTotalSize = _ref.getEstimatedTotalSize,\n      getItemSize = _ref.getItemSize,\n      getOffsetForIndexAndAlignment = _ref.getOffsetForIndexAndAlignment,\n      getStartIndexForOffset = _ref.getStartIndexForOffset,\n      getStopIndexForStartIndex = _ref.getStopIndexForStartIndex,\n      initInstanceProps = _ref.initInstanceProps,\n      shouldResetStyleCacheOnItemSizeChange = _ref.shouldResetStyleCacheOnItemSizeChange,\n      validateProps = _ref.validateProps;\n  return _temp = _class =\n  /*#__PURE__*/\n  function (_PureComponent) {\n    _inheritsLoose(List, _PureComponent);\n\n    // Always use explicit constructor for React components.\n    // It produces less code after transpilation. (#26)\n    // eslint-disable-next-line no-useless-constructor\n    function List(props) {\n      var _this;\n\n      _this = _PureComponent.call(this, props) || this;\n      _this._instanceProps = initInstanceProps(_this.props, _assertThisInitialized(_assertThisInitialized(_this)));\n      _this._outerRef = void 0;\n      _this._resetIsScrollingTimeoutId = null;\n      _this.state = {\n        instance: _assertThisInitialized(_assertThisInitialized(_this)),\n        isScrolling: false,\n        scrollDirection: 'forward',\n        scrollOffset: typeof _this.props.initialScrollOffset === 'number' ? _this.props.initialScrollOffset : 0,\n        scrollUpdateWasRequested: false\n      };\n      _this._callOnItemsRendered = void 0;\n      _this._callOnItemsRendered = memoizeOne(function (overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {\n        return _this.props.onItemsRendered({\n          overscanStartIndex: overscanStartIndex,\n          overscanStopIndex: overscanStopIndex,\n          visibleStartIndex: visibleStartIndex,\n          visibleStopIndex: visibleStopIndex\n        });\n      });\n      _this._callOnScroll = void 0;\n      _this._callOnScroll = memoizeOne(function (scrollDirection, scrollOffset, scrollUpdateWasRequested) {\n        return _this.props.onScroll({\n          scrollDirection: scrollDirection,\n          scrollOffset: scrollOffset,\n          scrollUpdateWasRequested: scrollUpdateWasRequested\n        });\n      });\n      _this._getItemStyle = void 0;\n\n      _this._getItemStyle = function (index) {\n        var _this$props = _this.props,\n            direction = _this$props.direction,\n            itemSize = _this$props.itemSize,\n            layout = _this$props.layout;\n\n        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && itemSize, shouldResetStyleCacheOnItemSizeChange && layout, shouldResetStyleCacheOnItemSizeChange && direction);\n\n        var style;\n\n        if (itemStyleCache.hasOwnProperty(index)) {\n          style = itemStyleCache[index];\n        } else {\n          var _offset = getItemOffset(_this.props, index, _this._instanceProps);\n\n          var size = getItemSize(_this.props, index, _this._instanceProps); // TODO Deprecate direction \"horizontal\"\n\n          var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n          var isRtl = direction === 'rtl';\n          var offsetHorizontal = isHorizontal ? _offset : 0;\n          itemStyleCache[index] = style = {\n            position: 'absolute',\n            left: isRtl ? undefined : offsetHorizontal,\n            right: isRtl ? offsetHorizontal : undefined,\n            top: !isHorizontal ? _offset : 0,\n            height: !isHorizontal ? size : '100%',\n            width: isHorizontal ? size : '100%'\n          };\n        }\n\n        return style;\n      };\n\n      _this._getItemStyleCache = void 0;\n      _this._getItemStyleCache = memoizeOne(function (_, __, ___) {\n        return {};\n      });\n\n      _this._onScrollHorizontal = function (event) {\n        var _event$currentTarget = event.currentTarget,\n            clientWidth = _event$currentTarget.clientWidth,\n            scrollLeft = _event$currentTarget.scrollLeft,\n            scrollWidth = _event$currentTarget.scrollWidth;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollOffset === scrollLeft) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          }\n\n          var direction = _this.props.direction;\n          var scrollOffset = scrollLeft;\n\n          if (direction === 'rtl') {\n            // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n            // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n            // It's also easier for this component if we convert offsets to the same format as they would be in for ltr.\n            // So the simplest solution is to determine which browser behavior we're dealing with, and convert based on it.\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                scrollOffset = -scrollLeft;\n                break;\n\n              case 'positive-descending':\n                scrollOffset = scrollWidth - clientWidth - scrollLeft;\n                break;\n            }\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));\n          return {\n            isScrolling: true,\n            scrollDirection: prevState.scrollOffset < scrollLeft ? 'forward' : 'backward',\n            scrollOffset: scrollOffset,\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._onScrollVertical = function (event) {\n        var _event$currentTarget2 = event.currentTarget,\n            clientHeight = _event$currentTarget2.clientHeight,\n            scrollHeight = _event$currentTarget2.scrollHeight,\n            scrollTop = _event$currentTarget2.scrollTop;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollOffset === scrollTop) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));\n          return {\n            isScrolling: true,\n            scrollDirection: prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n            scrollOffset: scrollOffset,\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._outerRefSetter = function (ref) {\n        var outerRef = _this.props.outerRef;\n        _this._outerRef = ref;\n\n        if (typeof outerRef === 'function') {\n          outerRef(ref);\n        } else if (outerRef != null && typeof outerRef === 'object' && outerRef.hasOwnProperty('current')) {\n          outerRef.current = ref;\n        }\n      };\n\n      _this._resetIsScrollingDebounced = function () {\n        if (_this._resetIsScrollingTimeoutId !== null) {\n          cancelTimeout(_this._resetIsScrollingTimeoutId);\n        }\n\n        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL$1);\n      };\n\n      _this._resetIsScrolling = function () {\n        _this._resetIsScrollingTimeoutId = null;\n\n        _this.setState({\n          isScrolling: false\n        }, function () {\n          // Clear style cache after state update has been committed.\n          // This way we don't break pure sCU for items that don't use isScrolling param.\n          _this._getItemStyleCache(-1, null);\n        });\n      };\n\n      return _this;\n    }\n\n    List.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      validateSharedProps$1(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    };\n\n    var _proto = List.prototype;\n\n    _proto.scrollTo = function scrollTo(scrollOffset) {\n      scrollOffset = Math.max(0, scrollOffset);\n      this.setState(function (prevState) {\n        if (prevState.scrollOffset === scrollOffset) {\n          return null;\n        }\n\n        return {\n          scrollDirection: prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n          scrollOffset: scrollOffset,\n          scrollUpdateWasRequested: true\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _proto.scrollToItem = function scrollToItem(index, align) {\n      if (align === void 0) {\n        align = 'auto';\n      }\n\n      var itemCount = this.props.itemCount;\n      var scrollOffset = this.state.scrollOffset;\n      index = Math.max(0, Math.min(index, itemCount - 1));\n      this.scrollTo(getOffsetForIndexAndAlignment(this.props, index, align, scrollOffset, this._instanceProps));\n    };\n\n    _proto.componentDidMount = function componentDidMount() {\n      var _this$props2 = this.props,\n          direction = _this$props2.direction,\n          initialScrollOffset = _this$props2.initialScrollOffset,\n          layout = _this$props2.layout;\n\n      if (typeof initialScrollOffset === 'number' && this._outerRef != null) {\n        var outerRef = this._outerRef; // TODO Deprecate direction \"horizontal\"\n\n        if (direction === 'horizontal' || layout === 'horizontal') {\n          outerRef.scrollLeft = initialScrollOffset;\n        } else {\n          outerRef.scrollTop = initialScrollOffset;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate() {\n      var _this$props3 = this.props,\n          direction = _this$props3.direction,\n          layout = _this$props3.layout;\n      var _this$state = this.state,\n          scrollOffset = _this$state.scrollOffset,\n          scrollUpdateWasRequested = _this$state.scrollUpdateWasRequested;\n\n      if (scrollUpdateWasRequested && this._outerRef != null) {\n        var outerRef = this._outerRef; // TODO Deprecate direction \"horizontal\"\n\n        if (direction === 'horizontal' || layout === 'horizontal') {\n          if (direction === 'rtl') {\n            // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n            // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n            // So we need to determine which browser behavior we're dealing with, and mimic it.\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                outerRef.scrollLeft = -scrollOffset;\n                break;\n\n              case 'positive-ascending':\n                outerRef.scrollLeft = scrollOffset;\n                break;\n\n              default:\n                var clientWidth = outerRef.clientWidth,\n                    scrollWidth = outerRef.scrollWidth;\n                outerRef.scrollLeft = scrollWidth - clientWidth - scrollOffset;\n                break;\n            }\n          } else {\n            outerRef.scrollLeft = scrollOffset;\n          }\n        } else {\n          outerRef.scrollTop = scrollOffset;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    };\n\n    _proto.render = function render() {\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          className = _this$props4.className,\n          direction = _this$props4.direction,\n          height = _this$props4.height,\n          innerRef = _this$props4.innerRef,\n          innerElementType = _this$props4.innerElementType,\n          innerTagName = _this$props4.innerTagName,\n          itemCount = _this$props4.itemCount,\n          itemData = _this$props4.itemData,\n          _this$props4$itemKey = _this$props4.itemKey,\n          itemKey = _this$props4$itemKey === void 0 ? defaultItemKey$1 : _this$props4$itemKey,\n          layout = _this$props4.layout,\n          outerElementType = _this$props4.outerElementType,\n          outerTagName = _this$props4.outerTagName,\n          style = _this$props4.style,\n          useIsScrolling = _this$props4.useIsScrolling,\n          width = _this$props4.width;\n      var isScrolling = this.state.isScrolling; // TODO Deprecate direction \"horizontal\"\n\n      var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n      var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;\n\n      var _this$_getRangeToRend = this._getRangeToRender(),\n          startIndex = _this$_getRangeToRend[0],\n          stopIndex = _this$_getRangeToRend[1];\n\n      var items = [];\n\n      if (itemCount > 0) {\n        for (var _index = startIndex; _index <= stopIndex; _index++) {\n          items.push(createElement(children, {\n            data: itemData,\n            key: itemKey(_index, itemData),\n            index: _index,\n            isScrolling: useIsScrolling ? isScrolling : undefined,\n            style: this._getItemStyle(_index)\n          }));\n        }\n      } // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n\n\n      var estimatedTotalSize = getEstimatedTotalSize(this.props, this._instanceProps);\n      return createElement(outerElementType || outerTagName || 'div', {\n        className: className,\n        onScroll: onScroll,\n        ref: this._outerRefSetter,\n        style: _extends({\n          position: 'relative',\n          height: height,\n          width: width,\n          overflow: 'auto',\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform',\n          direction: direction\n        }, style)\n      }, createElement(innerElementType || innerTagName || 'div', {\n        children: items,\n        ref: innerRef,\n        style: {\n          height: isHorizontal ? '100%' : estimatedTotalSize,\n          pointerEvents: isScrolling ? 'none' : undefined,\n          width: isHorizontal ? estimatedTotalSize : '100%'\n        }\n      }));\n    };\n\n    _proto._callPropsCallbacks = function _callPropsCallbacks() {\n      if (typeof this.props.onItemsRendered === 'function') {\n        var itemCount = this.props.itemCount;\n\n        if (itemCount > 0) {\n          var _this$_getRangeToRend2 = this._getRangeToRender(),\n              _overscanStartIndex = _this$_getRangeToRend2[0],\n              _overscanStopIndex = _this$_getRangeToRend2[1],\n              _visibleStartIndex = _this$_getRangeToRend2[2],\n              _visibleStopIndex = _this$_getRangeToRend2[3];\n\n          this._callOnItemsRendered(_overscanStartIndex, _overscanStopIndex, _visibleStartIndex, _visibleStopIndex);\n        }\n      }\n\n      if (typeof this.props.onScroll === 'function') {\n        var _this$state2 = this.state,\n            _scrollDirection = _this$state2.scrollDirection,\n            _scrollOffset = _this$state2.scrollOffset,\n            _scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;\n\n        this._callOnScroll(_scrollDirection, _scrollOffset, _scrollUpdateWasRequested);\n      }\n    }; // Lazily create and cache item styles while scrolling,\n    // So that pure component sCU will prevent re-renders.\n    // We maintain this cache, and pass a style prop rather than index,\n    // So that List can clear cached styles and force item re-render if necessary.\n\n\n    _proto._getRangeToRender = function _getRangeToRender() {\n      var _this$props5 = this.props,\n          itemCount = _this$props5.itemCount,\n          overscanCount = _this$props5.overscanCount;\n      var _this$state3 = this.state,\n          isScrolling = _this$state3.isScrolling,\n          scrollDirection = _this$state3.scrollDirection,\n          scrollOffset = _this$state3.scrollOffset;\n\n      if (itemCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getStartIndexForOffset(this.props, scrollOffset, this._instanceProps);\n      var stopIndex = getStopIndexForStartIndex(this.props, startIndex, scrollOffset, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || scrollDirection === 'backward' ? Math.max(1, overscanCount) : 1;\n      var overscanForward = !isScrolling || scrollDirection === 'forward' ? Math.max(1, overscanCount) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    return List;\n  }(PureComponent), _class.defaultProps = {\n    direction: 'ltr',\n    itemData: undefined,\n    layout: 'vertical',\n    overscanCount: 2,\n    useIsScrolling: false\n  }, _temp;\n} // NOTE: I considered further wrapping individual items with a pure ListItem component.\n// This would avoid ever calling the render function for the same index more than once,\n// But it would also add the overhead of a lot of components/fibers.\n// I assume people already do this (render function returning a class component),\n// So my doing it would just unnecessarily double the wrappers.\n\nvar validateSharedProps$1 = function validateSharedProps(_ref2, _ref3) {\n  var children = _ref2.children,\n      direction = _ref2.direction,\n      height = _ref2.height,\n      layout = _ref2.layout,\n      innerTagName = _ref2.innerTagName,\n      outerTagName = _ref2.outerTagName,\n      width = _ref2.width;\n  var instance = _ref3.instance;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName$1 && !devWarningsTagName$1.has(instance)) {\n        devWarningsTagName$1.add(instance);\n        console.warn('The innerTagName and outerTagName props have been deprecated. ' + 'Please use the innerElementType and outerElementType props instead.');\n      }\n    } // TODO Deprecate direction \"horizontal\"\n\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n\n    switch (direction) {\n      case 'horizontal':\n      case 'vertical':\n        if (devWarningsDirection && !devWarningsDirection.has(instance)) {\n          devWarningsDirection.add(instance);\n          console.warn('The direction prop should be either \"ltr\" (default) or \"rtl\". ' + 'Please use the layout prop to specify \"vertical\" (default) or \"horizontal\" orientation.');\n        }\n\n        break;\n\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"direction\" prop has been specified. ' + 'Value should be either \"ltr\" or \"rtl\". ' + (\"\\\"\" + direction + \"\\\" was specified.\"));\n    }\n\n    switch (layout) {\n      case 'horizontal':\n      case 'vertical':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"layout\" prop has been specified. ' + 'Value should be either \"horizontal\" or \"vertical\". ' + (\"\\\"\" + layout + \"\\\" was specified.\"));\n    }\n\n    if (children == null) {\n      throw Error('An invalid \"children\" prop has been specified. ' + 'Value should be a React component. ' + (\"\\\"\" + (children === null ? 'null' : typeof children) + \"\\\" was specified.\"));\n    }\n\n    if (isHorizontal && typeof width !== 'number') {\n      throw Error('An invalid \"width\" prop has been specified. ' + 'Horizontal lists must specify a number for width. ' + (\"\\\"\" + (width === null ? 'null' : typeof width) + \"\\\" was specified.\"));\n    } else if (!isHorizontal && typeof height !== 'number') {\n      throw Error('An invalid \"height\" prop has been specified. ' + 'Vertical lists must specify a number for height. ' + (\"\\\"\" + (height === null ? 'null' : typeof height) + \"\\\" was specified.\"));\n    }\n  }\n};\n\nvar DEFAULT_ESTIMATED_ITEM_SIZE$1 = 50;\n\nvar getItemMetadata$1 = function getItemMetadata(props, index, instanceProps) {\n  var _ref = props,\n      itemSize = _ref.itemSize;\n  var itemMetadataMap = instanceProps.itemMetadataMap,\n      lastMeasuredIndex = instanceProps.lastMeasuredIndex;\n\n  if (index > lastMeasuredIndex) {\n    var offset = 0;\n\n    if (lastMeasuredIndex >= 0) {\n      var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n      offset = itemMetadata.offset + itemMetadata.size;\n    }\n\n    for (var i = lastMeasuredIndex + 1; i <= index; i++) {\n      var size = itemSize(i);\n      itemMetadataMap[i] = {\n        offset: offset,\n        size: size\n      };\n      offset += size;\n    }\n\n    instanceProps.lastMeasuredIndex = index;\n  }\n\n  return itemMetadataMap[index];\n};\n\nvar findNearestItem$1 = function findNearestItem(props, instanceProps, offset) {\n  var itemMetadataMap = instanceProps.itemMetadataMap,\n      lastMeasuredIndex = instanceProps.lastMeasuredIndex;\n  var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;\n\n  if (lastMeasuredItemOffset >= offset) {\n    // If we've already measured items within this range just use a binary search as it's faster.\n    return findNearestItemBinarySearch$1(props, instanceProps, 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 items as a binary search would.\n    // The overall complexity for this approach is O(log n).\n    return findNearestItemExponentialSearch$1(props, instanceProps, Math.max(0, lastMeasuredIndex), offset);\n  }\n};\n\nvar findNearestItemBinarySearch$1 = function findNearestItemBinarySearch(props, instanceProps, high, low, offset) {\n  while (low <= high) {\n    var middle = low + Math.floor((high - low) / 2);\n    var currentOffset = getItemMetadata$1(props, middle, instanceProps).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\nvar findNearestItemExponentialSearch$1 = function findNearestItemExponentialSearch(props, instanceProps, index, offset) {\n  var itemCount = props.itemCount;\n  var interval = 1;\n\n  while (index < itemCount && getItemMetadata$1(props, index, instanceProps).offset < offset) {\n    index += interval;\n    interval *= 2;\n  }\n\n  return findNearestItemBinarySearch$1(props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);\n};\n\nvar getEstimatedTotalSize = function getEstimatedTotalSize(_ref2, _ref3) {\n  var itemCount = _ref2.itemCount;\n  var itemMetadataMap = _ref3.itemMetadataMap,\n      estimatedItemSize = _ref3.estimatedItemSize,\n      lastMeasuredIndex = _ref3.lastMeasuredIndex;\n  var totalSizeOfMeasuredItems = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredIndex >= itemCount) {\n    lastMeasuredIndex = itemCount - 1;\n  }\n\n  if (lastMeasuredIndex >= 0) {\n    var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n    totalSizeOfMeasuredItems = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = itemCount - lastMeasuredIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;\n  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;\n};\n\nvar VariableSizeList =\n/*#__PURE__*/\ncreateListComponent({\n  getItemOffset: function getItemOffset(props, index, instanceProps) {\n    return getItemMetadata$1(props, index, instanceProps).offset;\n  },\n  getItemSize: function getItemSize(props, index, instanceProps) {\n    return instanceProps.itemMetadataMap[index].size;\n  },\n  getEstimatedTotalSize: getEstimatedTotalSize,\n  getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(props, index, align, scrollOffset, instanceProps) {\n    var direction = props.direction,\n        height = props.height,\n        layout = props.layout,\n        width = props.width; // TODO Deprecate direction \"horizontal\"\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var itemMetadata = getItemMetadata$1(props, index, instanceProps); // Get estimated total size after ItemMetadata is computed,\n    // To ensure it reflects actual measurements instead of just estimates.\n\n    var estimatedTotalSize = getEstimatedTotalSize(props, instanceProps);\n    var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));\n    var minOffset = Math.max(0, itemMetadata.offset - size + itemMetadata.size);\n\n    if (align === 'smart') {\n      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        return Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n      case 'auto':\n      default:\n        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n          return scrollOffset;\n        } else if (scrollOffset < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getStartIndexForOffset: function getStartIndexForOffset(props, offset, instanceProps) {\n    return findNearestItem$1(props, instanceProps, offset);\n  },\n  getStopIndexForStartIndex: function getStopIndexForStartIndex(props, startIndex, scrollOffset, instanceProps) {\n    var direction = props.direction,\n        height = props.height,\n        itemCount = props.itemCount,\n        layout = props.layout,\n        width = props.width; // TODO Deprecate direction \"horizontal\"\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var itemMetadata = getItemMetadata$1(props, startIndex, instanceProps);\n    var maxOffset = scrollOffset + size;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < itemCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata$1(props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  initInstanceProps: function initInstanceProps(props, instance) {\n    var _ref4 = props,\n        estimatedItemSize = _ref4.estimatedItemSize;\n    var instanceProps = {\n      itemMetadataMap: {},\n      estimatedItemSize: estimatedItemSize || DEFAULT_ESTIMATED_ITEM_SIZE$1,\n      lastMeasuredIndex: -1\n    };\n\n    instance.resetAfterIndex = function (index, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instanceProps.lastMeasuredIndex = Math.min(instanceProps.lastMeasuredIndex, index - 1); // We could potentially optimize further by only evicting styles after this index,\n      // But since styles are only cached while scrolling is in progress-\n      // It seems an unnecessary optimization.\n      // It's unlikely that resetAfterIndex() will be called while a user is scrolling.\n\n      instance._getItemStyleCache(-1);\n\n      if (shouldForceUpdate) {\n        instance.forceUpdate();\n      }\n    };\n\n    return instanceProps;\n  },\n  shouldResetStyleCacheOnItemSizeChange: false,\n  validateProps: function validateProps(_ref5) {\n    var itemSize = _ref5.itemSize;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof itemSize !== 'function') {\n        throw Error('An invalid \"itemSize\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (itemSize === null ? 'null' : typeof itemSize) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar FixedSizeGrid =\n/*#__PURE__*/\ncreateGridComponent({\n  getColumnOffset: function getColumnOffset(_ref, index) {\n    var columnWidth = _ref.columnWidth;\n    return index * columnWidth;\n  },\n  getColumnWidth: function getColumnWidth(_ref2, index) {\n    var columnWidth = _ref2.columnWidth;\n    return columnWidth;\n  },\n  getRowOffset: function getRowOffset(_ref3, index) {\n    var rowHeight = _ref3.rowHeight;\n    return index * rowHeight;\n  },\n  getRowHeight: function getRowHeight(_ref4, index) {\n    var rowHeight = _ref4.rowHeight;\n    return rowHeight;\n  },\n  getEstimatedTotalHeight: function getEstimatedTotalHeight(_ref5) {\n    var rowCount = _ref5.rowCount,\n        rowHeight = _ref5.rowHeight;\n    return rowHeight * rowCount;\n  },\n  getEstimatedTotalWidth: function getEstimatedTotalWidth(_ref6) {\n    var columnCount = _ref6.columnCount,\n        columnWidth = _ref6.columnWidth;\n    return columnWidth * columnCount;\n  },\n  getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(_ref7, columnIndex, align, scrollLeft, instanceProps, scrollbarSize) {\n    var columnCount = _ref7.columnCount,\n        columnWidth = _ref7.columnWidth,\n        width = _ref7.width;\n    var lastColumnOffset = Math.max(0, columnCount * columnWidth - width);\n    var maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);\n    var minOffset = Math.max(0, columnIndex * columnWidth - width + scrollbarSize + columnWidth);\n\n    if (align === 'smart') {\n      if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        // \"Centered\" offset is usually the average of the min and max.\n        // But near the edges of the list, this doesn't hold true.\n        var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n        if (middleOffset < Math.ceil(width / 2)) {\n          return 0; // near the beginning\n        } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {\n          return lastColumnOffset; // near the end\n        } else {\n          return middleOffset;\n        }\n\n      case 'auto':\n      default:\n        if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {\n          return scrollLeft;\n        } else if (minOffset > maxOffset) {\n          // Because we only take into account the scrollbar size when calculating minOffset\n          // this value can be larger than maxOffset when at the end of the list\n          return minOffset;\n        } else if (scrollLeft < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(_ref8, rowIndex, align, scrollTop, instanceProps, scrollbarSize) {\n    var rowHeight = _ref8.rowHeight,\n        height = _ref8.height,\n        rowCount = _ref8.rowCount;\n    var lastRowOffset = Math.max(0, rowCount * rowHeight - height);\n    var maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);\n    var minOffset = Math.max(0, rowIndex * rowHeight - height + scrollbarSize + rowHeight);\n\n    if (align === 'smart') {\n      if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        // \"Centered\" offset is usually the average of the min and max.\n        // But near the edges of the list, this doesn't hold true.\n        var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n        if (middleOffset < Math.ceil(height / 2)) {\n          return 0; // near the beginning\n        } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {\n          return lastRowOffset; // near the end\n        } else {\n          return middleOffset;\n        }\n\n      case 'auto':\n      default:\n        if (scrollTop >= minOffset && scrollTop <= maxOffset) {\n          return scrollTop;\n        } else if (minOffset > maxOffset) {\n          // Because we only take into account the scrollbar size when calculating minOffset\n          // this value can be larger than maxOffset when at the end of the list\n          return minOffset;\n        } else if (scrollTop < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getColumnStartIndexForOffset: function getColumnStartIndexForOffset(_ref9, scrollLeft) {\n    var columnWidth = _ref9.columnWidth,\n        columnCount = _ref9.columnCount;\n    return Math.max(0, Math.min(columnCount - 1, Math.floor(scrollLeft / columnWidth)));\n  },\n  getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(_ref10, startIndex, scrollLeft) {\n    var columnWidth = _ref10.columnWidth,\n        columnCount = _ref10.columnCount,\n        width = _ref10.width;\n    var left = startIndex * columnWidth;\n    var numVisibleColumns = Math.ceil((width + scrollLeft - left) / columnWidth);\n    return Math.max(0, Math.min(columnCount - 1, startIndex + numVisibleColumns - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  getRowStartIndexForOffset: function getRowStartIndexForOffset(_ref11, scrollTop) {\n    var rowHeight = _ref11.rowHeight,\n        rowCount = _ref11.rowCount;\n    return Math.max(0, Math.min(rowCount - 1, Math.floor(scrollTop / rowHeight)));\n  },\n  getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(_ref12, startIndex, scrollTop) {\n    var rowHeight = _ref12.rowHeight,\n        rowCount = _ref12.rowCount,\n        height = _ref12.height;\n    var top = startIndex * rowHeight;\n    var numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);\n    return Math.max(0, Math.min(rowCount - 1, startIndex + numVisibleRows - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  initInstanceProps: function initInstanceProps(props) {// Noop\n  },\n  shouldResetStyleCacheOnItemSizeChange: true,\n  validateProps: function validateProps(_ref13) {\n    var columnWidth = _ref13.columnWidth,\n        rowHeight = _ref13.rowHeight;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof columnWidth !== 'number') {\n        throw Error('An invalid \"columnWidth\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (columnWidth === null ? 'null' : typeof columnWidth) + \"\\\" was specified.\"));\n      }\n\n      if (typeof rowHeight !== 'number') {\n        throw Error('An invalid \"rowHeight\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (rowHeight === null ? 'null' : typeof rowHeight) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar FixedSizeList =\n/*#__PURE__*/\ncreateListComponent({\n  getItemOffset: function getItemOffset(_ref, index) {\n    var itemSize = _ref.itemSize;\n    return index * itemSize;\n  },\n  getItemSize: function getItemSize(_ref2, index) {\n    var itemSize = _ref2.itemSize;\n    return itemSize;\n  },\n  getEstimatedTotalSize: function getEstimatedTotalSize(_ref3) {\n    var itemCount = _ref3.itemCount,\n        itemSize = _ref3.itemSize;\n    return itemSize * itemCount;\n  },\n  getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(_ref4, index, align, scrollOffset) {\n    var direction = _ref4.direction,\n        height = _ref4.height,\n        itemCount = _ref4.itemCount,\n        itemSize = _ref4.itemSize,\n        layout = _ref4.layout,\n        width = _ref4.width;\n    // TODO Deprecate direction \"horizontal\"\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var lastItemOffset = Math.max(0, itemCount * itemSize - size);\n    var maxOffset = Math.min(lastItemOffset, index * itemSize);\n    var minOffset = Math.max(0, index * itemSize - size + itemSize);\n\n    if (align === 'smart') {\n      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        {\n          // \"Centered\" offset is usually the average of the min and max.\n          // But near the edges of the list, this doesn't hold true.\n          var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n          if (middleOffset < Math.ceil(size / 2)) {\n            return 0; // near the beginning\n          } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {\n            return lastItemOffset; // near the end\n          } else {\n            return middleOffset;\n          }\n        }\n\n      case 'auto':\n      default:\n        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n          return scrollOffset;\n        } else if (scrollOffset < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getStartIndexForOffset: function getStartIndexForOffset(_ref5, offset) {\n    var itemCount = _ref5.itemCount,\n        itemSize = _ref5.itemSize;\n    return Math.max(0, Math.min(itemCount - 1, Math.floor(offset / itemSize)));\n  },\n  getStopIndexForStartIndex: function getStopIndexForStartIndex(_ref6, startIndex, scrollOffset) {\n    var direction = _ref6.direction,\n        height = _ref6.height,\n        itemCount = _ref6.itemCount,\n        itemSize = _ref6.itemSize,\n        layout = _ref6.layout,\n        width = _ref6.width;\n    // TODO Deprecate direction \"horizontal\"\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var offset = startIndex * itemSize;\n    var size = isHorizontal ? width : height;\n    var numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);\n    return Math.max(0, Math.min(itemCount - 1, startIndex + numVisibleItems - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  initInstanceProps: function initInstanceProps(props) {// Noop\n  },\n  shouldResetStyleCacheOnItemSizeChange: true,\n  validateProps: function validateProps(_ref7) {\n    var itemSize = _ref7.itemSize;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof itemSize !== 'number') {\n        throw Error('An invalid \"itemSize\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (itemSize === null ? 'null' : typeof itemSize) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\n// Pulled from react-compat\n// https://github.com/developit/preact-compat/blob/7c5de00e7c85e2ffd011bf3af02899b63f699d3a/src/index.js#L349\nfunction shallowDiffers(prev, next) {\n  for (var attribute in prev) {\n    if (!(attribute in next)) {\n      return true;\n    }\n  }\n\n  for (var _attribute in next) {\n    if (prev[_attribute] !== next[_attribute]) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// It knows to compare individual style props and ignore the wrapper object.\n// See https://reactjs.org/docs/react-api.html#reactmemo\n\nfunction areEqual(prevProps, nextProps) {\n  var prevStyle = prevProps.style,\n      prevRest = _objectWithoutPropertiesLoose(prevProps, [\"style\"]);\n\n  var nextStyle = nextProps.style,\n      nextRest = _objectWithoutPropertiesLoose(nextProps, [\"style\"]);\n\n  return !shallowDiffers(prevStyle, nextStyle) && !shallowDiffers(prevRest, nextRest);\n}\n\n// It knows to compare individual style props and ignore the wrapper object.\n// See https://reactjs.org/docs/react-component.html#shouldcomponentupdate\n\nfunction shouldComponentUpdate(nextProps, nextState) {\n  return !areEqual(this.props, nextProps) || shallowDiffers(this.state, nextState);\n}\n\nexport { VariableSizeGrid, VariableSizeList, FixedSizeGrid, FixedSizeList, areEqual, shouldComponentUpdate };\n//# sourceMappingURL=index.esm.js.map\n"],"sourceRoot":""}