{"version":3,"sources":["../node_modules/lodash/debounce.js","../ReactPaginate/webpack/universalModuleDefinition","../ReactPaginate/webpack/bootstrap","../ReactPaginate/node_modules/prop-types/index.js","../webpack:/ReactPaginate/external {\"root\":\"React\",\"amd\":\"react\",\"commonjs\":\"react\",\"commonjs2\":\"react\"}","../ReactPaginate/node_modules/prop-types/factoryWithThrowingShims.js","../ReactPaginate/node_modules/prop-types/lib/ReactPropTypesSecret.js","../ReactPaginate/react_components/PageView.js","../ReactPaginate/react_components/BreakView.js","../ReactPaginate/react_components/PaginationBoxView.js","../ReactPaginate/react_components/index.js","../node_modules/lodash/now.js","../node_modules/lodash/toNumber.js","../node_modules/lodash/isSymbol.js","../node_modules/react-table/index.js","publicUtils.js","utils.js","makeDefaultPluginHooks.js","hooks/useColumnVisibility.js","hooks/useTable.js","plugin-hooks/useExpanded.js","filterTypes.js","plugin-hooks/useFilters.js","plugin-hooks/useGlobalFilter.js","aggregations.js","plugin-hooks/useGroupBy.js","sortTypes.js","plugin-hooks/useSortBy.js","plugin-hooks/usePagination.js","plugin-hooks/_UNSTABLE_usePivotColumns.js","plugin-hooks/useRowSelect.js","plugin-hooks/useRowState.js","plugin-hooks/useColumnOrder.js","plugin-hooks/useResizeColumns.js","plugin-hooks/useAbsoluteLayout.js","plugin-hooks/useBlockLayout.js","plugin-hooks/useFlexLayout.js","../node_modules/react-bootstrap/esm/Table.js"],"names":["isObject","require","now","toNumber","nativeMax","Math","max","nativeMin","min","module","exports","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","apply","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","clearTimeout","cancel","flush","__WEBPACK_EXTERNAL_MODULE__1__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","props","propName","componentName","location","propFullName","secret","err","Error","getShim","isRequired","ReactPropTypes","array","bool","number","string","symbol","any","arrayOf","element","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","PageView","pageClassName","pageLinkClassName","page","selected","activeClassName","activeLinkClassName","getEventListener","pageSelectedHandler","href","extraAriaContext","ariaLabel","ariaCurrent","className","role","tabIndex","aria-label","aria-current","onKeyPress","propTypes","BreakView","breakLabel","breakClassName","breakLinkClassName","breakHandler","PaginationBoxView","initialSelected","evt","state","preventDefault","returnValue","handlePageSelected","pageCount","setState","callCallback","handlerFunction","eventListener","index","getForwardJump","getBackwardJump","selectedItem","onPageChange","items","pageRangeDisplayed","marginPagesDisplayed","push","getPageElement","breakView","leftSide","rightSide","createPageView","length","handleBreakClick","initialPage","forcePage","disableInitialCallback","console","warn","prevProps","forwardJump","backwardJump","pageIndex","hrefBuilder","ariaLabelBuilder","label","disabledClassName","containerClassName","previousLabel","previousClassName","previousLinkClassName","previousAriaLabel","nextLabel","nextClassName","nextLinkClassName","nextAriaLabel","previousClasses","nextClasses","previousAriaDisabled","nextAriaDisabled","handlePreviousPage","aria-disabled","pagination","handleNextPage","Component","root","Date","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","test","slice","baseGetTag","isObjectLike","actions","init","defaultRenderer","emptyRenderer","React","defaultColumn","Cell","width","minWidth","maxWidth","Number","MAX_SAFE_INTEGER","mergeProps","propList","reduce","next","style","makePropGetter","hooks","meta","userProps","prev","handlePropGetter","Array","isArray","reduceHooks","initial","allowUndefined","loopHooks","context","forEach","hook","ensurePluginOrder","plugins","befores","pluginName","afters","findIndex","plugin","before","functionalUpdate","updater","old","useGetLatest","obj","ref","useRef","current","useCallback","safeUseLayoutEffect","document","useLayoutEffect","useEffect","useMountedLayoutEffect","fn","deps","mountedRef","makeRenderer","instance","column","type","Comp","info","flexRender","component","proto","getPrototypeOf","isReactComponent","$$typeof","includes","description","linkColumnStructure","columns","parent","depth","map","assignColumnAccessor","flattenColumns","flattenBy","id","accessor","Header","accessorPath","split","path","def","val","cacheKey","JSON","stringify","pathObj","pathObjCache","flattenDeep","arr","newArr","String","join","reOpenBracket","reCloseBracket","set","cursor","pathPart","e","row","error","assign","decorateColumn","userDefaultColumn","Footer","originalWidth","makeHeaderGroups","allColumns","additionalHeaderProperties","headerGroups","scanColumns","uid","getUID","headerGroup","headers","parentColumns","hasParents","some","newParent","latestParentColumn","reverse","originalId","placeholderOf","Map","getFirstDefined","isFunction","a","flat","recurse","expandRows","rows","manualExpandedKey","expanded","expandSubRows","expandedRows","handleRow","isExpanded","original","canExpand","subRows","getFilterMethod","filter","userFilterTypes","filterTypes","text","shouldAutoRemoveFilter","autoRemove","unpreparedAccessWarning","passiveSupported","defaultGetTableProps","defaultGetTableBodyProps","defaultGetHeaderProps","colSpan","totalVisibleHeaderCount","defaultGetFooterProps","defaultGetHeaderGroupProps","defaultGetFooterGroupProps","defaultGetRowProps","defaultGetCellProps","cell","makeDefaultPluginHooks","useOptions","stateReducers","useControlledState","columnsDeps","allColumnsDeps","accessValue","materializedColumns","materializedColumnsDeps","useInstanceAfterData","visibleColumns","visibleColumnsDeps","headerGroupsDeps","useInstanceBeforeDimensions","useInstance","prepareRow","getTableProps","getTableBodyProps","getHeaderGroupProps","getFooterGroupProps","getHeaderProps","getFooterProps","getRowProps","getCellProps","useFinalInstance","resetHiddenColumns","toggleHideColumn","setHiddenColumns","toggleHideAllColumns","useColumnVisibility","getToggleHiddenProps","defaultGetToggleHiddenProps","getToggleHideAllColumnsProps","defaultGetToggleHideAllColumnsProps","reducer","hiddenColumns","onChange","toggleHidden","target","checked","isVisible","title","allColumnsHidden","indeterminate","action","previousState","initialState","columnId","handleColumn","parentVisible","subColumn","subHeader","flatHeaders","dispatch","getHooks","autoResetHiddenColumns","getInstance","getAutoResetHiddenColumns","defaultInitialState","defaultColumnInstance","defaultReducer","prevState","defaultGetSubRows","defaultGetRowId","defaultUseControlledState","applyDefaults","getSubRows","getRowId","stateReducer","calculateHeaderWidths","left","sumTotalMinWidth","sumTotalWidth","sumTotalMaxWidth","sumTotalFlexWidth","subHeaders","header","totalLeft","totalMinWidth","totalWidth","totalMaxWidth","totalFlexWidth","canResize","accessRowsForColumn","data","flatRows","rowsById","accessValueHooks","originalRow","rowIndex","accessRow","parentRows","originalSubRows","cells","values","resetExpanded","toggleRowExpanded","toggleAllRowsExpanded","useExpanded","getToggleAllRowsExpandedProps","defaultGetToggleAllRowsExpandedProps","getToggleRowExpandedProps","defaultGetToggleRowExpandedProps","onClick","isAllRowsExpanded","keys","rowId","setExpanded","exists","shouldExist","paginateExpandedRows","autoResetExpanded","getAutoResetExpanded","Boolean","useMemo","expandedDepth","maxDepth","splitId","preExpandedRows","ids","filterValue","rowValue","toLowerCase","exactText","exactTextCase","includesAll","every","includesSome","includesValue","equals","between","Infinity","temp","resetFilters","setFilter","setAllFilters","useFilters","filters","find","filterMethod","previousfilter","newFilter","manualFilters","defaultCanFilter","disableFilters","autoResetFilters","columnDefaultCanFilter","columnDisableFilters","canFilter","found","filteredFlatRows","filteredRowsById","filterRows","filteredRows","filteredSoFar","preFilteredRows","getAutoResetFilters","preFilteredFlatRows","preFilteredRowsById","resetGlobalFilter","setGlobalFilter","useGlobalFilter","globalFilter","manualGlobalFilter","globalFilterValue","autoResetGlobalFilter","disableGlobalFilter","columnDisableGlobalFilter","filterableColumns","globalFilteredRows","globalFilteredFlatRows","globalFilteredRowsById","getAutoResetGlobalFilter","preGlobalFilteredRows","preGlobalFilteredFlatRows","preGlobalFilteredRowsById","sum","aggregatedValues","mid","floor","nums","sort","b","from","Set","size","emptyArray","emptyObject","resetGroupBy","setGroupBy","toggleGroupBy","useGroupBy","getGroupByToggleProps","defaultGetGroupByToggleProps","groupBy","canGroupBy","persist","resolvedGroupBy","groupByColumns","col","g","nonGroupByColumns","isGrouped","groupedIndex","indexOf","defaultUserAggregations","groupByFn","defaultGroupByFn","manualGroupBy","aggregations","userAggregations","autoResetGroupBy","disableGroupBy","defaultCanGroupBy","defaultColumnGroupBy","defaultGroupBy","columnDisableGroupBy","Aggregated","existingGroupBy","groupedFlatRows","groupedRowsById","onlyGroupedFlatRows","onlyGroupedRowsById","nonGroupedFlatRows","nonGroupedRowsById","groupedRows","groupUpRecursively","parentId","rowGroupsMap","entries","groupByVal","leafRows","groupedValues","leafValues","columnValue","aggregateValue","aggregateValueFn","aggregateFn","aggregate","groupByID","subRow","getAutoResetGroupBy","preGroupedRows","preGroupedFlatRow","preGroupedRowsById","allCells","isPlaceholder","isAggregated","resKey","reSplitAlphaNumeric","compareBasic","getRowValueByColumnID","toString","isNaN","rowA","rowB","aa","shift","bb","an","bn","combo","getTime","resetSortBy","setSortBy","toggleSortBy","clearSortBy","sortType","sortDescFirst","useSortBy","getSortByToggleProps","defaultGetSortByToggleProps","isMultiSortEvent","shiftKey","canSort","disableMultiSort","sortBy","sortAction","desc","multi","disableSortRemove","disableMultiRemove","maxMultiSortColCount","existingSortBy","existingIndex","hasDescDefined","newSortBy","splice","orderByFn","defaultOrderByFn","userSortTypes","sortTypes","manualSortBy","defaultCanSort","disableSortBy","autoResetSortBy","defaultColumnCanSort","columnDisableSortBy","columnSort","isSorted","sortedIndex","isSortedDesc","sortedFlatRows","availableSortBy","sortData","sortedData","sortMethod","sortInverted","sortedRows","getAutoResetSortBy","preSortedRows","preSortedFlatRows","funcs","dirs","sortFn","sortInt","resetPage","gotoPage","setPageSize","usePagination","pageSize","newPageIndex","canNavigate","topRowIndex","autoResetPage","userPageCount","manualPagination","getAutoResetPage","ceil","pageOptions","fill","pageStart","pageEnd","canPreviousPage","canNextPage","previousPage","nextPage","resetPivot","togglePivot","_UNSTABLE_usePivotColumns","getPivotToggleProps","defaultGetPivotToggleProps","defaultPivotColumns","canPivot","pivotColumns","setPivot","resolvedPivot","isPivotSource","uniqueValues","add","materialized","sourceColumns","newMaterialized","buildPivotColumns","pivotFilters","pivotColumn","u","columnGroup","PivotHeader","uniqueValue","isPivotGroup","pivotValue","sourceColumn","isPivoted","autoResetPivot","manaulPivot","disablePivot","defaultCanPivot","defaultColumnPivot","defaultPivot","columnDisablePivot","getAutoResetPivot","resetSelectedRows","toggleAllRowsSelected","toggleRowSelected","toggleAllPageRowsSelected","useRowSelect","getToggleRowSelectedProps","defaultGetToggleRowSelectedProps","getToggleAllRowsSelectedProps","defaultGetToggleAllRowsSelectedProps","getToggleAllPageRowsSelectedProps","defaultGetToggleAllPageRowsSelectedProps","manualRowSelectedKey","isSelected","isSomeSelected","isAllRowsSelected","selectedRowIds","isAllPageRowsSelected","setSelected","selectAll","selectSubRows","newSelectedRowIds","handleRowById","autoResetSelectedRows","selectedFlatRows","getRowIsSelected","allChildrenSelected","someSelected","getAutoResetSelectedRows","defaultInitialRowStateAccessor","defaultInitialCellStateAccessor","setRowState","setCellState","resetRowState","useRowState","initialRowStateAccessor","initialCellStateAccessor","rowState","oldRowState","oldCellState","cellState","autoResetRowState","getAutoResetRowState","resetColumnOrder","setColumnOrder","useColumnOrder","columnOrder","columnOrderCopy","columnsCopy","columnsInOrder","targetColumnId","foundIndex","columnStartResizing","columnResizing","columnDoneResizing","resetResize","useResizeColumns","getResizerProps","defaultGetResizerProps","position","onResizeStart","isTouchEvent","touches","headerIdWidths","leafHeaders","recurseHeader","clientX","round","dispatchMove","clientXPos","dispatchEnd","handlersAndEvents","mouse","moveEvent","moveHandler","upEvent","upHandler","removeEventListener","touch","cancelable","stopPropagation","events","passiveIfSupported","supported","window","addEventListener","passive","columnWidth","onMouseDown","onTouchStart","draggable","columnWidths","startX","isResizingColumn","percentageDeltaX","newColumnWidths","headerId","headerWidth","disableResizing","isResizing","autoResetResize","getAutoResetResize","resetResizing","cellStyles","top","useAbsoluteLayout","getRowStyles","totalColumnsWidth","display","boxSizing","useBlockLayout","useFlexLayout","flex","totalColumnsMinWidth","defaultFn","defaultWait","debounceRef","getDefaultFn","getDefaultWait","promise","Promise","resolve","reject","timeout","userColumns","getStateReducer","handler","useReducer","reducerState","allColumnsQueue","initialRows","all","visibleColumnsDep","totalColumnsMaxWidth","render","footerGroups","Table","forwardRef","_ref","bsPrefix","striped","bordered","borderless","hover","variant","responsive","_objectWithoutPropertiesLoose","decoratedBsPrefix","useBootstrapPrefix","classes","classNames","table","createElement","_extends","responsiveClass"],"mappings":"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","file":"static/js/5.75104b95.chunk.js","sourcesContent":["var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactPaginate\"] = factory(require(\"react\"));\n\telse\n\t\troot[\"ReactPaginate\"] = factory(root[\"React\"]);\n})(global, function(__WEBPACK_EXTERNAL_MODULE__1__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 4);\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","module.exports = __WEBPACK_EXTERNAL_MODULE__1__;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","'use strict';\n\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nconst PageView = (props) => {\n  let { pageClassName, pageLinkClassName } = props;\n  const {\n    page,\n    selected,\n    activeClassName,\n    activeLinkClassName,\n    getEventListener,\n    pageSelectedHandler,\n    href,\n    extraAriaContext\n  } = props;\n\n  let ariaLabel =\n    props.ariaLabel ||\n    'Page ' +\n      page +\n      (extraAriaContext ? ' ' + extraAriaContext : '');\n  let ariaCurrent = null;\n\n  if (selected) {\n    ariaCurrent = 'page';\n\n    ariaLabel =\n      props.ariaLabel || 'Page ' + page + ' is your current page';\n\n    if (typeof pageClassName !== 'undefined') {\n      pageClassName = pageClassName + ' ' + activeClassName;\n    } else {\n      pageClassName = activeClassName;\n    }\n\n    if (typeof pageLinkClassName !== 'undefined') {\n      if (typeof activeLinkClassName !== 'undefined') {\n        pageLinkClassName = pageLinkClassName + ' ' + activeLinkClassName;\n      }\n    } else {\n      pageLinkClassName = activeLinkClassName;\n    }\n  }\n\n  return (\n    <li className={pageClassName}>\n      <a\n        role=\"button\"\n        className={pageLinkClassName}\n        href={href}\n        tabIndex=\"0\"\n        aria-label={ariaLabel}\n        aria-current={ariaCurrent}\n        onKeyPress={pageSelectedHandler}\n        {...getEventListener(pageSelectedHandler)}\n      >\n        {page}\n      </a>\n    </li>\n  );\n};\n\nPageView.propTypes = {\n  pageSelectedHandler: PropTypes.func.isRequired,\n  selected: PropTypes.bool.isRequired,\n  pageClassName: PropTypes.string,\n  pageLinkClassName: PropTypes.string,\n  activeClassName: PropTypes.string,\n  activeLinkClassName: PropTypes.string,\n  extraAriaContext: PropTypes.string,\n  href: PropTypes.string,\n  ariaLabel: PropTypes.string,\n  page: PropTypes.number.isRequired,\n  getEventListener: PropTypes.func.isRequired,\n};\n\nexport default PageView;\n","'use strict';\n\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nconst BreakView = (props) => {\n  const { breakLabel, breakClassName, breakLinkClassName, breakHandler, getEventListener } = props;\n  const className = breakClassName || 'break';\n\n  return (\n    <li className={className}>\n      <a\n        className={breakLinkClassName}\n        role=\"button\"\n        tabIndex=\"0\"\n        onKeyPress={breakHandler}\n        {...getEventListener(breakHandler)}\n      >\n        {breakLabel}\n      </a>\n    </li>\n  );\n};\n\nBreakView.propTypes = {\n  breakLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),\n  breakClassName: PropTypes.string,\n  breakLinkClassName: PropTypes.string,\n  breakHandler: PropTypes.func.isRequired,\n  getEventListener: PropTypes.func.isRequired,\n};\n\nexport default BreakView;\n","'use strict';\n\nimport React, { Component } from 'react';\nimport PropTypes from 'prop-types';\nimport PageView from './PageView';\nimport BreakView from './BreakView';\n\nexport default class PaginationBoxView extends Component {\n  static propTypes = {\n    pageCount: PropTypes.number.isRequired,\n    pageRangeDisplayed: PropTypes.number.isRequired,\n    marginPagesDisplayed: PropTypes.number.isRequired,\n    previousLabel: PropTypes.node,\n    previousAriaLabel: PropTypes.string,\n    nextLabel: PropTypes.node,\n    nextAriaLabel: PropTypes.string,\n    breakLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),\n    hrefBuilder: PropTypes.func,\n    onPageChange: PropTypes.func,\n    initialPage: PropTypes.number,\n    forcePage: PropTypes.number,\n    disableInitialCallback: PropTypes.bool,\n    containerClassName: PropTypes.string,\n    pageClassName: PropTypes.string,\n    pageLinkClassName: PropTypes.string,\n    activeClassName: PropTypes.string,\n    activeLinkClassName: PropTypes.string,\n    previousClassName: PropTypes.string,\n    nextClassName: PropTypes.string,\n    previousLinkClassName: PropTypes.string,\n    nextLinkClassName: PropTypes.string,\n    disabledClassName: PropTypes.string,\n    breakClassName: PropTypes.string,\n    breakLinkClassName: PropTypes.string,\n    extraAriaContext: PropTypes.string,\n    ariaLabelBuilder: PropTypes.func,\n    eventListener: PropTypes.string,\n  };\n\n  static defaultProps = {\n    pageCount: 10,\n    pageRangeDisplayed: 2,\n    marginPagesDisplayed: 3,\n    activeClassName: 'selected',\n    previousLabel: 'Previous',\n    previousClassName: 'previous',\n    previousAriaLabel: 'Previous page',\n    nextLabel: 'Next',\n    nextClassName: 'next',\n    nextAriaLabel: 'Next page',\n    breakLabel: '...',\n    disabledClassName: 'disabled',\n    disableInitialCallback: false,\n    eventListener: 'onClick',\n  };\n\n  constructor(props) {\n    super(props);\n\n    let initialSelected;\n    if (props.initialPage) {\n      initialSelected = props.initialPage;\n    } else if (props.forcePage) {\n      initialSelected = props.forcePage;\n    } else {\n      initialSelected = 0;\n    }\n\n    this.state = {\n      selected: initialSelected,\n    };\n  }\n\n  componentDidMount() {\n    const {\n      initialPage,\n      disableInitialCallback,\n      extraAriaContext,\n    } = this.props;\n    // Call the callback with the initialPage item:\n    if (typeof initialPage !== 'undefined' && !disableInitialCallback) {\n      this.callCallback(initialPage);\n    }\n\n    if (extraAriaContext) {\n      console.warn(\n        'DEPRECATED (react-paginate): The extraAriaContext prop is deprecated. You should now use the ariaLabelBuilder instead.'\n      );\n    }\n  }\n\n  componentDidUpdate(prevProps) {\n    if (\n      typeof this.props.forcePage !== 'undefined' &&\n      this.props.forcePage !== prevProps.forcePage\n    ) {\n      this.setState({ selected: this.props.forcePage });\n    }\n  }\n\n  handlePreviousPage = (evt) => {\n    const { selected } = this.state;\n    evt.preventDefault ? evt.preventDefault() : (evt.returnValue = false);\n    if (selected > 0) {\n      this.handlePageSelected(selected - 1, evt);\n    }\n  };\n\n  handleNextPage = (evt) => {\n    const { selected } = this.state;\n    const { pageCount } = this.props;\n\n    evt.preventDefault ? evt.preventDefault() : (evt.returnValue = false);\n    if (selected < pageCount - 1) {\n      this.handlePageSelected(selected + 1, evt);\n    }\n  };\n\n  handlePageSelected = (selected, evt) => {\n    evt.preventDefault ? evt.preventDefault() : (evt.returnValue = false);\n\n    if (this.state.selected === selected) return;\n\n    this.setState({ selected: selected });\n\n    // Call the callback with the new selected item:\n    this.callCallback(selected);\n  };\n\n  getEventListener = (handlerFunction) => {\n    const { eventListener } = this.props;\n    return {\n      [eventListener]: handlerFunction,\n    };\n  }\n\n  getForwardJump() {\n    const { selected } = this.state;\n    const { pageCount, pageRangeDisplayed } = this.props;\n\n    const forwardJump = selected + pageRangeDisplayed;\n    return forwardJump >= pageCount ? pageCount - 1 : forwardJump;\n  }\n\n  getBackwardJump() {\n    const { selected } = this.state;\n    const { pageRangeDisplayed } = this.props;\n\n    const backwardJump = selected - pageRangeDisplayed;\n    return backwardJump < 0 ? 0 : backwardJump;\n  }\n\n  handleBreakClick = (index, evt) => {\n    evt.preventDefault ? evt.preventDefault() : (evt.returnValue = false);\n\n    const { selected } = this.state;\n\n    this.handlePageSelected(\n      selected < index ? this.getForwardJump() : this.getBackwardJump(),\n      evt\n    );\n  };\n\n  hrefBuilder(pageIndex) {\n    const { hrefBuilder, pageCount } = this.props;\n    if (\n      hrefBuilder &&\n      pageIndex !== this.state.selected &&\n      pageIndex >= 0 &&\n      pageIndex < pageCount\n    ) {\n      return hrefBuilder(pageIndex + 1);\n    }\n  }\n\n  ariaLabelBuilder(pageIndex) {\n    const selected = pageIndex === this.state.selected;\n    if (\n      this.props.ariaLabelBuilder &&\n      pageIndex >= 0 &&\n      pageIndex < this.props.pageCount\n    ) {\n      let label = this.props.ariaLabelBuilder(pageIndex + 1, selected);\n      // DEPRECATED: The extraAriaContext prop was used to add additional context\n      // to the aria-label. Users should now use the ariaLabelBuilder instead.\n      if (this.props.extraAriaContext && !selected) {\n        label = label + ' ' + this.props.extraAriaContext;\n      }\n      return label;\n    }\n  }\n\n  callCallback = (selectedItem) => {\n    if (\n      typeof this.props.onPageChange !== 'undefined' &&\n      typeof this.props.onPageChange === 'function'\n    ) {\n      this.props.onPageChange({ selected: selectedItem });\n    }\n  };\n\n  getPageElement(index) {\n    const { selected } = this.state;\n    const {\n      pageClassName,\n      pageLinkClassName,\n      activeClassName,\n      activeLinkClassName,\n      extraAriaContext,\n    } = this.props;\n\n    return (\n      <PageView\n        key={index}\n        pageSelectedHandler={this.handlePageSelected.bind(null, index)}\n        selected={selected === index}\n        pageClassName={pageClassName}\n        pageLinkClassName={pageLinkClassName}\n        activeClassName={activeClassName}\n        activeLinkClassName={activeLinkClassName}\n        extraAriaContext={extraAriaContext}\n        href={this.hrefBuilder(index)}\n        ariaLabel={this.ariaLabelBuilder(index)}\n        page={index + 1}\n        getEventListener={this.getEventListener}\n      />\n    );\n  }\n\n  pagination = () => {\n    const items = [];\n    const {\n      pageRangeDisplayed,\n      pageCount,\n      marginPagesDisplayed,\n      breakLabel,\n      breakClassName,\n      breakLinkClassName,\n    } = this.props;\n\n    const { selected } = this.state;\n\n    if (pageCount <= pageRangeDisplayed) {\n      for (let index = 0; index < pageCount; index++) {\n        items.push(this.getPageElement(index));\n      }\n    } else {\n      let leftSide = pageRangeDisplayed / 2;\n      let rightSide = pageRangeDisplayed - leftSide;\n\n      // If the selected page index is on the default right side of the pagination,\n      // we consider that the new right side is made up of it (= only one break element).\n      // If the selected page index is on the default left side of the pagination,\n      // we consider that the new left side is made up of it (= only one break element).\n      if (selected > pageCount - pageRangeDisplayed / 2) {\n        rightSide = pageCount - selected;\n        leftSide = pageRangeDisplayed - rightSide;\n      } else if (selected < pageRangeDisplayed / 2) {\n        leftSide = selected;\n        rightSide = pageRangeDisplayed - leftSide;\n      }\n\n      let index;\n      let page;\n      let breakView;\n      let createPageView = (index) => this.getPageElement(index);\n\n      for (index = 0; index < pageCount; index++) {\n        page = index + 1;\n\n        // If the page index is lower than the margin defined,\n        // the page has to be displayed on the left side of\n        // the pagination.\n        if (page <= marginPagesDisplayed) {\n          items.push(createPageView(index));\n          continue;\n        }\n\n        // If the page index is greater than the page count\n        // minus the margin defined, the page has to be\n        // displayed on the right side of the pagination.\n        if (page > pageCount - marginPagesDisplayed) {\n          items.push(createPageView(index));\n          continue;\n        }\n\n        // If the page index is near the selected page index\n        // and inside the defined range (pageRangeDisplayed)\n        // we have to display it (it will create the center\n        // part of the pagination).\n        if (index >= selected - leftSide && index <= selected + rightSide) {\n          items.push(createPageView(index));\n          continue;\n        }\n\n        // If the page index doesn't meet any of the conditions above,\n        // we check if the last item of the current \"items\" array\n        // is a break element. If not, we add a break element, else,\n        // we do nothing (because we don't want to display the page).\n        if (breakLabel && items[items.length - 1] !== breakView) {\n          breakView = (\n            <BreakView\n              key={index}\n              breakLabel={breakLabel}\n              breakClassName={breakClassName}\n              breakLinkClassName={breakLinkClassName}\n              breakHandler={this.handleBreakClick.bind(null, index)}\n              getEventListener={this.getEventListener}\n            />\n          );\n          items.push(breakView);\n        }\n      }\n    }\n\n    return items;\n  };\n\n  render() {\n    const {\n      disabledClassName,\n      pageCount,\n      containerClassName,\n      previousLabel,\n      previousClassName,\n      previousLinkClassName,\n      previousAriaLabel,\n      nextLabel,\n      nextClassName,\n      nextLinkClassName,\n      nextAriaLabel,\n    } = this.props;\n\n    const { selected } = this.state;\n\n    const previousClasses =\n      previousClassName + (selected === 0 ? ` ${disabledClassName}` : '');\n    const nextClasses =\n      nextClassName +\n      (selected === pageCount - 1 ? ` ${disabledClassName}` : '');\n\n    const previousAriaDisabled = selected === 0 ? 'true' : 'false';\n    const nextAriaDisabled = selected === pageCount - 1 ? 'true' : 'false';\n\n    return (\n      <ul className={containerClassName}>\n        <li className={previousClasses}>\n          <a\n            className={previousLinkClassName}\n            href={this.hrefBuilder(selected - 1)}\n            tabIndex=\"0\"\n            role=\"button\"\n            onKeyPress={this.handlePreviousPage}\n            aria-disabled={previousAriaDisabled}\n            aria-label={previousAriaLabel}\n            {...this.getEventListener(this.handlePreviousPage)}\n          >\n            {previousLabel}\n          </a>\n        </li>\n\n        {this.pagination()}\n\n        <li className={nextClasses}>\n          <a\n            className={nextLinkClassName}\n            href={this.hrefBuilder(selected + 1)}\n            tabIndex=\"0\"\n            role=\"button\"\n            onKeyPress={this.handleNextPage}\n            aria-disabled={nextAriaDisabled}\n            aria-label={nextAriaLabel}\n            {...this.getEventListener(this.handleNextPage)}\n          >\n            {nextLabel}\n          </a>\n        </li>\n      </ul>\n    );\n  }\n}\n","import PaginationBoxView from './PaginationBoxView';\n\nexport default PaginationBoxView;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","if (process.env.NODE_ENV === 'production') {\n  module.exports = require('./dist/react-table.production.min.js')\n} else {\n  module.exports = require('./dist/react-table.development.js')\n}\n","import React from 'react'\n\nlet renderErr = 'Renderer Error ☝️'\n\nexport const actions = {\n  init: 'init',\n}\n\nexport const defaultRenderer = ({ value = '' }) => value;\nexport const emptyRenderer = () => <>&nbsp;</>;\n\nexport const defaultColumn = {\n  Cell: defaultRenderer,\n  width: 150,\n  minWidth: 0,\n  maxWidth: Number.MAX_SAFE_INTEGER,\n}\n\nfunction mergeProps(...propList) {\n  return propList.reduce((props, next) => {\n    const { style, className, ...rest } = next\n\n    props = {\n      ...props,\n      ...rest,\n    }\n\n    if (style) {\n      props.style = props.style\n        ? { ...(props.style || {}), ...(style || {}) }\n        : style\n    }\n\n    if (className) {\n      props.className = props.className\n        ? props.className + ' ' + className\n        : className\n    }\n\n    if (props.className === '') {\n      delete props.className\n    }\n\n    return props\n  }, {})\n}\n\nfunction handlePropGetter(prevProps, userProps, meta) {\n  // Handle a lambda, pass it the previous props\n  if (typeof userProps === 'function') {\n    return handlePropGetter({}, userProps(prevProps, meta))\n  }\n\n  // Handle an array, merge each item as separate props\n  if (Array.isArray(userProps)) {\n    return mergeProps(prevProps, ...userProps)\n  }\n\n  // Handle an object by default, merge the two objects\n  return mergeProps(prevProps, userProps)\n}\n\nexport const makePropGetter = (hooks, meta = {}) => {\n  return (userProps = {}) =>\n    [...hooks, userProps].reduce(\n      (prev, next) =>\n        handlePropGetter(prev, next, {\n          ...meta,\n          userProps,\n        }),\n      {}\n    )\n}\n\nexport const reduceHooks = (hooks, initial, meta = {}, allowUndefined) =>\n  hooks.reduce((prev, next) => {\n    const nextValue = next(prev, meta)\n    if (process.env.NODE_ENV !== 'production') {\n      if (!allowUndefined && typeof nextValue === 'undefined') {\n        console.info(next)\n        throw new Error(\n          'React Table: A reducer hook ☝️ just returned undefined! This is not allowed.'\n        )\n      }\n    }\n    return nextValue\n  }, initial)\n\nexport const loopHooks = (hooks, context, meta = {}) =>\n  hooks.forEach(hook => {\n    const nextValue = hook(context, meta)\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof nextValue !== 'undefined') {\n        console.info(hook, nextValue)\n        throw new Error(\n          'React Table: A loop-type hook ☝️ just returned a value! This is not allowed.'\n        )\n      }\n    }\n  })\n\nexport function ensurePluginOrder(plugins, befores, pluginName, afters) {\n  if (process.env.NODE_ENV !== 'production' && afters) {\n    throw new Error(\n      `Defining plugins in the \"after\" section of ensurePluginOrder is no longer supported (see plugin ${pluginName})`\n    )\n  }\n  const pluginIndex = plugins.findIndex(\n    plugin => plugin.pluginName === pluginName\n  )\n\n  if (pluginIndex === -1) {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error(`The plugin \"${pluginName}\" was not found in the plugin list!\nThis usually means you need to need to name your plugin hook by setting the 'pluginName' property of the hook function, eg:\n\n  ${pluginName}.pluginName = '${pluginName}'\n`)\n    }\n  }\n\n  befores.forEach(before => {\n    const beforeIndex = plugins.findIndex(\n      plugin => plugin.pluginName === before\n    )\n    if (beforeIndex > -1 && beforeIndex > pluginIndex) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          `React Table: The ${pluginName} plugin hook must be placed after the ${before} plugin hook!`\n        )\n      }\n    }\n  })\n}\n\nexport function functionalUpdate(updater, old) {\n  return typeof updater === 'function' ? updater(old) : updater\n}\n\nexport function useGetLatest(obj) {\n  const ref = React.useRef()\n  ref.current = obj\n\n  return React.useCallback(() => ref.current, [])\n}\n\n// SSR has issues with useLayoutEffect still, so use useEffect during SSR\nexport const safeUseLayoutEffect =\n  typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\nexport function useMountedLayoutEffect(fn, deps) {\n  const mountedRef = React.useRef(false)\n\n  safeUseLayoutEffect(() => {\n    if (mountedRef.current) {\n      fn()\n    }\n    mountedRef.current = true\n    // eslint-disable-next-line\n  }, deps)\n}\n\nexport function useAsyncDebounce(defaultFn, defaultWait = 0) {\n  const debounceRef = React.useRef({})\n\n  const getDefaultFn = useGetLatest(defaultFn)\n  const getDefaultWait = useGetLatest(defaultWait)\n\n  return React.useCallback(\n    async (...args) => {\n      if (!debounceRef.current.promise) {\n        debounceRef.current.promise = new Promise((resolve, reject) => {\n          debounceRef.current.resolve = resolve\n          debounceRef.current.reject = reject\n        })\n      }\n\n      if (debounceRef.current.timeout) {\n        clearTimeout(debounceRef.current.timeout)\n      }\n\n      debounceRef.current.timeout = setTimeout(async () => {\n        delete debounceRef.current.timeout\n        try {\n          debounceRef.current.resolve(await getDefaultFn()(...args))\n        } catch (err) {\n          debounceRef.current.reject(err)\n        } finally {\n          delete debounceRef.current.promise\n        }\n      }, getDefaultWait())\n\n      return debounceRef.current.promise\n    },\n    [getDefaultFn, getDefaultWait]\n  )\n}\n\nexport function makeRenderer(instance, column, meta = {}) {\n  return (type, userProps = {}) => {\n    const Comp = typeof type === 'string' ? column[type] : type\n\n    if (typeof Comp === 'undefined') {\n      console.info(column)\n      throw new Error(renderErr)\n    }\n\n    return flexRender(Comp, { ...instance, column, ...meta, ...userProps })\n  }\n}\n\nexport function flexRender(Comp, props) {\n  return isReactComponent(Comp) ? <Comp {...props} /> : Comp\n}\n\nfunction isReactComponent(component) {\n  return (\n    isClassComponent(component) ||\n    typeof component === 'function' ||\n    isExoticComponent(component)\n  )\n}\n\nfunction isClassComponent(component) {\n  return (\n    typeof component === 'function' &&\n    (() => {\n      const proto = Object.getPrototypeOf(component)\n      return proto.prototype && proto.prototype.isReactComponent\n    })()\n  )\n}\n\nfunction isExoticComponent(component) {\n  return (\n    typeof component === 'object' &&\n    typeof component.$$typeof === 'symbol' &&\n    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)\n  )\n}\n","import { defaultColumn, emptyRenderer } from './publicUtils'\n\n// Find the depth of the columns\nexport function findMaxDepth(columns, depth = 0) {\n  return columns.reduce((prev, curr) => {\n    if (curr.columns) {\n      return Math.max(prev, findMaxDepth(curr.columns, depth + 1))\n    }\n    return depth\n  }, 0)\n}\n\n// Build the visible columns, headers and flat column list\nexport function linkColumnStructure(columns, parent, depth = 0) {\n  return columns.map(column => {\n    column = {\n      ...column,\n      parent,\n      depth,\n    }\n\n    assignColumnAccessor(column)\n\n    if (column.columns) {\n      column.columns = linkColumnStructure(column.columns, column, depth + 1)\n    }\n    return column\n  })\n}\n\nexport function flattenColumns(columns) {\n  return flattenBy(columns, 'columns')\n}\n\nexport function assignColumnAccessor(column) {\n  // First check for string accessor\n  let { id, accessor, Header } = column\n\n  if (typeof accessor === 'string') {\n    id = id || accessor\n    const accessorPath = accessor.split('.')\n    accessor = row => getBy(row, accessorPath)\n  }\n\n  if (!id && typeof Header === 'string' && Header) {\n    id = Header\n  }\n\n  if (!id && column.columns) {\n    console.error(column)\n    throw new Error('A column ID (or unique \"Header\" value) is required!')\n  }\n\n  if (!id) {\n    console.error(column)\n    throw new Error('A column ID (or string accessor) is required!')\n  }\n\n  Object.assign(column, {\n    id,\n    accessor,\n  })\n\n  return column\n}\n\nexport function decorateColumn(column, userDefaultColumn) {\n  if (!userDefaultColumn) {\n    throw new Error()\n  }\n  Object.assign(column, {\n    // Make sure there is a fallback header, just in case\n    Header: emptyRenderer,\n    Footer: emptyRenderer,\n    ...defaultColumn,\n    ...userDefaultColumn,\n    ...column,\n  })\n\n  Object.assign(column, {\n    originalWidth: column.width,\n  })\n\n  return column\n}\n\n// Build the header groups from the bottom up\nexport function makeHeaderGroups(\n  allColumns,\n  defaultColumn,\n  additionalHeaderProperties = () => ({})\n) {\n  const headerGroups = []\n\n  let scanColumns = allColumns\n\n  let uid = 0\n  const getUID = () => uid++\n\n  while (scanColumns.length) {\n    // The header group we are creating\n    const headerGroup = {\n      headers: [],\n    }\n\n    // The parent columns we're going to scan next\n    const parentColumns = []\n\n    const hasParents = scanColumns.some(d => d.parent)\n\n    // Scan each column for parents\n    scanColumns.forEach(column => {\n      // What is the latest (last) parent column?\n      let latestParentColumn = [...parentColumns].reverse()[0]\n\n      let newParent\n\n      if (hasParents) {\n        // If the column has a parent, add it if necessary\n        if (column.parent) {\n          newParent = {\n            ...column.parent,\n            originalId: column.parent.id,\n            id: `${column.parent.id}_${getUID()}`,\n            headers: [column],\n            ...additionalHeaderProperties(column),\n          }\n        } else {\n          // If other columns have parents, we'll need to add a place holder if necessary\n          const originalId = `${column.id}_placeholder`\n          newParent = decorateColumn(\n            {\n              originalId,\n              id: `${column.id}_placeholder_${getUID()}`,\n              placeholderOf: column,\n              headers: [column],\n              ...additionalHeaderProperties(column),\n            },\n            defaultColumn\n          )\n        }\n\n        // If the resulting parent columns are the same, just add\n        // the column and increment the header span\n        if (\n          latestParentColumn &&\n          latestParentColumn.originalId === newParent.originalId\n        ) {\n          latestParentColumn.headers.push(column)\n        } else {\n          parentColumns.push(newParent)\n        }\n      }\n\n      headerGroup.headers.push(column)\n    })\n\n    headerGroups.push(headerGroup)\n\n    // Start scanning the parent columns\n    scanColumns = parentColumns\n  }\n\n  return headerGroups.reverse()\n}\n\nconst pathObjCache = new Map()\n\nexport function getBy(obj, path, def) {\n  if (!path) {\n    return obj\n  }\n  const cacheKey = typeof path === 'function' ? path : JSON.stringify(path)\n\n  const pathObj =\n    pathObjCache.get(cacheKey) ||\n    (() => {\n      const pathObj = makePathArray(path)\n      pathObjCache.set(cacheKey, pathObj)\n      return pathObj\n    })()\n\n  let val\n\n  try {\n    val = pathObj.reduce((cursor, pathPart) => cursor[pathPart], obj)\n  } catch (e) {\n    // continue regardless of error\n  }\n  return typeof val !== 'undefined' ? val : def\n}\n\nexport function getFirstDefined(...args) {\n  for (let i = 0; i < args.length; i += 1) {\n    if (typeof args[i] !== 'undefined') {\n      return args[i]\n    }\n  }\n}\n\nexport function getElementDimensions(element) {\n  const rect = element.getBoundingClientRect()\n  const style = window.getComputedStyle(element)\n  const margins = {\n    left: parseInt(style.marginLeft),\n    right: parseInt(style.marginRight),\n  }\n  const padding = {\n    left: parseInt(style.paddingLeft),\n    right: parseInt(style.paddingRight),\n  }\n  return {\n    left: Math.ceil(rect.left),\n    width: Math.ceil(rect.width),\n    outerWidth: Math.ceil(\n      rect.width + margins.left + margins.right + padding.left + padding.right\n    ),\n    marginLeft: margins.left,\n    marginRight: margins.right,\n    paddingLeft: padding.left,\n    paddingRight: padding.right,\n    scrollWidth: element.scrollWidth,\n  }\n}\n\nexport function isFunction(a) {\n  if (typeof a === 'function') {\n    return a\n  }\n}\n\nexport function flattenBy(arr, key) {\n  const flat = []\n\n  const recurse = arr => {\n    arr.forEach(d => {\n      if (!d[key]) {\n        flat.push(d)\n      } else {\n        recurse(d[key])\n      }\n    })\n  }\n\n  recurse(arr)\n\n  return flat\n}\n\nexport function expandRows(\n  rows,\n  { manualExpandedKey, expanded, expandSubRows = true }\n) {\n  const expandedRows = []\n\n  const handleRow = row => {\n    row.isExpanded =\n      (row.original && row.original[manualExpandedKey]) || expanded[row.id]\n\n    row.canExpand = row.subRows && !!row.subRows.length\n\n    expandedRows.push(row)\n\n    if (expandSubRows && row.subRows && row.subRows.length && row.isExpanded) {\n      row.subRows.forEach(handleRow)\n    }\n  }\n\n  rows.forEach(handleRow)\n\n  return expandedRows\n}\n\nexport function getFilterMethod(filter, userFilterTypes, filterTypes) {\n  return (\n    isFunction(filter) ||\n    userFilterTypes[filter] ||\n    filterTypes[filter] ||\n    filterTypes.text\n  )\n}\n\nexport function shouldAutoRemoveFilter(autoRemove, value, column) {\n  return autoRemove ? autoRemove(value, column) : typeof value === 'undefined'\n}\n\nexport function unpreparedAccessWarning() {\n  throw new Error(\n    'React-Table: You have not called prepareRow(row) one or more rows you are attempting to render.'\n  )\n}\n\nlet passiveSupported = null\nexport function passiveEventSupported() {\n  // memoize support to avoid adding multiple test events\n  if (typeof passiveSupported === 'boolean') return passiveSupported\n\n  let supported = false\n  try {\n    const options = {\n      get passive() {\n        supported = true\n        return false\n      },\n    }\n\n    window.addEventListener('test', null, options)\n    window.removeEventListener('test', null, options)\n  } catch (err) {\n    supported = false\n  }\n  passiveSupported = supported\n  return passiveSupported\n}\n\n//\n\nconst reOpenBracket = /\\[/g\nconst reCloseBracket = /\\]/g\n\nfunction makePathArray(obj) {\n  return (\n    flattenDeep(obj)\n      // remove all periods in parts\n      .map(d => String(d).replace('.', '_'))\n      // join parts using period\n      .join('.')\n      // replace brackets with periods\n      .replace(reOpenBracket, '.')\n      .replace(reCloseBracket, '')\n      // split it back out on periods\n      .split('.')\n  )\n}\n\nfunction flattenDeep(arr, newArr = []) {\n  if (!Array.isArray(arr)) {\n    newArr.push(arr)\n  } else {\n    for (let i = 0; i < arr.length; i += 1) {\n      flattenDeep(arr[i], newArr)\n    }\n  }\n  return newArr\n}\n","const defaultGetTableProps = props => ({\n  role: 'table',\n  ...props,\n})\n\nconst defaultGetTableBodyProps = props => ({\n  role: 'rowgroup',\n  ...props,\n})\n\nconst defaultGetHeaderProps = (props, { column }) => ({\n  key: `header_${column.id}`,\n  colSpan: column.totalVisibleHeaderCount,\n  role: 'columnheader',\n  ...props,\n})\n\nconst defaultGetFooterProps = (props, { column }) => ({\n  key: `footer_${column.id}`,\n  colSpan: column.totalVisibleHeaderCount,\n  ...props,\n})\n\nconst defaultGetHeaderGroupProps = (props, { index }) => ({\n  key: `headerGroup_${index}`,\n  role: 'row',\n  ...props,\n})\n\nconst defaultGetFooterGroupProps = (props, { index }) => ({\n  key: `footerGroup_${index}`,\n  ...props,\n})\n\nconst defaultGetRowProps = (props, { row }) => ({\n  key: `row_${row.id}`,\n  role: 'row',\n  ...props,\n})\n\nconst defaultGetCellProps = (props, { cell }) => ({\n  key: `cell_${cell.row.id}_${cell.column.id}`,\n  role: 'cell',\n  ...props,\n})\n\nexport default function makeDefaultPluginHooks() {\n  return {\n    useOptions: [],\n    stateReducers: [],\n    useControlledState: [],\n    columns: [],\n    columnsDeps: [],\n    allColumns: [],\n    allColumnsDeps: [],\n    accessValue: [],\n    materializedColumns: [],\n    materializedColumnsDeps: [],\n    useInstanceAfterData: [],\n    visibleColumns: [],\n    visibleColumnsDeps: [],\n    headerGroups: [],\n    headerGroupsDeps: [],\n    useInstanceBeforeDimensions: [],\n    useInstance: [],\n    prepareRow: [],\n    getTableProps: [defaultGetTableProps],\n    getTableBodyProps: [defaultGetTableBodyProps],\n    getHeaderGroupProps: [defaultGetHeaderGroupProps],\n    getFooterGroupProps: [defaultGetFooterGroupProps],\n    getHeaderProps: [defaultGetHeaderProps],\n    getFooterProps: [defaultGetFooterProps],\n    getRowProps: [defaultGetRowProps],\n    getCellProps: [defaultGetCellProps],\n    useFinalInstance: [],\n  }\n}\n","import React from 'react'\n\nimport {\n  actions,\n  functionalUpdate,\n  useGetLatest,\n  makePropGetter,\n  useMountedLayoutEffect,\n} from '../publicUtils'\n\nactions.resetHiddenColumns = 'resetHiddenColumns'\nactions.toggleHideColumn = 'toggleHideColumn'\nactions.setHiddenColumns = 'setHiddenColumns'\nactions.toggleHideAllColumns = 'toggleHideAllColumns'\n\nexport const useColumnVisibility = hooks => {\n  hooks.getToggleHiddenProps = [defaultGetToggleHiddenProps]\n  hooks.getToggleHideAllColumnsProps = [defaultGetToggleHideAllColumnsProps]\n\n  hooks.stateReducers.push(reducer)\n  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)\n  hooks.headerGroupsDeps.push((deps, { instance }) => [\n    ...deps,\n    instance.state.hiddenColumns,\n  ])\n  hooks.useInstance.push(useInstance)\n}\n\nuseColumnVisibility.pluginName = 'useColumnVisibility'\n\nconst defaultGetToggleHiddenProps = (props, { column }) => [\n  props,\n  {\n    onChange: e => {\n      column.toggleHidden(!e.target.checked)\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    checked: column.isVisible,\n    title: 'Toggle Column Visible',\n  },\n]\n\nconst defaultGetToggleHideAllColumnsProps = (props, { instance }) => [\n  props,\n  {\n    onChange: e => {\n      instance.toggleHideAllColumns(!e.target.checked)\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    checked: !instance.allColumnsHidden && !instance.state.hiddenColumns.length,\n    title: 'Toggle All Columns Hidden',\n    indeterminate:\n      !instance.allColumnsHidden && instance.state.hiddenColumns.length,\n  },\n]\n\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      hiddenColumns: [],\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetHiddenColumns) {\n    return {\n      ...state,\n      hiddenColumns: instance.initialState.hiddenColumns || [],\n    }\n  }\n\n  if (action.type === actions.toggleHideColumn) {\n    const should =\n      typeof action.value !== 'undefined'\n        ? action.value\n        : !state.hiddenColumns.includes(action.columnId)\n\n    const hiddenColumns = should\n      ? [...state.hiddenColumns, action.columnId]\n      : state.hiddenColumns.filter(d => d !== action.columnId)\n\n    return {\n      ...state,\n      hiddenColumns,\n    }\n  }\n\n  if (action.type === actions.setHiddenColumns) {\n    return {\n      ...state,\n      hiddenColumns: functionalUpdate(action.value, state.hiddenColumns),\n    }\n  }\n\n  if (action.type === actions.toggleHideAllColumns) {\n    const shouldAll =\n      typeof action.value !== 'undefined'\n        ? action.value\n        : !state.hiddenColumns.length\n\n    return {\n      ...state,\n      hiddenColumns: shouldAll ? instance.allColumns.map(d => d.id) : [],\n    }\n  }\n}\n\nfunction useInstanceBeforeDimensions(instance) {\n  const {\n    headers,\n    state: { hiddenColumns },\n  } = instance\n\n  const isMountedRef = React.useRef(false)\n\n  if (!isMountedRef.current) {\n  }\n\n  const handleColumn = (column, parentVisible) => {\n    column.isVisible = parentVisible && !hiddenColumns.includes(column.id)\n\n    let totalVisibleHeaderCount = 0\n\n    if (column.headers && column.headers.length) {\n      column.headers.forEach(\n        subColumn =>\n          (totalVisibleHeaderCount += handleColumn(subColumn, column.isVisible))\n      )\n    } else {\n      totalVisibleHeaderCount = column.isVisible ? 1 : 0\n    }\n\n    column.totalVisibleHeaderCount = totalVisibleHeaderCount\n\n    return totalVisibleHeaderCount\n  }\n\n  let totalVisibleHeaderCount = 0\n\n  headers.forEach(\n    subHeader => (totalVisibleHeaderCount += handleColumn(subHeader, true))\n  )\n}\n\nfunction useInstance(instance) {\n  const {\n    columns,\n    flatHeaders,\n    dispatch,\n    allColumns,\n    getHooks,\n    state: { hiddenColumns },\n    autoResetHiddenColumns = true,\n  } = instance\n\n  const getInstance = useGetLatest(instance)\n\n  const allColumnsHidden = allColumns.length === hiddenColumns.length\n\n  const toggleHideColumn = React.useCallback(\n    (columnId, value) =>\n      dispatch({ type: actions.toggleHideColumn, columnId, value }),\n    [dispatch]\n  )\n\n  const setHiddenColumns = React.useCallback(\n    value => dispatch({ type: actions.setHiddenColumns, value }),\n    [dispatch]\n  )\n\n  const toggleHideAllColumns = React.useCallback(\n    value => dispatch({ type: actions.toggleHideAllColumns, value }),\n    [dispatch]\n  )\n\n  const getToggleHideAllColumnsProps = makePropGetter(\n    getHooks().getToggleHideAllColumnsProps,\n    { instance: getInstance() }\n  )\n\n  flatHeaders.forEach(column => {\n    column.toggleHidden = value => {\n      dispatch({\n        type: actions.toggleHideColumn,\n        columnId: column.id,\n        value,\n      })\n    }\n\n    column.getToggleHiddenProps = makePropGetter(\n      getHooks().getToggleHiddenProps,\n      {\n        instance: getInstance(),\n        column,\n      }\n    )\n  })\n\n  const getAutoResetHiddenColumns = useGetLatest(autoResetHiddenColumns)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetHiddenColumns()) {\n      dispatch({ type: actions.resetHiddenColumns })\n    }\n  }, [dispatch, columns])\n\n  Object.assign(instance, {\n    allColumnsHidden,\n    toggleHideColumn,\n    setHiddenColumns,\n    toggleHideAllColumns,\n    getToggleHideAllColumnsProps,\n  })\n}\n","import React from 'react'\n\n//\n\nimport {\n  linkColumnStructure,\n  flattenColumns,\n  assignColumnAccessor,\n  unpreparedAccessWarning,\n  makeHeaderGroups,\n  decorateColumn,\n} from '../utils'\n\nimport {\n  useGetLatest,\n  reduceHooks,\n  actions,\n  loopHooks,\n  makePropGetter,\n  makeRenderer,\n} from '../publicUtils'\n\nimport makeDefaultPluginHooks from '../makeDefaultPluginHooks'\n\nimport { useColumnVisibility } from './useColumnVisibility'\n\nconst defaultInitialState = {}\nconst defaultColumnInstance = {}\nconst defaultReducer = (state, action, prevState) => state\nconst defaultGetSubRows = (row, index) => row.subRows || []\nconst defaultGetRowId = (row, index, parent) =>\n  `${parent ? [parent.id, index].join('.') : index}`\nconst defaultUseControlledState = d => d\n\nfunction applyDefaults(props) {\n  const {\n    initialState = defaultInitialState,\n    defaultColumn = defaultColumnInstance,\n    getSubRows = defaultGetSubRows,\n    getRowId = defaultGetRowId,\n    stateReducer = defaultReducer,\n    useControlledState = defaultUseControlledState,\n    ...rest\n  } = props\n\n  return {\n    ...rest,\n    initialState,\n    defaultColumn,\n    getSubRows,\n    getRowId,\n    stateReducer,\n    useControlledState,\n  }\n}\n\nexport const useTable = (props, ...plugins) => {\n  // Apply default props\n  props = applyDefaults(props)\n\n  // Add core plugins\n  plugins = [useColumnVisibility, ...plugins]\n\n  // Create the table instance\n  let instanceRef = React.useRef({})\n\n  // Create a getter for the instance (helps avoid a lot of potential memory leaks)\n  const getInstance = useGetLatest(instanceRef.current)\n\n  // Assign the props, plugins and hooks to the instance\n  Object.assign(getInstance(), {\n    ...props,\n    plugins,\n    hooks: makeDefaultPluginHooks(),\n  })\n\n  // Allow plugins to register hooks as early as possible\n  plugins.filter(Boolean).forEach(plugin => {\n    plugin(getInstance().hooks)\n  })\n\n  // Consume all hooks and make a getter for them\n  const getHooks = useGetLatest(getInstance().hooks)\n  getInstance().getHooks = getHooks\n  delete getInstance().hooks\n\n  // Allow useOptions hooks to modify the options coming into the table\n  Object.assign(\n    getInstance(),\n    reduceHooks(getHooks().useOptions, applyDefaults(props))\n  )\n\n  const {\n    data,\n    columns: userColumns,\n    initialState,\n    defaultColumn,\n    getSubRows,\n    getRowId,\n    stateReducer,\n    useControlledState,\n  } = getInstance()\n\n  // Setup user reducer ref\n  const getStateReducer = useGetLatest(stateReducer)\n\n  // Build the reducer\n  const reducer = React.useCallback(\n    (state, action) => {\n      // Detect invalid actions\n      if (!action.type) {\n        console.info({ action })\n        throw new Error('Unknown Action 👆')\n      }\n\n      // Reduce the state from all plugin reducers\n      return [\n        ...getHooks().stateReducers,\n        // Allow the user to add their own state reducer(s)\n        ...(Array.isArray(getStateReducer())\n          ? getStateReducer()\n          : [getStateReducer()]),\n      ].reduce(\n        (s, handler) => handler(s, action, state, getInstance()) || s,\n        state\n      )\n    },\n    [getHooks, getStateReducer, getInstance]\n  )\n\n  // Start the reducer\n  const [reducerState, dispatch] = React.useReducer(reducer, undefined, () =>\n    reducer(initialState, { type: actions.init })\n  )\n\n  // Allow the user to control the final state with hooks\n  const state = reduceHooks(\n    [...getHooks().useControlledState, useControlledState],\n    reducerState,\n    { instance: getInstance() }\n  )\n\n  Object.assign(getInstance(), {\n    state,\n    dispatch,\n  })\n\n  // Decorate All the columns\n  const columns = React.useMemo(\n    () =>\n      linkColumnStructure(\n        reduceHooks(getHooks().columns, userColumns, {\n          instance: getInstance(),\n        })\n      ),\n    [\n      getHooks,\n      getInstance,\n      userColumns,\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      ...reduceHooks(getHooks().columnsDeps, [], { instance: getInstance() }),\n    ]\n  )\n  getInstance().columns = columns\n\n  // Get the flat list of all columns and allow hooks to decorate\n  // those columns (and trigger this memoization via deps)\n  let allColumns = React.useMemo(\n    () =>\n      reduceHooks(getHooks().allColumns, flattenColumns(columns), {\n        instance: getInstance(),\n      }).map(assignColumnAccessor),\n    [\n      columns,\n      getHooks,\n      getInstance,\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      ...reduceHooks(getHooks().allColumnsDeps, [], {\n        instance: getInstance(),\n      }),\n    ]\n  )\n  getInstance().allColumns = allColumns\n\n  // Access the row model using initial columns\n  const [rows, flatRows, rowsById] = React.useMemo(() => {\n    let rows = []\n    let flatRows = []\n    const rowsById = {}\n\n    const allColumnsQueue = [...allColumns]\n\n    while (allColumnsQueue.length) {\n      const column = allColumnsQueue.shift()\n      accessRowsForColumn({\n        data,\n        rows,\n        flatRows,\n        rowsById,\n        column,\n        getRowId,\n        getSubRows,\n        accessValueHooks: getHooks().accessValue,\n        getInstance,\n      })\n    }\n\n    return [rows, flatRows, rowsById]\n  }, [allColumns, data, getRowId, getSubRows, getHooks, getInstance])\n\n  Object.assign(getInstance(), {\n    rows,\n    initialRows: [...rows],\n    flatRows,\n    rowsById,\n    // materializedColumns,\n  })\n\n  loopHooks(getHooks().useInstanceAfterData, getInstance())\n\n  // Get the flat list of all columns AFTER the rows\n  // have been access, and allow hooks to decorate\n  // those columns (and trigger this memoization via deps)\n  let visibleColumns = React.useMemo(\n    () =>\n      reduceHooks(getHooks().visibleColumns, allColumns, {\n        instance: getInstance(),\n      }).map(d => decorateColumn(d, defaultColumn)),\n    [\n      getHooks,\n      allColumns,\n      getInstance,\n      defaultColumn,\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      ...reduceHooks(getHooks().visibleColumnsDeps, [], {\n        instance: getInstance(),\n      }),\n    ]\n  )\n\n  // Combine new visible columns with all columns\n  allColumns = React.useMemo(() => {\n    const columns = [...visibleColumns]\n\n    allColumns.forEach(column => {\n      if (!columns.find(d => d.id === column.id)) {\n        columns.push(column)\n      }\n    })\n\n    return columns\n  }, [allColumns, visibleColumns])\n  getInstance().allColumns = allColumns\n\n  if (process.env.NODE_ENV !== 'production') {\n    const duplicateColumns = allColumns.filter((column, i) => {\n      return allColumns.findIndex(d => d.id === column.id) !== i\n    })\n\n    if (duplicateColumns.length) {\n      console.info(allColumns)\n      throw new Error(\n        `Duplicate columns were found with ids: \"${duplicateColumns\n          .map(d => d.id)\n          .join(', ')}\" in the columns array above`\n      )\n    }\n  }\n\n  // Make the headerGroups\n  const headerGroups = React.useMemo(\n    () =>\n      reduceHooks(\n        getHooks().headerGroups,\n        makeHeaderGroups(visibleColumns, defaultColumn),\n        getInstance()\n      ),\n    [\n      getHooks,\n      visibleColumns,\n      defaultColumn,\n      getInstance,\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      ...reduceHooks(getHooks().headerGroupsDeps, [], {\n        instance: getInstance(),\n      }),\n    ]\n  )\n  getInstance().headerGroups = headerGroups\n\n  // Get the first level of headers\n  const headers = React.useMemo(\n    () => (headerGroups.length ? headerGroups[0].headers : []),\n    [headerGroups]\n  )\n  getInstance().headers = headers\n\n  // Provide a flat header list for utilities\n  getInstance().flatHeaders = headerGroups.reduce(\n    (all, headerGroup) => [...all, ...headerGroup.headers],\n    []\n  )\n\n  loopHooks(getHooks().useInstanceBeforeDimensions, getInstance())\n\n  // Filter columns down to visible ones\n  const visibleColumnsDep = visibleColumns\n    .filter(d => d.isVisible)\n    .map(d => d.id)\n    .sort()\n    .join('_')\n\n  visibleColumns = React.useMemo(\n    () => visibleColumns.filter(d => d.isVisible),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [visibleColumns, visibleColumnsDep]\n  )\n  getInstance().visibleColumns = visibleColumns\n\n  // Header Visibility is needed by this point\n  const [\n    totalColumnsMinWidth,\n    totalColumnsWidth,\n    totalColumnsMaxWidth,\n  ] = calculateHeaderWidths(headers)\n\n  getInstance().totalColumnsMinWidth = totalColumnsMinWidth\n  getInstance().totalColumnsWidth = totalColumnsWidth\n  getInstance().totalColumnsMaxWidth = totalColumnsMaxWidth\n\n  loopHooks(getHooks().useInstance, getInstance())\n\n  // Each materialized header needs to be assigned a render function and other\n  // prop getter properties here.\n  ;[...getInstance().flatHeaders, ...getInstance().allColumns].forEach(\n    column => {\n      // Give columns/headers rendering power\n      column.render = makeRenderer(getInstance(), column)\n\n      // Give columns/headers a default getHeaderProps\n      column.getHeaderProps = makePropGetter(getHooks().getHeaderProps, {\n        instance: getInstance(),\n        column,\n      })\n\n      // Give columns/headers a default getFooterProps\n      column.getFooterProps = makePropGetter(getHooks().getFooterProps, {\n        instance: getInstance(),\n        column,\n      })\n    }\n  )\n\n  getInstance().headerGroups = React.useMemo(\n    () =>\n      headerGroups.filter((headerGroup, i) => {\n        // Filter out any headers and headerGroups that don't have visible columns\n        headerGroup.headers = headerGroup.headers.filter(column => {\n          const recurse = headers =>\n            headers.filter(column => {\n              if (column.headers) {\n                return recurse(column.headers)\n              }\n              return column.isVisible\n            }).length\n          if (column.headers) {\n            return recurse(column.headers)\n          }\n          return column.isVisible\n        })\n\n        // Give headerGroups getRowProps\n        if (headerGroup.headers.length) {\n          headerGroup.getHeaderGroupProps = makePropGetter(\n            getHooks().getHeaderGroupProps,\n            { instance: getInstance(), headerGroup, index: i }\n          )\n\n          headerGroup.getFooterGroupProps = makePropGetter(\n            getHooks().getFooterGroupProps,\n            { instance: getInstance(), headerGroup, index: i }\n          )\n\n          return true\n        }\n\n        return false\n      }),\n    [headerGroups, getInstance, getHooks]\n  )\n\n  getInstance().footerGroups = [...getInstance().headerGroups].reverse()\n\n  // The prepareRow function is absolutely necessary and MUST be called on\n  // any rows the user wishes to be displayed.\n\n  getInstance().prepareRow = React.useCallback(\n    row => {\n      row.getRowProps = makePropGetter(getHooks().getRowProps, {\n        instance: getInstance(),\n        row,\n      })\n\n      // Build the visible cells for each row\n      row.allCells = allColumns.map(column => {\n        const value = row.values[column.id]\n\n        const cell = {\n          column,\n          row,\n          value,\n        }\n\n        // Give each cell a getCellProps base\n        cell.getCellProps = makePropGetter(getHooks().getCellProps, {\n          instance: getInstance(),\n          cell,\n        })\n\n        // Give each cell a renderer function (supports multiple renderers)\n        cell.render = makeRenderer(getInstance(), column, {\n          row,\n          cell,\n          value,\n        })\n\n        return cell\n      })\n\n      row.cells = visibleColumns.map(column =>\n        row.allCells.find(cell => cell.column.id === column.id)\n      )\n\n      // need to apply any row specific hooks (useExpanded requires this)\n      loopHooks(getHooks().prepareRow, row, { instance: getInstance() })\n    },\n    [getHooks, getInstance, allColumns, visibleColumns]\n  )\n\n  getInstance().getTableProps = makePropGetter(getHooks().getTableProps, {\n    instance: getInstance(),\n  })\n\n  getInstance().getTableBodyProps = makePropGetter(\n    getHooks().getTableBodyProps,\n    {\n      instance: getInstance(),\n    }\n  )\n\n  loopHooks(getHooks().useFinalInstance, getInstance())\n\n  return getInstance()\n}\n\nfunction calculateHeaderWidths(headers, left = 0) {\n  let sumTotalMinWidth = 0\n  let sumTotalWidth = 0\n  let sumTotalMaxWidth = 0\n  let sumTotalFlexWidth = 0\n\n  headers.forEach(header => {\n    let { headers: subHeaders } = header\n\n    header.totalLeft = left\n\n    if (subHeaders && subHeaders.length) {\n      const [\n        totalMinWidth,\n        totalWidth,\n        totalMaxWidth,\n        totalFlexWidth,\n      ] = calculateHeaderWidths(subHeaders, left)\n      header.totalMinWidth = totalMinWidth\n      header.totalWidth = totalWidth\n      header.totalMaxWidth = totalMaxWidth\n      header.totalFlexWidth = totalFlexWidth\n    } else {\n      header.totalMinWidth = header.minWidth\n      header.totalWidth = Math.min(\n        Math.max(header.minWidth, header.width),\n        header.maxWidth\n      )\n      header.totalMaxWidth = header.maxWidth\n      header.totalFlexWidth = header.canResize ? header.totalWidth : 0\n    }\n    if (header.isVisible) {\n      left += header.totalWidth\n      sumTotalMinWidth += header.totalMinWidth\n      sumTotalWidth += header.totalWidth\n      sumTotalMaxWidth += header.totalMaxWidth\n      sumTotalFlexWidth += header.totalFlexWidth\n    }\n  })\n\n  return [sumTotalMinWidth, sumTotalWidth, sumTotalMaxWidth, sumTotalFlexWidth]\n}\n\nfunction accessRowsForColumn({\n  data,\n  rows,\n  flatRows,\n  rowsById,\n  column,\n  getRowId,\n  getSubRows,\n  accessValueHooks,\n  getInstance,\n}) {\n  // Access the row's data column-by-column\n  // We do it this way so we can incrementally add materialized\n  // columns after the first pass and avoid excessive looping\n  const accessRow = (originalRow, rowIndex, depth = 0, parent, parentRows) => {\n    // Keep the original reference around\n    const original = originalRow\n\n    const id = getRowId(originalRow, rowIndex, parent)\n\n    let row = rowsById[id]\n\n    // If the row hasn't been created, let's make it\n    if (!row) {\n      row = {\n        id,\n        original,\n        index: rowIndex,\n        depth,\n        cells: [{}], // This is a dummy cell\n      }\n\n      // Override common array functions (and the dummy cell's getCellProps function)\n      // to show an error if it is accessed without calling prepareRow\n      row.cells.map = unpreparedAccessWarning\n      row.cells.filter = unpreparedAccessWarning\n      row.cells.forEach = unpreparedAccessWarning\n      row.cells[0].getCellProps = unpreparedAccessWarning\n\n      // Create the cells and values\n      row.values = {}\n\n      // Push this row into the parentRows array\n      parentRows.push(row)\n      // Keep track of every row in a flat array\n      flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowsById[id] = row\n\n      // Get the original subrows\n      row.originalSubRows = getSubRows(originalRow, rowIndex)\n\n      // Then recursively access them\n      if (row.originalSubRows) {\n        const subRows = []\n        row.originalSubRows.forEach((d, i) =>\n          accessRow(d, i, depth + 1, row, subRows)\n        )\n        // Keep the new subRows array on the row\n        row.subRows = subRows\n      }\n    } else if (row.subRows) {\n      // If the row exists, then it's already been accessed\n      // Keep recursing, but don't worry about passing the\n      // accumlator array (those rows already exist)\n      row.originalSubRows.forEach((d, i) => accessRow(d, i, depth + 1, row))\n    }\n\n    // If the column has an accessor, use it to get a value\n    if (column.accessor) {\n      row.values[column.id] = column.accessor(originalRow, rowIndex, row)\n    }\n\n    // Allow plugins to manipulate the column value\n    row.values[column.id] = reduceHooks(\n      accessValueHooks,\n      row.values[column.id],\n      {\n        row,\n        column,\n        instance: getInstance(),\n      },\n      true\n    )\n  }\n\n  data.forEach((originalRow, rowIndex) =>\n    accessRow(originalRow, rowIndex, 0, undefined, rows)\n  )\n}\n","import React from 'react'\n\nimport { expandRows } from '../utils'\n\nimport {\n  useGetLatest,\n  actions,\n  useMountedLayoutEffect,\n  makePropGetter,\n  ensurePluginOrder,\n} from '../publicUtils'\n\n// Actions\nactions.resetExpanded = 'resetExpanded'\nactions.toggleRowExpanded = 'toggleRowExpanded'\nactions.toggleAllRowsExpanded = 'toggleAllRowsExpanded'\n\nexport const useExpanded = hooks => {\n  hooks.getToggleAllRowsExpandedProps = [defaultGetToggleAllRowsExpandedProps]\n  hooks.getToggleRowExpandedProps = [defaultGetToggleRowExpandedProps]\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n  hooks.prepareRow.push(prepareRow)\n}\n\nuseExpanded.pluginName = 'useExpanded'\n\nconst defaultGetToggleAllRowsExpandedProps = (props, { instance }) => [\n  props,\n  {\n    onClick: e => {\n      instance.toggleAllRowsExpanded()\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    title: 'Toggle All Rows Expanded',\n  },\n]\n\nconst defaultGetToggleRowExpandedProps = (props, { row }) => [\n  props,\n  {\n    onClick: () => {\n      row.toggleRowExpanded()\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    title: 'Toggle Row Expanded',\n  },\n]\n\n// Reducer\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      expanded: {},\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetExpanded) {\n    return {\n      ...state,\n      expanded: instance.initialState.expanded || {},\n    }\n  }\n\n  if (action.type === actions.toggleAllRowsExpanded) {\n    const { value } = action\n    const { isAllRowsExpanded, rowsById } = instance\n\n    const expandAll = typeof value !== 'undefined' ? value : !isAllRowsExpanded\n\n    if (expandAll) {\n      const expanded = {}\n\n      Object.keys(rowsById).forEach(rowId => {\n        expanded[rowId] = true\n      })\n\n      return {\n        ...state,\n        expanded,\n      }\n    }\n\n    return {\n      ...state,\n      expanded: {},\n    }\n  }\n\n  if (action.type === actions.toggleRowExpanded) {\n    const { id, value: setExpanded } = action\n    const exists = state.expanded[id]\n\n    const shouldExist =\n      typeof setExpanded !== 'undefined' ? setExpanded : !exists\n\n    if (!exists && shouldExist) {\n      return {\n        ...state,\n        expanded: {\n          ...state.expanded,\n          [id]: true,\n        },\n      }\n    } else if (exists && !shouldExist) {\n      const { [id]: _, ...rest } = state.expanded\n      return {\n        ...state,\n        expanded: rest,\n      }\n    } else {\n      return state\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    rowsById,\n    manualExpandedKey = 'expanded',\n    paginateExpandedRows = true,\n    expandSubRows = true,\n    autoResetExpanded = true,\n    getHooks,\n    plugins,\n    state: { expanded },\n    dispatch,\n  } = instance\n\n  ensurePluginOrder(\n    plugins,\n    ['useSortBy', 'useGroupBy', 'usePivotColumns', 'useGlobalFilter'],\n    'useExpanded'\n  )\n\n  const getAutoResetExpanded = useGetLatest(autoResetExpanded)\n\n  let isAllRowsExpanded = Boolean(\n    Object.keys(rowsById).length && Object.keys(expanded).length\n  )\n\n  if (isAllRowsExpanded) {\n    if (Object.keys(rowsById).some(id => !expanded[id])) {\n      isAllRowsExpanded = false\n    }\n  }\n\n  // Bypass any effects from firing when this changes\n  useMountedLayoutEffect(() => {\n    if (getAutoResetExpanded()) {\n      dispatch({ type: actions.resetExpanded })\n    }\n  }, [dispatch, data])\n\n  const toggleRowExpanded = React.useCallback(\n    (id, value) => {\n      dispatch({ type: actions.toggleRowExpanded, id, value })\n    },\n    [dispatch]\n  )\n\n  const toggleAllRowsExpanded = React.useCallback(\n    value => dispatch({ type: actions.toggleAllRowsExpanded, value }),\n    [dispatch]\n  )\n\n  const expandedRows = React.useMemo(() => {\n    if (paginateExpandedRows) {\n      return expandRows(rows, { manualExpandedKey, expanded, expandSubRows })\n    }\n\n    return rows\n  }, [paginateExpandedRows, rows, manualExpandedKey, expanded, expandSubRows])\n\n  const expandedDepth = React.useMemo(() => findExpandedDepth(expanded), [\n    expanded,\n  ])\n\n  const getInstance = useGetLatest(instance)\n\n  const getToggleAllRowsExpandedProps = makePropGetter(\n    getHooks().getToggleAllRowsExpandedProps,\n    { instance: getInstance() }\n  )\n\n  Object.assign(instance, {\n    preExpandedRows: rows,\n    expandedRows,\n    rows: expandedRows,\n    expandedDepth,\n    isAllRowsExpanded,\n    toggleRowExpanded,\n    toggleAllRowsExpanded,\n    getToggleAllRowsExpandedProps,\n  })\n}\n\nfunction prepareRow(row, { instance: { getHooks }, instance }) {\n  row.toggleRowExpanded = set => instance.toggleRowExpanded(row.id, set)\n\n  row.getToggleRowExpandedProps = makePropGetter(\n    getHooks().getToggleRowExpandedProps,\n    {\n      instance,\n      row,\n    }\n  )\n}\n\nfunction findExpandedDepth(expanded) {\n  let maxDepth = 0\n\n  Object.keys(expanded).forEach(id => {\n    const splitId = id.split('.')\n    maxDepth = Math.max(maxDepth, splitId.length)\n  })\n\n  return maxDepth\n}\n","export const text = (rows, ids, filterValue) => {\n  rows = rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return String(rowValue)\n        .toLowerCase()\n        .includes(String(filterValue).toLowerCase())\n    })\n  })\n  return rows\n}\n\ntext.autoRemove = val => !val\n\nexport const exactText = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return rowValue !== undefined\n        ? String(rowValue).toLowerCase() === String(filterValue).toLowerCase()\n        : true\n    })\n  })\n}\n\nexactText.autoRemove = val => !val\n\nexport const exactTextCase = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return rowValue !== undefined\n        ? String(rowValue) === String(filterValue)\n        : true\n    })\n  })\n}\n\nexactTextCase.autoRemove = val => !val\n\nexport const includes = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return rowValue.includes(filterValue)\n    })\n  })\n}\n\nincludes.autoRemove = val => !val || !val.length\n\nexport const includesAll = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return (\n        rowValue &&\n        rowValue.length &&\n        filterValue.every(val => rowValue.includes(val))\n      )\n    })\n  })\n}\n\nincludesAll.autoRemove = val => !val || !val.length\n\nexport const includesSome = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return (\n        rowValue &&\n        rowValue.length &&\n        filterValue.some(val => rowValue.includes(val))\n      )\n    })\n  })\n}\n\nincludesSome.autoRemove = val => !val || !val.length\n\nexport const includesValue = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return filterValue.includes(rowValue)\n    })\n  })\n}\n\nincludesValue.autoRemove = val => !val || !val.length\n\nexport const exact = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return rowValue === filterValue\n    })\n  })\n}\n\nexact.autoRemove = val => typeof val === 'undefined'\n\nexport const equals = (rows, ids, filterValue) => {\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      // eslint-disable-next-line eqeqeq\n      return rowValue == filterValue\n    })\n  })\n}\n\nequals.autoRemove = val => val == null\n\nexport const between = (rows, ids, filterValue) => {\n  let [min, max] = filterValue || []\n\n  min = typeof min === 'number' ? min : -Infinity\n  max = typeof max === 'number' ? max : Infinity\n\n  if (min > max) {\n    const temp = min\n    min = max\n    max = temp\n  }\n\n  return rows.filter(row => {\n    return ids.some(id => {\n      const rowValue = row.values[id]\n      return rowValue >= min && rowValue <= max\n    })\n  })\n}\n\nbetween.autoRemove = val =>\n  !val || (typeof val[0] !== 'number' && typeof val[1] !== 'number')\n","import React from 'react'\n\nimport {\n  getFirstDefined,\n  getFilterMethod,\n  shouldAutoRemoveFilter,\n} from '../utils'\n\nimport {\n  actions,\n  useGetLatest,\n  functionalUpdate,\n  useMountedLayoutEffect,\n} from '../publicUtils'\n\nimport * as filterTypes from '../filterTypes'\n\n// Actions\nactions.resetFilters = 'resetFilters'\nactions.setFilter = 'setFilter'\nactions.setAllFilters = 'setAllFilters'\n\nexport const useFilters = hooks => {\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n}\n\nuseFilters.pluginName = 'useFilters'\n\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      filters: [],\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetFilters) {\n    return {\n      ...state,\n      filters: instance.initialState.filters || [],\n    }\n  }\n\n  if (action.type === actions.setFilter) {\n    const { columnId, filterValue } = action\n    const { allColumns, filterTypes: userFilterTypes } = instance\n\n    const column = allColumns.find(d => d.id === columnId)\n\n    if (!column) {\n      throw new Error(\n        `React-Table: Could not find a column with id: ${columnId}`\n      )\n    }\n\n    const filterMethod = getFilterMethod(\n      column.filter,\n      userFilterTypes || {},\n      filterTypes\n    )\n\n    const previousfilter = state.filters.find(d => d.id === columnId)\n\n    const newFilter = functionalUpdate(\n      filterValue,\n      previousfilter && previousfilter.value\n    )\n\n    //\n    if (shouldAutoRemoveFilter(filterMethod.autoRemove, newFilter, column)) {\n      return {\n        ...state,\n        filters: state.filters.filter(d => d.id !== columnId),\n      }\n    }\n\n    if (previousfilter) {\n      return {\n        ...state,\n        filters: state.filters.map(d => {\n          if (d.id === columnId) {\n            return { id: columnId, value: newFilter }\n          }\n          return d\n        }),\n      }\n    }\n\n    return {\n      ...state,\n      filters: [...state.filters, { id: columnId, value: newFilter }],\n    }\n  }\n\n  if (action.type === actions.setAllFilters) {\n    const { filters } = action\n    const { allColumns, filterTypes: userFilterTypes } = instance\n\n    return {\n      ...state,\n      // Filter out undefined values\n      filters: functionalUpdate(filters, state.filters).filter(filter => {\n        const column = allColumns.find(d => d.id === filter.id)\n        const filterMethod = getFilterMethod(\n          column.filter,\n          userFilterTypes || {},\n          filterTypes\n        )\n\n        if (\n          shouldAutoRemoveFilter(filterMethod.autoRemove, filter.value, column)\n        ) {\n          return false\n        }\n        return true\n      }),\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    flatRows,\n    rowsById,\n    allColumns,\n    filterTypes: userFilterTypes,\n    manualFilters,\n    defaultCanFilter = false,\n    disableFilters,\n    state: { filters },\n    dispatch,\n    autoResetFilters = true,\n  } = instance\n\n  const setFilter = React.useCallback(\n    (columnId, filterValue) => {\n      dispatch({ type: actions.setFilter, columnId, filterValue })\n    },\n    [dispatch]\n  )\n\n  const setAllFilters = React.useCallback(\n    filters => {\n      dispatch({\n        type: actions.setAllFilters,\n        filters,\n      })\n    },\n    [dispatch]\n  )\n\n  allColumns.forEach(column => {\n    const {\n      id,\n      accessor,\n      defaultCanFilter: columnDefaultCanFilter,\n      disableFilters: columnDisableFilters,\n    } = column\n\n    // Determine if a column is filterable\n    column.canFilter = accessor\n      ? getFirstDefined(\n          columnDisableFilters === true ? false : undefined,\n          disableFilters === true ? false : undefined,\n          true\n        )\n      : getFirstDefined(columnDefaultCanFilter, defaultCanFilter, false)\n\n    // Provide the column a way of updating the filter value\n    column.setFilter = val => setFilter(column.id, val)\n\n    // Provide the current filter value to the column for\n    // convenience\n    const found = filters.find(d => d.id === id)\n    column.filterValue = found && found.value\n  })\n\n  const [\n    filteredRows,\n    filteredFlatRows,\n    filteredRowsById,\n  ] = React.useMemo(() => {\n    if (manualFilters || !filters.length) {\n      return [rows, flatRows, rowsById]\n    }\n\n    const filteredFlatRows = []\n    const filteredRowsById = {}\n\n    // Filters top level and nested rows\n    const filterRows = (rows, depth = 0) => {\n      let filteredRows = rows\n\n      filteredRows = filters.reduce(\n        (filteredSoFar, { id: columnId, value: filterValue }) => {\n          // Find the filters column\n          const column = allColumns.find(d => d.id === columnId)\n\n          if (!column) {\n            return filteredSoFar\n          }\n\n          if (depth === 0) {\n            column.preFilteredRows = filteredSoFar\n          }\n\n          const filterMethod = getFilterMethod(\n            column.filter,\n            userFilterTypes || {},\n            filterTypes\n          )\n\n          if (!filterMethod) {\n            console.warn(\n              `Could not find a valid 'column.filter' for column with the ID: ${column.id}.`\n            )\n            return filteredSoFar\n          }\n\n          // Pass the rows, id, filterValue and column to the filterMethod\n          // to get the filtered rows back\n          column.filteredRows = filterMethod(\n            filteredSoFar,\n            [columnId],\n            filterValue\n          )\n\n          return column.filteredRows\n        },\n        rows\n      )\n\n      // Apply the filter to any subRows\n      // We technically could do this recursively in the above loop,\n      // but that would severely hinder the API for the user, since they\n      // would be required to do that recursion in some scenarios\n      filteredRows.forEach(row => {\n        filteredFlatRows.push(row)\n        filteredRowsById[row.id] = row\n        if (!row.subRows) {\n          return\n        }\n\n        row.subRows =\n          row.subRows && row.subRows.length > 0\n            ? filterRows(row.subRows, depth + 1)\n            : row.subRows\n      })\n\n      return filteredRows\n    }\n\n    return [filterRows(rows), filteredFlatRows, filteredRowsById]\n  }, [\n    manualFilters,\n    filters,\n    rows,\n    flatRows,\n    rowsById,\n    allColumns,\n    userFilterTypes,\n  ])\n\n  React.useMemo(() => {\n    // Now that each filtered column has it's partially filtered rows,\n    // lets assign the final filtered rows to all of the other columns\n    const nonFilteredColumns = allColumns.filter(\n      column => !filters.find(d => d.id === column.id)\n    )\n\n    // This essentially enables faceted filter options to be built easily\n    // using every column's preFilteredRows value\n    nonFilteredColumns.forEach(column => {\n      column.preFilteredRows = filteredRows\n      column.filteredRows = filteredRows\n    })\n  }, [filteredRows, filters, allColumns])\n\n  const getAutoResetFilters = useGetLatest(autoResetFilters)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetFilters()) {\n      dispatch({ type: actions.resetFilters })\n    }\n  }, [dispatch, manualFilters ? null : data])\n\n  Object.assign(instance, {\n    preFilteredRows: rows,\n    preFilteredFlatRows: flatRows,\n    preFilteredRowsById: rowsById,\n    filteredRows,\n    filteredFlatRows,\n    filteredRowsById,\n    rows: filteredRows,\n    flatRows: filteredFlatRows,\n    rowsById: filteredRowsById,\n    setFilter,\n    setAllFilters,\n  })\n}\n","import React from 'react'\n\nimport {\n  getFilterMethod,\n  shouldAutoRemoveFilter,\n  getFirstDefined,\n} from '../utils'\n\nimport {\n  actions,\n  useMountedLayoutEffect,\n  functionalUpdate,\n  useGetLatest,\n} from '../publicUtils'\n\nimport * as filterTypes from '../filterTypes'\n\n// Actions\nactions.resetGlobalFilter = 'resetGlobalFilter'\nactions.setGlobalFilter = 'setGlobalFilter'\n\nexport const useGlobalFilter = hooks => {\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n}\n\nuseGlobalFilter.pluginName = 'useGlobalFilter'\n\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.resetGlobalFilter) {\n    return {\n      ...state,\n      globalFilter: instance.initialState.globalFilter || undefined,\n    }\n  }\n\n  if (action.type === actions.setGlobalFilter) {\n    const { filterValue } = action\n    const { userFilterTypes } = instance\n\n    const filterMethod = getFilterMethod(\n      instance.globalFilter,\n      userFilterTypes || {},\n      filterTypes\n    )\n\n    const newFilter = functionalUpdate(filterValue, state.globalFilter)\n\n    //\n    if (shouldAutoRemoveFilter(filterMethod.autoRemove, newFilter)) {\n      const { globalFilter, ...stateWithoutGlobalFilter } = state\n      return stateWithoutGlobalFilter\n    }\n\n    return {\n      ...state,\n      globalFilter: newFilter,\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    flatRows,\n    rowsById,\n    allColumns,\n    filterTypes: userFilterTypes,\n    globalFilter,\n    manualGlobalFilter,\n    state: { globalFilter: globalFilterValue },\n    dispatch,\n    autoResetGlobalFilter = true,\n    disableGlobalFilter,\n  } = instance\n\n  const setGlobalFilter = React.useCallback(\n    filterValue => {\n      dispatch({ type: actions.setGlobalFilter, filterValue })\n    },\n    [dispatch]\n  )\n\n  // TODO: Create a filter cache for incremental high speed multi-filtering\n  // This gets pretty complicated pretty fast, since you have to maintain a\n  // cache for each row group (top-level rows, and each row's recursive subrows)\n  // This would make multi-filtering a lot faster though. Too far?\n\n  const [\n    globalFilteredRows,\n    globalFilteredFlatRows,\n    globalFilteredRowsById,\n  ] = React.useMemo(() => {\n    if (manualGlobalFilter || typeof globalFilterValue === 'undefined') {\n      return [rows, flatRows, rowsById]\n    }\n\n    const filteredFlatRows = []\n    const filteredRowsById = {}\n\n    const filterMethod = getFilterMethod(\n      globalFilter,\n      userFilterTypes || {},\n      filterTypes\n    )\n\n    if (!filterMethod) {\n      console.warn(`Could not find a valid 'globalFilter' option.`)\n      return rows\n    }\n\n    allColumns.forEach(column => {\n      const { disableGlobalFilter: columnDisableGlobalFilter } = column\n\n      column.canFilter = getFirstDefined(\n        columnDisableGlobalFilter === true ? false : undefined,\n        disableGlobalFilter === true ? false : undefined,\n        true\n      )\n    })\n\n    const filterableColumns = allColumns.filter(c => c.canFilter === true)\n\n    // Filters top level and nested rows\n    const filterRows = filteredRows => {\n      filteredRows = filterMethod(\n        filteredRows,\n        filterableColumns.map(d => d.id),\n        globalFilterValue\n      )\n\n      filteredRows.forEach(row => {\n        filteredFlatRows.push(row)\n        filteredRowsById[row.id] = row\n\n        row.subRows =\n          row.subRows && row.subRows.length\n            ? filterRows(row.subRows)\n            : row.subRows\n      })\n\n      return filteredRows\n    }\n\n    return [filterRows(rows), filteredFlatRows, filteredRowsById]\n  }, [\n    manualGlobalFilter,\n    globalFilterValue,\n    globalFilter,\n    userFilterTypes,\n    allColumns,\n    rows,\n    flatRows,\n    rowsById,\n    disableGlobalFilter,\n  ])\n\n  const getAutoResetGlobalFilter = useGetLatest(autoResetGlobalFilter)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetGlobalFilter()) {\n      dispatch({ type: actions.resetGlobalFilter })\n    }\n  }, [dispatch, manualGlobalFilter ? null : data])\n\n  Object.assign(instance, {\n    preGlobalFilteredRows: rows,\n    preGlobalFilteredFlatRows: flatRows,\n    preGlobalFilteredRowsById: rowsById,\n    globalFilteredRows,\n    globalFilteredFlatRows,\n    globalFilteredRowsById,\n    rows: globalFilteredRows,\n    flatRows: globalFilteredFlatRows,\n    rowsById: globalFilteredRowsById,\n    setGlobalFilter,\n    disableGlobalFilter,\n  })\n}\n","export function sum(values, aggregatedValues) {\n  // It's faster to just add the aggregations together instead of\n  // process leaf nodes individually\n  return aggregatedValues.reduce(\n    (sum, next) => sum + (typeof next === 'number' ? next : 0),\n    0\n  )\n}\n\nexport function min(values) {\n  let min = 0\n\n  values.forEach(value => {\n    if (typeof value === 'number') {\n      min = Math.min(min, value)\n    }\n  })\n\n  return min\n}\n\nexport function max(values) {\n  let max = 0\n\n  values.forEach(value => {\n    if (typeof value === 'number') {\n      max = Math.max(max, value)\n    }\n  })\n\n  return max\n}\n\nexport function minMax(values) {\n  let min = 0\n  let max = 0\n\n  values.forEach(value => {\n    if (typeof value === 'number') {\n      min = Math.min(min, value)\n      max = Math.max(max, value)\n    }\n  })\n\n  return `${min}..${max}`\n}\n\nexport function average(values) {\n  return sum(null, values) / values.length\n}\n\nexport function median(values) {\n  if (!values.length) {\n    return null\n  }\n\n  const mid = Math.floor(values.length / 2)\n  const nums = [...values].sort((a, b) => a - b)\n  return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2\n}\n\nexport function unique(values) {\n  return Array.from(new Set(values).values())\n}\n\nexport function uniqueCount(values) {\n  return new Set(values).size\n}\n\nexport function count(values) {\n  return values.length\n}\n","import React from 'react'\n\nimport * as aggregations from '../aggregations'\n\nimport { getFirstDefined, flattenBy } from '../utils'\n\nimport {\n  actions,\n  makePropGetter,\n  ensurePluginOrder,\n  useMountedLayoutEffect,\n  useGetLatest,\n} from '../publicUtils'\n\nconst emptyArray = []\nconst emptyObject = {}\n\n// Actions\nactions.resetGroupBy = 'resetGroupBy'\nactions.setGroupBy = 'setGroupBy'\nactions.toggleGroupBy = 'toggleGroupBy'\n\nexport const useGroupBy = hooks => {\n  hooks.getGroupByToggleProps = [defaultGetGroupByToggleProps]\n  hooks.stateReducers.push(reducer)\n  hooks.visibleColumnsDeps.push((deps, { instance }) => [\n    ...deps,\n    instance.state.groupBy,\n  ])\n  hooks.visibleColumns.push(visibleColumns)\n  hooks.useInstance.push(useInstance)\n  hooks.prepareRow.push(prepareRow)\n}\n\nuseGroupBy.pluginName = 'useGroupBy'\n\nconst defaultGetGroupByToggleProps = (props, { header }) => [\n  props,\n  {\n    onClick: header.canGroupBy\n      ? e => {\n          e.persist()\n          header.toggleGroupBy()\n        }\n      : undefined,\n    style: {\n      cursor: header.canGroupBy ? 'pointer' : undefined,\n    },\n    title: 'Toggle GroupBy',\n  },\n]\n\n// Reducer\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      groupBy: [],\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetGroupBy) {\n    return {\n      ...state,\n      groupBy: instance.initialState.groupBy || [],\n    }\n  }\n\n  if (action.type === actions.setGroupBy) {\n    const { value } = action\n    return {\n      ...state,\n      groupBy: value,\n    }\n  }\n\n  if (action.type === actions.toggleGroupBy) {\n    const { columnId, value: setGroupBy } = action\n\n    const resolvedGroupBy =\n      typeof setGroupBy !== 'undefined'\n        ? setGroupBy\n        : !state.groupBy.includes(columnId)\n\n    if (resolvedGroupBy) {\n      return {\n        ...state,\n        groupBy: [...state.groupBy, columnId],\n      }\n    }\n\n    return {\n      ...state,\n      groupBy: state.groupBy.filter(d => d !== columnId),\n    }\n  }\n}\n\nfunction visibleColumns(\n  columns,\n  {\n    instance: {\n      state: { groupBy },\n    },\n  }\n) {\n  // Sort grouped columns to the start of the column list\n  // before the headers are built\n\n  const groupByColumns = groupBy\n    .map(g => columns.find(col => col.id === g))\n    .filter(Boolean)\n\n  const nonGroupByColumns = columns.filter(col => !groupBy.includes(col.id))\n\n  columns = [...groupByColumns, ...nonGroupByColumns]\n\n  columns.forEach(column => {\n    column.isGrouped = groupBy.includes(column.id)\n    column.groupedIndex = groupBy.indexOf(column.id)\n  })\n\n  return columns\n}\n\nconst defaultUserAggregations = {}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    flatRows,\n    rowsById,\n    allColumns,\n    flatHeaders,\n    groupByFn = defaultGroupByFn,\n    manualGroupBy,\n    aggregations: userAggregations = defaultUserAggregations,\n    plugins,\n    state: { groupBy },\n    dispatch,\n    autoResetGroupBy = true,\n    disableGroupBy,\n    defaultCanGroupBy,\n    getHooks,\n  } = instance\n\n  ensurePluginOrder(plugins, ['useColumnOrder', 'useFilters'], 'useGroupBy')\n\n  const getInstance = useGetLatest(instance)\n\n  allColumns.forEach(column => {\n    const {\n      accessor,\n      defaultGroupBy: defaultColumnGroupBy,\n      disableGroupBy: columnDisableGroupBy,\n    } = column\n\n    column.canGroupBy = accessor\n      ? getFirstDefined(\n          column.canGroupBy,\n          columnDisableGroupBy === true ? false : undefined,\n          disableGroupBy === true ? false : undefined,\n          true\n        )\n      : getFirstDefined(\n          column.canGroupBy,\n          defaultColumnGroupBy,\n          defaultCanGroupBy,\n          false\n        )\n\n    if (column.canGroupBy) {\n      column.toggleGroupBy = () => instance.toggleGroupBy(column.id)\n    }\n\n    column.Aggregated = column.Aggregated || column.Cell\n  })\n\n  const toggleGroupBy = React.useCallback(\n    (columnId, value) => {\n      dispatch({ type: actions.toggleGroupBy, columnId, value })\n    },\n    [dispatch]\n  )\n\n  const setGroupBy = React.useCallback(\n    value => {\n      dispatch({ type: actions.setGroupBy, value })\n    },\n    [dispatch]\n  )\n\n  flatHeaders.forEach(header => {\n    header.getGroupByToggleProps = makePropGetter(\n      getHooks().getGroupByToggleProps,\n      { instance: getInstance(), header }\n    )\n  })\n\n  const [\n    groupedRows,\n    groupedFlatRows,\n    groupedRowsById,\n    onlyGroupedFlatRows,\n    onlyGroupedRowsById,\n    nonGroupedFlatRows,\n    nonGroupedRowsById,\n  ] = React.useMemo(() => {\n    if (manualGroupBy || !groupBy.length) {\n      return [\n        rows,\n        flatRows,\n        rowsById,\n        emptyArray,\n        emptyObject,\n        flatRows,\n        rowsById,\n      ]\n    }\n\n    // Ensure that the list of filtered columns exist\n    const existingGroupBy = groupBy.filter(g =>\n      allColumns.find(col => col.id === g)\n    )\n\n    // Find the columns that can or are aggregating\n    // Uses each column to aggregate rows into a single value\n    const aggregateRowsToValues = (leafRows, groupedRows, depth) => {\n      const values = {}\n\n      allColumns.forEach(column => {\n        // Don't aggregate columns that are in the groupBy\n        if (existingGroupBy.includes(column.id)) {\n          values[column.id] = groupedRows[0]\n            ? groupedRows[0].values[column.id]\n            : null\n          return\n        }\n\n        // Get the columnValues to aggregate\n        const groupedValues = groupedRows.map(row => row.values[column.id])\n\n        // Get the columnValues to aggregate\n        const leafValues = leafRows.map(row => {\n          let columnValue = row.values[column.id]\n\n          if (!depth && column.aggregateValue) {\n            const aggregateValueFn =\n              typeof column.aggregateValue === 'function'\n                ? column.aggregateValue\n                : userAggregations[column.aggregateValue] ||\n                  aggregations[column.aggregateValue]\n\n            if (!aggregateValueFn) {\n              console.info({ column })\n              throw new Error(\n                `React Table: Invalid column.aggregateValue option for column listed above`\n              )\n            }\n\n            columnValue = aggregateValueFn(columnValue, row, column)\n          }\n          return columnValue\n        })\n\n        // Aggregate the values\n        let aggregateFn =\n          typeof column.aggregate === 'function'\n            ? column.aggregate\n            : userAggregations[column.aggregate] ||\n              aggregations[column.aggregate]\n\n        if (aggregateFn) {\n          values[column.id] = aggregateFn(leafValues, groupedValues)\n        } else if (column.aggregate) {\n          console.info({ column })\n          throw new Error(\n            `React Table: Invalid column.aggregate option for column listed above`\n          )\n        } else {\n          values[column.id] = null\n        }\n      })\n\n      return values\n    }\n\n    let groupedFlatRows = []\n    const groupedRowsById = {}\n    const onlyGroupedFlatRows = []\n    const onlyGroupedRowsById = {}\n    const nonGroupedFlatRows = []\n    const nonGroupedRowsById = {}\n\n    // Recursively group the data\n    const groupUpRecursively = (rows, depth = 0, parentId) => {\n      // This is the last level, just return the rows\n      if (depth === existingGroupBy.length) {\n        return rows\n      }\n\n      const columnId = existingGroupBy[depth]\n\n      // Group the rows together for this level\n      let rowGroupsMap = groupByFn(rows, columnId)\n\n      // Peform aggregations for each group\n      const aggregatedGroupedRows = Object.entries(rowGroupsMap).map(\n        ([groupByVal, groupedRows], index) => {\n          let id = `${columnId}:${groupByVal}`\n          id = parentId ? `${parentId}>${id}` : id\n\n          // First, Recurse to group sub rows before aggregation\n          const subRows = groupUpRecursively(groupedRows, depth + 1, id)\n\n          // Flatten the leaf rows of the rows in this group\n          const leafRows = depth\n            ? flattenBy(groupedRows, 'leafRows')\n            : groupedRows\n\n          const values = aggregateRowsToValues(leafRows, groupedRows, depth)\n\n          const row = {\n            id,\n            isGrouped: true,\n            groupByID: columnId,\n            groupByVal,\n            values,\n            subRows,\n            leafRows,\n            depth,\n            index,\n          }\n\n          subRows.forEach(subRow => {\n            groupedFlatRows.push(subRow)\n            groupedRowsById[subRow.id] = subRow\n            if (subRow.isGrouped) {\n              onlyGroupedFlatRows.push(subRow)\n              onlyGroupedRowsById[subRow.id] = subRow\n            } else {\n              nonGroupedFlatRows.push(subRow)\n              nonGroupedRowsById[subRow.id] = subRow\n            }\n          })\n\n          return row\n        }\n      )\n\n      return aggregatedGroupedRows\n    }\n\n    const groupedRows = groupUpRecursively(rows)\n\n    groupedRows.forEach(subRow => {\n      groupedFlatRows.push(subRow)\n      groupedRowsById[subRow.id] = subRow\n      if (subRow.isGrouped) {\n        onlyGroupedFlatRows.push(subRow)\n        onlyGroupedRowsById[subRow.id] = subRow\n      } else {\n        nonGroupedFlatRows.push(subRow)\n        nonGroupedRowsById[subRow.id] = subRow\n      }\n    })\n\n    // Assign the new data\n    return [\n      groupedRows,\n      groupedFlatRows,\n      groupedRowsById,\n      onlyGroupedFlatRows,\n      onlyGroupedRowsById,\n      nonGroupedFlatRows,\n      nonGroupedRowsById,\n    ]\n  }, [\n    manualGroupBy,\n    groupBy,\n    rows,\n    flatRows,\n    rowsById,\n    allColumns,\n    userAggregations,\n    groupByFn,\n  ])\n\n  const getAutoResetGroupBy = useGetLatest(autoResetGroupBy)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetGroupBy()) {\n      dispatch({ type: actions.resetGroupBy })\n    }\n  }, [dispatch, manualGroupBy ? null : data])\n\n  Object.assign(instance, {\n    preGroupedRows: rows,\n    preGroupedFlatRow: flatRows,\n    preGroupedRowsById: rowsById,\n    groupedRows,\n    groupedFlatRows,\n    groupedRowsById,\n    onlyGroupedFlatRows,\n    onlyGroupedRowsById,\n    nonGroupedFlatRows,\n    nonGroupedRowsById,\n    rows: groupedRows,\n    flatRows: groupedFlatRows,\n    rowsById: groupedRowsById,\n    toggleGroupBy,\n    setGroupBy,\n  })\n}\n\nfunction prepareRow(row) {\n  row.allCells.forEach(cell => {\n    // Grouped cells are in the groupBy and the pivot cell for the row\n    cell.isGrouped = cell.column.isGrouped && cell.column.id === row.groupByID\n    // Placeholder cells are any columns in the groupBy that are not grouped\n    cell.isPlaceholder = !cell.isGrouped && cell.column.isGrouped\n    // Aggregated cells are not grouped, not repeated, but still have subRows\n    cell.isAggregated =\n      !cell.isGrouped && !cell.isPlaceholder && row.subRows?.length\n  })\n}\n\nexport function defaultGroupByFn(rows, columnId) {\n  return rows.reduce((prev, row, i) => {\n    // TODO: Might want to implement a key serializer here so\n    // irregular column values can still be grouped if needed?\n    const resKey = `${row.values[columnId]}`\n    prev[resKey] = Array.isArray(prev[resKey]) ? prev[resKey] : []\n    prev[resKey].push(row)\n    return prev\n  }, {})\n}\n","const reSplitAlphaNumeric = /([0-9]+)/gm\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nexport const alphanumeric = (rowA, rowB, columnId) => {\n  let a = getRowValueByColumnID(rowA, columnId)\n  let b = getRowValueByColumnID(rowB, columnId)\n  // Force to strings (or \"\" for unsupported types)\n  a = toString(a)\n  b = toString(b)\n\n  // Split on number groups, but keep the delimiter\n  // Then remove falsey split values\n  a = a.split(reSplitAlphaNumeric).filter(Boolean)\n  b = b.split(reSplitAlphaNumeric).filter(Boolean)\n\n  // While\n  while (a.length && b.length) {\n    let aa = a.shift()\n    let bb = b.shift()\n\n    const an = parseInt(aa, 10)\n    const bn = parseInt(bb, 10)\n\n    const combo = [an, bn].sort()\n\n    // Both are string\n    if (isNaN(combo[0])) {\n      if (aa > bb) {\n        return 1\n      }\n      if (bb > aa) {\n        return -1\n      }\n      continue\n    }\n\n    // One is a string, one is a number\n    if (isNaN(combo[1])) {\n      return isNaN(an) ? -1 : 1\n    }\n\n    // Both are numbers\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n  }\n\n  return a.length - b.length\n}\n\nexport function datetime(rowA, rowB, columnId) {\n  let a = getRowValueByColumnID(rowA, columnId)\n  let b = getRowValueByColumnID(rowB, columnId)\n\n  a = a.getTime()\n  b = b.getTime()\n\n  return compareBasic(a, b)\n}\n\nexport function basic(rowA, rowB, columnId) {\n  let a = getRowValueByColumnID(rowA, columnId)\n  let b = getRowValueByColumnID(rowB, columnId)\n\n  return compareBasic(a, b)\n}\n\n// Utils\n\nfunction compareBasic(a, b) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction getRowValueByColumnID(row, columnId) {\n  return row.values[columnId]\n}\n\nfunction toString(a) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n","import React from 'react'\n\nimport {\n  actions,\n  ensurePluginOrder,\n  defaultColumn,\n  makePropGetter,\n  useGetLatest,\n  useMountedLayoutEffect,\n} from '../publicUtils'\n\nimport { getFirstDefined, isFunction } from '../utils'\n\nimport * as sortTypes from '../sortTypes'\n\n// Actions\nactions.resetSortBy = 'resetSortBy'\nactions.setSortBy = 'setSortBy'\nactions.toggleSortBy = 'toggleSortBy'\nactions.clearSortBy = 'clearSortBy'\n\ndefaultColumn.sortType = 'alphanumeric'\ndefaultColumn.sortDescFirst = false\n\nexport const useSortBy = hooks => {\n  hooks.getSortByToggleProps = [defaultGetSortByToggleProps]\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n}\n\nuseSortBy.pluginName = 'useSortBy'\n\nconst defaultGetSortByToggleProps = (props, { instance, column }) => {\n  const { isMultiSortEvent = e => e.shiftKey } = instance\n\n  return [\n    props,\n    {\n      onClick: column.canSort\n        ? e => {\n            e.persist()\n            column.toggleSortBy(\n              undefined,\n              !instance.disableMultiSort && isMultiSortEvent(e)\n            )\n          }\n        : undefined,\n      style: {\n        cursor: column.canSort ? 'pointer' : undefined,\n      },\n      title: column.canSort ? 'Toggle SortBy' : undefined,\n    },\n  ]\n}\n\n// Reducer\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      sortBy: [],\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetSortBy) {\n    return {\n      ...state,\n      sortBy: instance.initialState.sortBy || [],\n    }\n  }\n\n  if (action.type === actions.clearSortBy) {\n    const { sortBy } = state\n    const newSortBy = sortBy.filter(d => d.id !== action.columnId)\n\n    return {\n      ...state,\n      sortBy: newSortBy,\n    }\n  }\n\n  if (action.type === actions.setSortBy) {\n    const { sortBy } = action\n    return {\n      ...state,\n      sortBy,\n    }\n  }\n\n  if (action.type === actions.toggleSortBy) {\n    const { columnId, desc, multi } = action\n\n    const {\n      allColumns,\n      disableMultiSort,\n      disableSortRemove,\n      disableMultiRemove,\n      maxMultiSortColCount = Number.MAX_SAFE_INTEGER,\n    } = instance\n\n    const { sortBy } = state\n\n    // Find the column for this columnId\n    const column = allColumns.find(d => d.id === columnId)\n    const { sortDescFirst } = column\n\n    // Find any existing sortBy for this column\n    const existingSortBy = sortBy.find(d => d.id === columnId)\n    const existingIndex = sortBy.findIndex(d => d.id === columnId)\n    const hasDescDefined = typeof desc !== 'undefined' && desc !== null\n\n    let newSortBy = []\n\n    // What should we do with this sort action?\n    let sortAction\n\n    if (!disableMultiSort && multi) {\n      if (existingSortBy) {\n        sortAction = 'toggle'\n      } else {\n        sortAction = 'add'\n      }\n    } else {\n      // Normal mode\n      if (existingIndex !== sortBy.length - 1 || sortBy.length !== 1) {\n        sortAction = 'replace'\n      } else if (existingSortBy) {\n        sortAction = 'toggle'\n      } else {\n        sortAction = 'replace'\n      }\n    }\n\n    // Handle toggle states that will remove the sortBy\n    if (\n      sortAction === 'toggle' && // Must be toggling\n      !disableSortRemove && // If disableSortRemove, disable in general\n      !hasDescDefined && // Must not be setting desc\n      (multi ? !disableMultiRemove : true) && // If multi, don't allow if disableMultiRemove\n      ((existingSortBy && // Finally, detect if it should indeed be removed\n        existingSortBy.desc &&\n        !sortDescFirst) ||\n        (!existingSortBy.desc && sortDescFirst))\n    ) {\n      sortAction = 'remove'\n    }\n\n    if (sortAction === 'replace') {\n      newSortBy = [\n        {\n          id: columnId,\n          desc: hasDescDefined ? desc : sortDescFirst,\n        },\n      ]\n    } else if (sortAction === 'add') {\n      newSortBy = [\n        ...sortBy,\n        {\n          id: columnId,\n          desc: hasDescDefined ? desc : sortDescFirst,\n        },\n      ]\n      // Take latest n columns\n      newSortBy.splice(0, newSortBy.length - maxMultiSortColCount)\n    } else if (sortAction === 'toggle') {\n      // This flips (or sets) the\n      newSortBy = sortBy.map(d => {\n        if (d.id === columnId) {\n          return {\n            ...d,\n            desc: hasDescDefined ? desc : !existingSortBy.desc,\n          }\n        }\n        return d\n      })\n    } else if (sortAction === 'remove') {\n      newSortBy = sortBy.filter(d => d.id !== columnId)\n    }\n\n    return {\n      ...state,\n      sortBy: newSortBy,\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    flatRows,\n    allColumns,\n    orderByFn = defaultOrderByFn,\n    sortTypes: userSortTypes,\n    manualSortBy,\n    defaultCanSort,\n    disableSortBy,\n    flatHeaders,\n    state: { sortBy },\n    dispatch,\n    plugins,\n    getHooks,\n    autoResetSortBy = true,\n  } = instance\n\n  ensurePluginOrder(\n    plugins,\n    ['useFilters', 'useGlobalFilter', 'useGroupBy', 'usePivotColumns'],\n    'useSortBy'\n  )\n\n  const setSortBy = React.useCallback(\n    sortBy => {\n      dispatch({ type: actions.setSortBy, sortBy })\n    },\n    [dispatch]\n  )\n\n  // Updates sorting based on a columnId, desc flag and multi flag\n  const toggleSortBy = React.useCallback(\n    (columnId, desc, multi) => {\n      dispatch({ type: actions.toggleSortBy, columnId, desc, multi })\n    },\n    [dispatch]\n  )\n\n  // use reference to avoid memory leak in #1608\n  const getInstance = useGetLatest(instance)\n\n  // Add the getSortByToggleProps method to columns and headers\n  flatHeaders.forEach(column => {\n    const {\n      accessor,\n      canSort: defaultColumnCanSort,\n      disableSortBy: columnDisableSortBy,\n      id,\n    } = column\n\n    const canSort = accessor\n      ? getFirstDefined(\n          columnDisableSortBy === true ? false : undefined,\n          disableSortBy === true ? false : undefined,\n          true\n        )\n      : getFirstDefined(defaultCanSort, defaultColumnCanSort, false)\n\n    column.canSort = canSort\n\n    if (column.canSort) {\n      column.toggleSortBy = (desc, multi) =>\n        toggleSortBy(column.id, desc, multi)\n\n      column.clearSortBy = () => {\n        dispatch({ type: actions.clearSortBy, columnId: column.id })\n      }\n    }\n\n    column.getSortByToggleProps = makePropGetter(\n      getHooks().getSortByToggleProps,\n      {\n        instance: getInstance(),\n        column,\n      }\n    )\n\n    const columnSort = sortBy.find(d => d.id === id)\n    column.isSorted = !!columnSort\n    column.sortedIndex = sortBy.findIndex(d => d.id === id)\n    column.isSortedDesc = column.isSorted ? columnSort.desc : undefined\n  })\n\n  const [sortedRows, sortedFlatRows] = React.useMemo(() => {\n    if (manualSortBy || !sortBy.length) {\n      return [rows, flatRows]\n    }\n\n    const sortedFlatRows = []\n\n    // Filter out sortBys that correspond to non existing columns\n    const availableSortBy = sortBy.filter(sort =>\n      allColumns.find(col => col.id === sort.id)\n    )\n\n    const sortData = rows => {\n      // Use the orderByFn to compose multiple sortBy's together.\n      // This will also perform a stable sorting using the row index\n      // if needed.\n      const sortedData = orderByFn(\n        rows,\n        availableSortBy.map(sort => {\n          // Support custom sorting methods for each column\n          const column = allColumns.find(d => d.id === sort.id)\n\n          if (!column) {\n            throw new Error(\n              `React-Table: Could not find a column with id: ${sort.id} while sorting`\n            )\n          }\n\n          const { sortType } = column\n\n          // Look up sortBy functions in this order:\n          // column function\n          // column string lookup on user sortType\n          // column string lookup on built-in sortType\n          // default function\n          // default string lookup on user sortType\n          // default string lookup on built-in sortType\n          const sortMethod =\n            isFunction(sortType) ||\n            (userSortTypes || {})[sortType] ||\n            sortTypes[sortType]\n\n          if (!sortMethod) {\n            throw new Error(\n              `React-Table: Could not find a valid sortType of '${sortType}' for column '${sort.id}'.`\n            )\n          }\n\n          // Return the correct sortFn.\n          // This function should always return in ascending order\n          return (a, b) => sortMethod(a, b, sort.id, sort.desc)\n        }),\n        // Map the directions\n        availableSortBy.map(sort => {\n          // Detect and use the sortInverted option\n          const column = allColumns.find(d => d.id === sort.id)\n\n          if (column && column.sortInverted) {\n            return sort.desc\n          }\n\n          return !sort.desc\n        })\n      )\n\n      // If there are sub-rows, sort them\n      sortedData.forEach(row => {\n        sortedFlatRows.push(row)\n        if (!row.subRows) {\n          return\n        } else if (row.subRows.length === 1) {\n          sortedFlatRows.push(row.subRows[0])\n          return\n        }\n        row.subRows = sortData(row.subRows)\n      })\n\n      return sortedData\n    }\n\n    return [sortData(rows), sortedFlatRows]\n  }, [\n    manualSortBy,\n    sortBy,\n    rows,\n    flatRows,\n    allColumns,\n    orderByFn,\n    userSortTypes,\n  ])\n\n  const getAutoResetSortBy = useGetLatest(autoResetSortBy)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetSortBy()) {\n      dispatch({ type: actions.resetSortBy })\n    }\n  }, [manualSortBy ? null : data])\n\n  Object.assign(instance, {\n    preSortedRows: rows,\n    preSortedFlatRows: flatRows,\n    sortedRows,\n    sortedFlatRows,\n    rows: sortedRows,\n    flatRows: sortedFlatRows,\n    setSortBy,\n    toggleSortBy,\n  })\n}\n\nexport function defaultOrderByFn(arr, funcs, dirs) {\n  return [...arr].sort((rowA, rowB) => {\n    for (let i = 0; i < funcs.length; i += 1) {\n      const sortFn = funcs[i]\n      const desc = dirs[i] === false || dirs[i] === 'desc'\n      const sortInt = sortFn(rowA, rowB)\n      if (sortInt !== 0) {\n        return desc ? -sortInt : sortInt\n      }\n    }\n    return dirs[0] ? rowA.index - rowB.index : rowB.index - rowA.index\n  })\n}\n","import React from 'react'\n\n//\n\nimport {\n  actions,\n  ensurePluginOrder,\n  functionalUpdate,\n  useMountedLayoutEffect,\n  useGetLatest,\n} from '../publicUtils'\n\nimport { expandRows } from '../utils'\n\nconst pluginName = 'usePagination'\n\n// Actions\nactions.resetPage = 'resetPage'\nactions.gotoPage = 'gotoPage'\nactions.setPageSize = 'setPageSize'\n\nexport const usePagination = hooks => {\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n}\n\nusePagination.pluginName = pluginName\n\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      pageSize: 10,\n      pageIndex: 0,\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetPage) {\n    return {\n      ...state,\n      pageIndex: instance.initialState.pageIndex || 0,\n    }\n  }\n\n  if (action.type === actions.gotoPage) {\n    const { pageCount, page } = instance\n    const newPageIndex = functionalUpdate(action.pageIndex, state.pageIndex)\n    let canNavigate = false\n\n    if (newPageIndex > state.pageIndex) {\n      // next page\n      canNavigate =\n        pageCount === -1\n          ? page.length >= state.pageSize\n          : newPageIndex <= pageCount\n    } else if (newPageIndex < state.pageIndex) {\n      // prev page\n      canNavigate = newPageIndex > -1\n    }\n\n    if (!canNavigate) {\n      return state\n    }\n\n    return {\n      ...state,\n      pageIndex: newPageIndex,\n    }\n  }\n\n  if (action.type === actions.setPageSize) {\n    const { pageSize } = action\n    const topRowIndex = state.pageSize * state.pageIndex\n    const pageIndex = Math.floor(topRowIndex / pageSize)\n\n    return {\n      ...state,\n      pageIndex,\n      pageSize,\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const {\n    rows,\n    autoResetPage = true,\n    manualExpandedKey = 'expanded',\n    plugins,\n    pageCount: userPageCount,\n    paginateExpandedRows = true,\n    expandSubRows = true,\n    state: {\n      pageSize,\n      pageIndex,\n      expanded,\n      globalFilter,\n      filters,\n      groupBy,\n      sortBy,\n    },\n    dispatch,\n    data,\n    manualPagination,\n  } = instance\n\n  ensurePluginOrder(\n    plugins,\n    ['useGlobalFilter', 'useFilters', 'useGroupBy', 'useSortBy', 'useExpanded'],\n    'usePagination'\n  )\n\n  const getAutoResetPage = useGetLatest(autoResetPage)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetPage()) {\n      dispatch({ type: actions.resetPage })\n    }\n  }, [\n    dispatch,\n    manualPagination ? null : data,\n    globalFilter,\n    filters,\n    groupBy,\n    sortBy,\n  ])\n\n  const pageCount = manualPagination\n    ? userPageCount\n    : Math.ceil(rows.length / pageSize)\n\n  const pageOptions = React.useMemo(\n    () =>\n      pageCount > 0\n        ? [...new Array(pageCount)].fill(null).map((d, i) => i)\n        : [],\n    [pageCount]\n  )\n\n  const page = React.useMemo(() => {\n    let page\n\n    if (manualPagination) {\n      page = rows\n    } else {\n      const pageStart = pageSize * pageIndex\n      const pageEnd = pageStart + pageSize\n\n      page = rows.slice(pageStart, pageEnd)\n    }\n\n    if (paginateExpandedRows) {\n      return page\n    }\n\n    return expandRows(page, { manualExpandedKey, expanded, expandSubRows })\n  }, [\n    expandSubRows,\n    expanded,\n    manualExpandedKey,\n    manualPagination,\n    pageIndex,\n    pageSize,\n    paginateExpandedRows,\n    rows,\n  ])\n\n  const canPreviousPage = pageIndex > 0\n  const canNextPage =\n    pageCount === -1 ? page.length >= pageSize : pageIndex < pageCount - 1\n\n  const gotoPage = React.useCallback(\n    pageIndex => {\n      dispatch({ type: actions.gotoPage, pageIndex })\n    },\n    [dispatch]\n  )\n\n  const previousPage = React.useCallback(() => {\n    return gotoPage(old => old - 1)\n  }, [gotoPage])\n\n  const nextPage = React.useCallback(() => {\n    return gotoPage(old => old + 1)\n  }, [gotoPage])\n\n  const setPageSize = React.useCallback(\n    pageSize => {\n      dispatch({ type: actions.setPageSize, pageSize })\n    },\n    [dispatch]\n  )\n\n  Object.assign(instance, {\n    pageOptions,\n    pageCount,\n    page,\n    canPreviousPage,\n    canNextPage,\n    gotoPage,\n    previousPage,\n    nextPage,\n    setPageSize,\n  })\n}\n","/* istanbul ignore file */\n\nimport {\n  actions,\n  makePropGetter,\n  ensurePluginOrder,\n  useMountedLayoutEffect,\n  useGetLatest,\n} from '../publicUtils'\n\nimport { flattenColumns, getFirstDefined } from '../utils'\n\n// Actions\nactions.resetPivot = 'resetPivot'\nactions.togglePivot = 'togglePivot'\n\nexport const _UNSTABLE_usePivotColumns = hooks => {\n  hooks.getPivotToggleProps = [defaultGetPivotToggleProps]\n  hooks.stateReducers.push(reducer)\n  hooks.useInstanceAfterData.push(useInstanceAfterData)\n  hooks.allColumns.push(allColumns)\n  hooks.accessValue.push(accessValue)\n  hooks.materializedColumns.push(materializedColumns)\n  hooks.materializedColumnsDeps.push(materializedColumnsDeps)\n  hooks.visibleColumns.push(visibleColumns)\n  hooks.visibleColumnsDeps.push(visibleColumnsDeps)\n  hooks.useInstance.push(useInstance)\n  hooks.prepareRow.push(prepareRow)\n}\n\n_UNSTABLE_usePivotColumns.pluginName = 'usePivotColumns'\n\nconst defaultPivotColumns = []\n\nconst defaultGetPivotToggleProps = (props, { header }) => [\n  props,\n  {\n    onClick: header.canPivot\n      ? e => {\n          e.persist()\n          header.togglePivot()\n        }\n      : undefined,\n    style: {\n      cursor: header.canPivot ? 'pointer' : undefined,\n    },\n    title: 'Toggle Pivot',\n  },\n]\n\n// Reducer\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      pivotColumns: defaultPivotColumns,\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetPivot) {\n    return {\n      ...state,\n      pivotColumns: instance.initialState.pivotColumns || defaultPivotColumns,\n    }\n  }\n\n  if (action.type === actions.togglePivot) {\n    const { columnId, value: setPivot } = action\n\n    const resolvedPivot =\n      typeof setPivot !== 'undefined'\n        ? setPivot\n        : !state.pivotColumns.includes(columnId)\n\n    if (resolvedPivot) {\n      return {\n        ...state,\n        pivotColumns: [...state.pivotColumns, columnId],\n      }\n    }\n\n    return {\n      ...state,\n      pivotColumns: state.pivotColumns.filter(d => d !== columnId),\n    }\n  }\n}\n\nfunction useInstanceAfterData(instance) {\n  instance.allColumns.forEach(column => {\n    column.isPivotSource = instance.state.pivotColumns.includes(column.id)\n  })\n}\n\nfunction allColumns(columns, { instance }) {\n  columns.forEach(column => {\n    column.isPivotSource = instance.state.pivotColumns.includes(column.id)\n    column.uniqueValues = new Set()\n  })\n  return columns\n}\n\nfunction accessValue(value, { column }) {\n  if (column.uniqueValues && typeof value !== 'undefined') {\n    column.uniqueValues.add(value)\n  }\n  return value\n}\n\nfunction materializedColumns(materialized, { instance }) {\n  const { allColumns, state } = instance\n\n  if (!state.pivotColumns.length || !state.groupBy || !state.groupBy.length) {\n    return materialized\n  }\n\n  const pivotColumns = state.pivotColumns\n    .map(id => allColumns.find(d => d.id === id))\n    .filter(Boolean)\n\n  const sourceColumns = allColumns.filter(\n    d =>\n      !d.isPivotSource &&\n      !state.groupBy.includes(d.id) &&\n      !state.pivotColumns.includes(d.id)\n  )\n\n  const buildPivotColumns = (depth = 0, parent, pivotFilters = []) => {\n    const pivotColumn = pivotColumns[depth]\n\n    if (!pivotColumn) {\n      return sourceColumns.map(sourceColumn => {\n        // TODO: We could offer support here for renesting pivoted\n        // columns inside copies of their header groups. For now,\n        // that seems like it would be (1) overkill on nesting, considering\n        // you already get nesting for every pivot level and (2)\n        // really hard. :)\n\n        return {\n          ...sourceColumn,\n          canPivot: false,\n          isPivoted: true,\n          parent,\n          depth: depth,\n          id: `${parent ? `${parent.id}.${sourceColumn.id}` : sourceColumn.id}`,\n          accessor: (originalRow, i, row) => {\n            if (pivotFilters.every(filter => filter(row))) {\n              return row.values[sourceColumn.id]\n            }\n          },\n        }\n      })\n    }\n\n    const uniqueValues = Array.from(pivotColumn.uniqueValues).sort()\n\n    return uniqueValues.map(uniqueValue => {\n      const columnGroup = {\n        ...pivotColumn,\n        Header:\n          pivotColumn.PivotHeader || typeof pivotColumn.header === 'string'\n            ? `${pivotColumn.Header}: ${uniqueValue}`\n            : uniqueValue,\n        isPivotGroup: true,\n        parent,\n        depth,\n        id: parent\n          ? `${parent.id}.${pivotColumn.id}.${uniqueValue}`\n          : `${pivotColumn.id}.${uniqueValue}`,\n        pivotValue: uniqueValue,\n      }\n\n      columnGroup.columns = buildPivotColumns(depth + 1, columnGroup, [\n        ...pivotFilters,\n        row => row.values[pivotColumn.id] === uniqueValue,\n      ])\n\n      return columnGroup\n    })\n  }\n\n  const newMaterialized = flattenColumns(buildPivotColumns())\n\n  return [...materialized, ...newMaterialized]\n}\n\nfunction materializedColumnsDeps(\n  deps,\n  {\n    instance: {\n      state: { pivotColumns, groupBy },\n    },\n  }\n) {\n  return [...deps, pivotColumns, groupBy]\n}\n\nfunction visibleColumns(visibleColumns, { instance: { state } }) {\n  visibleColumns = visibleColumns.filter(d => !d.isPivotSource)\n\n  if (state.pivotColumns.length && state.groupBy && state.groupBy.length) {\n    visibleColumns = visibleColumns.filter(\n      column => column.isGrouped || column.isPivoted\n    )\n  }\n\n  return visibleColumns\n}\n\nfunction visibleColumnsDeps(deps, { instance }) {\n  return [...deps, instance.state.pivotColumns, instance.state.groupBy]\n}\n\nfunction useInstance(instance) {\n  const {\n    columns,\n    allColumns,\n    flatHeaders,\n    // pivotFn = defaultPivotFn,\n    // manualPivot,\n    getHooks,\n    plugins,\n    dispatch,\n    autoResetPivot = true,\n    manaulPivot,\n    disablePivot,\n    defaultCanPivot,\n  } = instance\n\n  ensurePluginOrder(plugins, ['useGroupBy'], 'usePivotColumns')\n\n  const getInstance = useGetLatest(instance)\n\n  allColumns.forEach(column => {\n    const {\n      accessor,\n      defaultPivot: defaultColumnPivot,\n      disablePivot: columnDisablePivot,\n    } = column\n\n    column.canPivot = accessor\n      ? getFirstDefined(\n          column.canPivot,\n          columnDisablePivot === true ? false : undefined,\n          disablePivot === true ? false : undefined,\n          true\n        )\n      : getFirstDefined(\n          column.canPivot,\n          defaultColumnPivot,\n          defaultCanPivot,\n          false\n        )\n\n    if (column.canPivot) {\n      column.togglePivot = () => instance.togglePivot(column.id)\n    }\n\n    column.Aggregated = column.Aggregated || column.Cell\n  })\n\n  const togglePivot = (columnId, value) => {\n    dispatch({ type: actions.togglePivot, columnId, value })\n  }\n\n  flatHeaders.forEach(header => {\n    header.getPivotToggleProps = makePropGetter(\n      getHooks().getPivotToggleProps,\n      {\n        instance: getInstance(),\n        header,\n      }\n    )\n  })\n\n  const getAutoResetPivot = useGetLatest(autoResetPivot)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetPivot()) {\n      dispatch({ type: actions.resetPivot })\n    }\n  }, [dispatch, manaulPivot ? null : columns])\n\n  Object.assign(instance, {\n    togglePivot,\n  })\n}\n\nfunction prepareRow(row) {\n  row.allCells.forEach(cell => {\n    // Grouped cells are in the pivotColumns and the pivot cell for the row\n    cell.isPivoted = cell.column.isPivoted\n  })\n}\n","import React from 'react'\n\nimport {\n  actions,\n  makePropGetter,\n  ensurePluginOrder,\n  useGetLatest,\n  useMountedLayoutEffect,\n} from '../publicUtils'\n\nconst pluginName = 'useRowSelect'\n\n// Actions\nactions.resetSelectedRows = 'resetSelectedRows'\nactions.toggleAllRowsSelected = 'toggleAllRowsSelected'\nactions.toggleRowSelected = 'toggleRowSelected'\nactions.toggleAllPageRowsSelected = 'toggleAllPageRowsSelected'\n\nexport const useRowSelect = hooks => {\n  hooks.getToggleRowSelectedProps = [defaultGetToggleRowSelectedProps]\n  hooks.getToggleAllRowsSelectedProps = [defaultGetToggleAllRowsSelectedProps]\n  hooks.getToggleAllPageRowsSelectedProps = [\n    defaultGetToggleAllPageRowsSelectedProps,\n  ]\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n  hooks.prepareRow.push(prepareRow)\n}\n\nuseRowSelect.pluginName = pluginName\n\nconst defaultGetToggleRowSelectedProps = (props, { instance, row }) => {\n  const { manualRowSelectedKey = 'isSelected' } = instance\n  let checked = false\n\n  if (row.original && row.original[manualRowSelectedKey]) {\n    checked = true\n  } else {\n    checked = row.isSelected\n  }\n\n  return [\n    props,\n    {\n      onChange: e => {\n        row.toggleRowSelected(e.target.checked)\n      },\n      style: {\n        cursor: 'pointer',\n      },\n      checked,\n      title: 'Toggle Row Selected',\n      indeterminate: row.isSomeSelected,\n    },\n  ]\n}\n\nconst defaultGetToggleAllRowsSelectedProps = (props, { instance }) => [\n  props,\n  {\n    onChange: e => {\n      instance.toggleAllRowsSelected(e.target.checked)\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    checked: instance.isAllRowsSelected,\n    title: 'Toggle All Rows Selected',\n    indeterminate: Boolean(\n      !instance.isAllRowsSelected &&\n        Object.keys(instance.state.selectedRowIds).length\n    ),\n  },\n]\n\nconst defaultGetToggleAllPageRowsSelectedProps = (props, { instance }) => [\n  props,\n  {\n    onChange(e) {\n      instance.toggleAllPageRowsSelected(e.target.checked)\n    },\n    style: {\n      cursor: 'pointer',\n    },\n    checked: instance.isAllPageRowsSelected,\n    title: 'Toggle All Current Page Rows Selected',\n    indeterminate: Boolean(\n      !instance.isAllPageRowsSelected &&\n        instance.page.some(({ id }) => instance.state.selectedRowIds[id])\n    ),\n  },\n]\n\n// eslint-disable-next-line max-params\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      selectedRowIds: {},\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetSelectedRows) {\n    return {\n      ...state,\n      selectedRowIds: instance.initialState.selectedRowIds || {},\n    }\n  }\n\n  if (action.type === actions.toggleAllRowsSelected) {\n    const { value: setSelected } = action\n    const {\n      isAllRowsSelected,\n      rowsById,\n      nonGroupedRowsById = rowsById,\n    } = instance\n\n    const selectAll =\n      typeof setSelected !== 'undefined' ? setSelected : !isAllRowsSelected\n\n    // Only remove/add the rows that are visible on the screen\n    //  Leave all the other rows that are selected alone.\n    const selectedRowIds = Object.assign({}, state.selectedRowIds)\n\n    if (selectAll) {\n      Object.keys(nonGroupedRowsById).forEach(rowId => {\n        selectedRowIds[rowId] = true\n      })\n    } else {\n      Object.keys(nonGroupedRowsById).forEach(rowId => {\n        delete selectedRowIds[rowId]\n      })\n    }\n\n    return {\n      ...state,\n      selectedRowIds,\n    }\n  }\n\n  if (action.type === actions.toggleRowSelected) {\n    const { id, value: setSelected } = action\n    const { rowsById, selectSubRows = true, getSubRows } = instance\n\n    // Join the ids of deep rows\n    // to make a key, then manage all of the keys\n    // in a flat object\n    const row = rowsById[id]\n    const isSelected = row.isSelected\n    const shouldExist =\n      typeof setSelected !== 'undefined' ? setSelected : !isSelected\n\n    if (isSelected === shouldExist) {\n      return state\n    }\n\n    const newSelectedRowIds = { ...state.selectedRowIds }\n\n    const handleRowById = id => {\n      const row = rowsById[id]\n\n      if (!row.isGrouped) {\n        if (shouldExist) {\n          newSelectedRowIds[id] = true\n        } else {\n          delete newSelectedRowIds[id]\n        }\n      }\n\n      if (selectSubRows && getSubRows(row)) {\n        return getSubRows(row).forEach(row => handleRowById(row.id))\n      }\n    }\n\n    handleRowById(id)\n\n    return {\n      ...state,\n      selectedRowIds: newSelectedRowIds,\n    }\n  }\n\n  if (action.type === actions.toggleAllPageRowsSelected) {\n    const { value: setSelected } = action\n    const {\n      page,\n      rowsById,\n      selectSubRows = true,\n      isAllPageRowsSelected,\n      getSubRows,\n    } = instance\n\n    const selectAll =\n      typeof setSelected !== 'undefined' ? setSelected : !isAllPageRowsSelected\n\n    const newSelectedRowIds = { ...state.selectedRowIds }\n\n    const handleRowById = id => {\n      const row = rowsById[id]\n\n      if (!row.isGrouped) {\n        if (selectAll) {\n          newSelectedRowIds[id] = true\n        } else {\n          delete newSelectedRowIds[id]\n        }\n      }\n\n      if (selectSubRows && getSubRows(row)) {\n        return getSubRows(row).forEach(row => handleRowById(row.id))\n      }\n    }\n\n    page.forEach(row => handleRowById(row.id))\n\n    return {\n      ...state,\n      selectedRowIds: newSelectedRowIds,\n    }\n  }\n  return state\n}\n\nfunction useInstance(instance) {\n  const {\n    data,\n    rows,\n    getHooks,\n    plugins,\n    rowsById,\n    nonGroupedRowsById = rowsById,\n    autoResetSelectedRows = true,\n    state: { selectedRowIds },\n    selectSubRows = true,\n    dispatch,\n    page,\n    getSubRows,\n  } = instance\n\n  ensurePluginOrder(\n    plugins,\n    ['useFilters', 'useGroupBy', 'useSortBy', 'useExpanded', 'usePagination'],\n    'useRowSelect'\n  )\n\n  const selectedFlatRows = React.useMemo(() => {\n    const selectedFlatRows = []\n\n    rows.forEach(row => {\n      const isSelected = selectSubRows\n        ? getRowIsSelected(row, selectedRowIds, getSubRows)\n        : !!selectedRowIds[row.id]\n      row.isSelected = !!isSelected\n      row.isSomeSelected = isSelected === null\n\n      if (isSelected) {\n        selectedFlatRows.push(row)\n      }\n    })\n\n    return selectedFlatRows\n  }, [rows, selectSubRows, selectedRowIds, getSubRows])\n\n  let isAllRowsSelected = Boolean(\n    Object.keys(nonGroupedRowsById).length && Object.keys(selectedRowIds).length\n  )\n\n  let isAllPageRowsSelected = isAllRowsSelected\n\n  if (isAllRowsSelected) {\n    if (Object.keys(nonGroupedRowsById).some(id => !selectedRowIds[id])) {\n      isAllRowsSelected = false\n    }\n  }\n\n  if (!isAllRowsSelected) {\n    if (page && page.length && page.some(({ id }) => !selectedRowIds[id])) {\n      isAllPageRowsSelected = false\n    }\n  }\n\n  const getAutoResetSelectedRows = useGetLatest(autoResetSelectedRows)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetSelectedRows()) {\n      dispatch({ type: actions.resetSelectedRows })\n    }\n  }, [dispatch, data])\n\n  const toggleAllRowsSelected = React.useCallback(\n    value => dispatch({ type: actions.toggleAllRowsSelected, value }),\n    [dispatch]\n  )\n\n  const toggleAllPageRowsSelected = React.useCallback(\n    value => dispatch({ type: actions.toggleAllPageRowsSelected, value }),\n    [dispatch]\n  )\n\n  const toggleRowSelected = React.useCallback(\n    (id, value) => dispatch({ type: actions.toggleRowSelected, id, value }),\n    [dispatch]\n  )\n\n  const getInstance = useGetLatest(instance)\n\n  const getToggleAllRowsSelectedProps = makePropGetter(\n    getHooks().getToggleAllRowsSelectedProps,\n    { instance: getInstance() }\n  )\n\n  const getToggleAllPageRowsSelectedProps = makePropGetter(\n    getHooks().getToggleAllPageRowsSelectedProps,\n    { instance: getInstance() }\n  )\n\n  Object.assign(instance, {\n    selectedFlatRows,\n    isAllRowsSelected,\n    isAllPageRowsSelected,\n    toggleRowSelected,\n    toggleAllRowsSelected,\n    getToggleAllRowsSelectedProps,\n    getToggleAllPageRowsSelectedProps,\n    toggleAllPageRowsSelected,\n  })\n}\n\nfunction prepareRow(row, { instance }) {\n  row.toggleRowSelected = set => instance.toggleRowSelected(row.id, set)\n\n  row.getToggleRowSelectedProps = makePropGetter(\n    instance.getHooks().getToggleRowSelectedProps,\n    { instance: instance, row }\n  )\n}\n\nfunction getRowIsSelected(row, selectedRowIds, getSubRows) {\n  if (selectedRowIds[row.id]) {\n    return true\n  }\n\n  const subRows = getSubRows(row)\n\n  if (subRows && subRows.length) {\n    let allChildrenSelected = true\n    let someSelected = false\n\n    subRows.forEach(subRow => {\n      // Bail out early if we know both of these\n      if (someSelected && !allChildrenSelected) {\n        return\n      }\n\n      if (getRowIsSelected(subRow, selectedRowIds, getSubRows)) {\n        someSelected = true\n      } else {\n        allChildrenSelected = false\n      }\n    })\n    return allChildrenSelected ? true : someSelected ? null : false\n  }\n\n  return false\n}\n","import React from 'react'\n\nimport {\n  actions,\n  functionalUpdate,\n  useMountedLayoutEffect,\n  useGetLatest,\n} from '../publicUtils'\n\nconst defaultInitialRowStateAccessor = originalRow => ({})\nconst defaultInitialCellStateAccessor = originalRow => ({})\n\n// Actions\nactions.setRowState = 'setRowState'\nactions.setCellState = 'setCellState'\nactions.resetRowState = 'resetRowState'\n\nexport const useRowState = hooks => {\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n  hooks.prepareRow.push(prepareRow)\n}\n\nuseRowState.pluginName = 'useRowState'\n\nfunction reducer(state, action, previousState, instance) {\n  const {\n    initialRowStateAccessor = defaultInitialRowStateAccessor,\n    initialCellStateAccessor = defaultInitialCellStateAccessor,\n    rowsById,\n  } = instance\n\n  if (action.type === actions.init) {\n    return {\n      rowState: {},\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetRowState) {\n    return {\n      ...state,\n      rowState: instance.initialState.rowState || {},\n    }\n  }\n\n  if (action.type === actions.setRowState) {\n    const { rowId, value } = action\n\n    const oldRowState =\n      typeof state.rowState[rowId] !== 'undefined'\n        ? state.rowState[rowId]\n        : initialRowStateAccessor(rowsById[rowId].original)\n\n    return {\n      ...state,\n      rowState: {\n        ...state.rowState,\n        [rowId]: functionalUpdate(value, oldRowState),\n      },\n    }\n  }\n\n  if (action.type === actions.setCellState) {\n    const { rowId, columnId, value } = action\n\n    const oldRowState =\n      typeof state.rowState[rowId] !== 'undefined'\n        ? state.rowState[rowId]\n        : initialRowStateAccessor(rowsById[rowId].original)\n\n    const oldCellState =\n      typeof oldRowState?.cellState?.[columnId] !== 'undefined'\n        ? oldRowState.cellState[columnId]\n        : initialCellStateAccessor(rowsById[rowId].original)\n\n    return {\n      ...state,\n      rowState: {\n        ...state.rowState,\n        [rowId]: {\n          ...oldRowState,\n          cellState: {\n            ...(oldRowState.cellState || {}),\n            [columnId]: functionalUpdate(value, oldCellState),\n          },\n        },\n      },\n    }\n  }\n}\n\nfunction useInstance(instance) {\n  const { autoResetRowState = true, data, dispatch } = instance\n\n  const setRowState = React.useCallback(\n    (rowId, value) =>\n      dispatch({\n        type: actions.setRowState,\n        rowId,\n        value,\n      }),\n    [dispatch]\n  )\n\n  const setCellState = React.useCallback(\n    (rowId, columnId, value) =>\n      dispatch({\n        type: actions.setCellState,\n        rowId,\n        columnId,\n        value,\n      }),\n    [dispatch]\n  )\n\n  const getAutoResetRowState = useGetLatest(autoResetRowState)\n\n  useMountedLayoutEffect(() => {\n    if (getAutoResetRowState()) {\n      dispatch({ type: actions.resetRowState })\n    }\n  }, [data])\n\n  Object.assign(instance, {\n    setRowState,\n    setCellState,\n  })\n}\n\nfunction prepareRow(row, { instance }) {\n  const {\n    initialRowStateAccessor = defaultInitialRowStateAccessor,\n    initialCellStateAccessor = defaultInitialCellStateAccessor,\n    state: { rowState },\n  } = instance\n\n  if (row.original) {\n    row.state =\n      typeof rowState[row.id] !== 'undefined'\n        ? rowState[row.id]\n        : initialRowStateAccessor(row.original)\n\n    row.setState = updater => {\n      return instance.setRowState(row.id, updater)\n    }\n\n    row.cells.forEach(cell => {\n      if (!row.state.cellState) {\n        row.state.cellState = {}\n      }\n\n      cell.state =\n        typeof row.state.cellState[cell.column.id] !== 'undefined'\n          ? row.state.cellState[cell.column.id]\n          : initialCellStateAccessor(row.original)\n\n      cell.setState = updater => {\n        return instance.setCellState(row.id, cell.column.id, updater)\n      }\n    })\n  }\n}\n","import React from 'react'\n\nimport { functionalUpdate, actions } from '../publicUtils'\n\n// Actions\nactions.resetColumnOrder = 'resetColumnOrder'\nactions.setColumnOrder = 'setColumnOrder'\n\nexport const useColumnOrder = hooks => {\n  hooks.stateReducers.push(reducer)\n  hooks.visibleColumnsDeps.push((deps, { instance }) => {\n    return [...deps, instance.state.columnOrder]\n  })\n  hooks.visibleColumns.push(visibleColumns)\n  hooks.useInstance.push(useInstance)\n}\n\nuseColumnOrder.pluginName = 'useColumnOrder'\n\nfunction reducer(state, action, previousState, instance) {\n  if (action.type === actions.init) {\n    return {\n      columnOrder: [],\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetColumnOrder) {\n    return {\n      ...state,\n      columnOrder: instance.initialState.columnOrder || [],\n    }\n  }\n\n  if (action.type === actions.setColumnOrder) {\n    return {\n      ...state,\n      columnOrder: functionalUpdate(action.columnOrder, state.columnOrder),\n    }\n  }\n}\n\nfunction visibleColumns(\n  columns,\n  {\n    instance: {\n      state: { columnOrder },\n    },\n  }\n) {\n  // If there is no order, return the normal columns\n  if (!columnOrder || !columnOrder.length) {\n    return columns\n  }\n\n  const columnOrderCopy = [...columnOrder]\n\n  // If there is an order, make a copy of the columns\n  const columnsCopy = [...columns]\n\n  // And make a new ordered array of the columns\n  const columnsInOrder = []\n\n  // Loop over the columns and place them in order into the new array\n  while (columnsCopy.length && columnOrderCopy.length) {\n    const targetColumnId = columnOrderCopy.shift()\n    const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId)\n    if (foundIndex > -1) {\n      columnsInOrder.push(columnsCopy.splice(foundIndex, 1)[0])\n    }\n  }\n\n  // If there are any columns left, add them to the end\n  return [...columnsInOrder, ...columnsCopy]\n}\n\nfunction useInstance(instance) {\n  const { dispatch } = instance\n\n  instance.setColumnOrder = React.useCallback(\n    columnOrder => {\n      return dispatch({ type: actions.setColumnOrder, columnOrder })\n    },\n    [dispatch]\n  )\n}\n","import React from 'react'\n\nimport {\n  actions,\n  defaultColumn,\n  makePropGetter,\n  useGetLatest,\n  ensurePluginOrder,\n  useMountedLayoutEffect,\n} from '../publicUtils'\n\nimport { getFirstDefined, passiveEventSupported } from '../utils'\n\n// Default Column\ndefaultColumn.canResize = true\n\n// Actions\nactions.columnStartResizing = 'columnStartResizing'\nactions.columnResizing = 'columnResizing'\nactions.columnDoneResizing = 'columnDoneResizing'\nactions.resetResize = 'resetResize'\n\nexport const useResizeColumns = hooks => {\n  hooks.getResizerProps = [defaultGetResizerProps]\n  hooks.getHeaderProps.push({\n    style: {\n      position: 'relative',\n    },\n  })\n  hooks.stateReducers.push(reducer)\n  hooks.useInstance.push(useInstance)\n  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)\n}\n\nconst defaultGetResizerProps = (props, { instance, header }) => {\n  const { dispatch } = instance\n\n  const onResizeStart = (e, header) => {\n    let isTouchEvent = false\n    if (e.type === 'touchstart') {\n      // lets not respond to multiple touches (e.g. 2 or 3 fingers)\n      if (e.touches && e.touches.length > 1) {\n        return\n      }\n      isTouchEvent = true\n    }\n    const headersToResize = getLeafHeaders(header)\n    const headerIdWidths = headersToResize.map(d => [d.id, d.totalWidth])\n\n    const clientX = isTouchEvent ? Math.round(e.touches[0].clientX) : e.clientX\n\n    const dispatchMove = clientXPos => {\n      dispatch({ type: actions.columnResizing, clientX: clientXPos })\n    }\n    const dispatchEnd = () => dispatch({ type: actions.columnDoneResizing })\n\n    const handlersAndEvents = {\n      mouse: {\n        moveEvent: 'mousemove',\n        moveHandler: e => dispatchMove(e.clientX),\n        upEvent: 'mouseup',\n        upHandler: e => {\n          document.removeEventListener(\n            'mousemove',\n            handlersAndEvents.mouse.moveHandler\n          )\n          document.removeEventListener(\n            'mouseup',\n            handlersAndEvents.mouse.upHandler\n          )\n          dispatchEnd()\n        },\n      },\n      touch: {\n        moveEvent: 'touchmove',\n        moveHandler: e => {\n          if (e.cancelable) {\n            e.preventDefault()\n            e.stopPropagation()\n          }\n          dispatchMove(e.touches[0].clientX)\n          return false\n        },\n        upEvent: 'touchend',\n        upHandler: e => {\n          document.removeEventListener(\n            handlersAndEvents.touch.moveEvent,\n            handlersAndEvents.touch.moveHandler\n          )\n          document.removeEventListener(\n            handlersAndEvents.touch.upEvent,\n            handlersAndEvents.touch.moveHandler\n          )\n          dispatchEnd()\n        },\n      },\n    }\n\n    const events = isTouchEvent\n      ? handlersAndEvents.touch\n      : handlersAndEvents.mouse\n    const passiveIfSupported = passiveEventSupported()\n      ? { passive: false }\n      : false\n    document.addEventListener(\n      events.moveEvent,\n      events.moveHandler,\n      passiveIfSupported\n    )\n    document.addEventListener(\n      events.upEvent,\n      events.upHandler,\n      passiveIfSupported\n    )\n\n    dispatch({\n      type: actions.columnStartResizing,\n      columnId: header.id,\n      columnWidth: header.totalWidth,\n      headerIdWidths,\n      clientX,\n    })\n  }\n\n  return [\n    props,\n    {\n      onMouseDown: e => e.persist() || onResizeStart(e, header),\n      onTouchStart: e => e.persist() || onResizeStart(e, header),\n      style: {\n        cursor: 'ew-resize',\n      },\n      draggable: false,\n      role: 'separator',\n    },\n  ]\n}\n\nuseResizeColumns.pluginName = 'useResizeColumns'\n\nfunction reducer(state, action) {\n  if (action.type === actions.init) {\n    return {\n      columnResizing: {\n        columnWidths: {},\n      },\n      ...state,\n    }\n  }\n\n  if (action.type === actions.resetResize) {\n    return {\n      ...state,\n      columnResizing: {\n        columnWidths: {},\n      },\n    }\n  }\n\n  if (action.type === actions.columnStartResizing) {\n    const { clientX, columnId, columnWidth, headerIdWidths } = action\n\n    return {\n      ...state,\n      columnResizing: {\n        ...state.columnResizing,\n        startX: clientX,\n        headerIdWidths,\n        columnWidth,\n        isResizingColumn: columnId,\n      },\n    }\n  }\n\n  if (action.type === actions.columnResizing) {\n    const { clientX } = action\n    const { startX, columnWidth, headerIdWidths } = state.columnResizing\n\n    const deltaX = clientX - startX\n    const percentageDeltaX = deltaX / columnWidth\n\n    const newColumnWidths = {}\n\n    headerIdWidths.forEach(([headerId, headerWidth]) => {\n      newColumnWidths[headerId] = Math.max(\n        headerWidth + headerWidth * percentageDeltaX,\n        0\n      )\n    })\n\n    return {\n      ...state,\n      columnResizing: {\n        ...state.columnResizing,\n        columnWidths: {\n          ...state.columnResizing.columnWidths,\n          ...newColumnWidths,\n        },\n      },\n    }\n  }\n\n  if (action.type === actions.columnDoneResizing) {\n    return {\n      ...state,\n      columnResizing: {\n        ...state.columnResizing,\n        startX: null,\n        isResizingColumn: null,\n      },\n    }\n  }\n}\n\nconst useInstanceBeforeDimensions = instance => {\n  const {\n    flatHeaders,\n    disableResizing,\n    getHooks,\n    state: { columnResizing },\n  } = instance\n\n  const getInstance = useGetLatest(instance)\n\n  flatHeaders.forEach(header => {\n    const canResize = getFirstDefined(\n      header.disableResizing === true ? false : undefined,\n      disableResizing === true ? false : undefined,\n      true\n    )\n\n    header.canResize = canResize\n    header.width =\n      columnResizing.columnWidths[header.id] ||\n      header.originalWidth ||\n      header.width\n    header.isResizing = columnResizing.isResizingColumn === header.id\n\n    if (canResize) {\n      header.getResizerProps = makePropGetter(getHooks().getResizerProps, {\n        instance: getInstance(),\n        header,\n      })\n    }\n  })\n}\n\nfunction useInstance(instance) {\n  const { plugins, dispatch, autoResetResize = true, columns } = instance\n\n  ensurePluginOrder(plugins, ['useAbsoluteLayout'], 'useResizeColumns')\n\n  const getAutoResetResize = useGetLatest(autoResetResize)\n  useMountedLayoutEffect(() => {\n    if (getAutoResetResize()) {\n      dispatch({ type: actions.resetResize })\n    }\n  }, [columns])\n\n  const resetResizing = React.useCallback(\n    () => dispatch({ type: actions.resetResize }),\n    [dispatch]\n  )\n\n  Object.assign(instance, {\n    resetResizing,\n  })\n}\n\nfunction getLeafHeaders(header) {\n  const leafHeaders = []\n  const recurseHeader = header => {\n    if (header.columns && header.columns.length) {\n      header.columns.map(recurseHeader)\n    }\n    leafHeaders.push(header)\n  }\n  recurseHeader(header)\n  return leafHeaders\n}\n","const cellStyles = {\n  position: 'absolute',\n  top: 0,\n}\n\nexport const useAbsoluteLayout = hooks => {\n  hooks.getTableBodyProps.push(getRowStyles)\n  hooks.getRowProps.push(getRowStyles)\n  hooks.getHeaderGroupProps.push(getRowStyles)\n  hooks.getFooterGroupProps.push(getRowStyles)\n\n  hooks.getHeaderProps.push((props, { column }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        left: `${column.totalLeft}px`,\n        width: `${column.totalWidth}px`,\n      },\n    },\n  ])\n\n  hooks.getCellProps.push((props, { cell }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        left: `${cell.column.totalLeft}px`,\n        width: `${cell.column.totalWidth}px`,\n      },\n    },\n  ])\n\n  hooks.getFooterProps.push((props, { column }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        left: `${column.totalLeft}px`,\n        width: `${column.totalWidth}px`,\n      },\n    },\n  ])\n}\n\nuseAbsoluteLayout.pluginName = 'useAbsoluteLayout'\n\nconst getRowStyles = (props, { instance }) => [\n  props,\n  {\n    style: {\n      position: 'relative',\n      width: `${instance.totalColumnsWidth}px`,\n    },\n  },\n]\n","const cellStyles = {\n  display: 'inline-block',\n  boxSizing: 'border-box',\n}\n\nconst getRowStyles = (props, { instance }) => [\n  props,\n  {\n    style: {\n      display: 'flex',\n      width: `${instance.totalColumnsWidth}px`,\n    },\n  },\n]\n\nexport const useBlockLayout = hooks => {\n  hooks.getRowProps.push(getRowStyles)\n  hooks.getHeaderGroupProps.push(getRowStyles)\n  hooks.getFooterGroupProps.push(getRowStyles)\n\n  hooks.getHeaderProps.push((props, { column }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        width: `${column.totalWidth}px`,\n      },\n    },\n  ])\n\n  hooks.getCellProps.push((props, { cell }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        width: `${cell.column.totalWidth}px`,\n      },\n    },\n  ])\n\n  hooks.getFooterProps.push((props, { column }) => [\n    props,\n    {\n      style: {\n        ...cellStyles,\n        width: `${column.totalWidth}px`,\n      },\n    },\n  ])\n}\n\nuseBlockLayout.pluginName = 'useBlockLayout'\n","export function useFlexLayout(hooks) {\n  hooks.getTableProps.push(getTableProps)\n  hooks.getRowProps.push(getRowStyles)\n  hooks.getHeaderGroupProps.push(getRowStyles)\n  hooks.getFooterGroupProps.push(getRowStyles)\n  hooks.getHeaderProps.push(getHeaderProps)\n  hooks.getCellProps.push(getCellProps)\n  hooks.getFooterProps.push(getFooterProps)\n}\n\nuseFlexLayout.pluginName = 'useFlexLayout'\n\nconst getTableProps = (props, { instance }) => [\n  props,\n  {\n    style: {\n      minWidth: `${instance.totalColumnsWidth}px`,\n    },\n  },\n]\n\nconst getRowStyles = (props, { instance }) => [\n  props,\n  {\n    style: {\n      display: 'flex',\n      flex: '1 0 auto',\n      minWidth: `${instance.totalColumnsMinWidth}px`,\n    },\n  },\n]\n\nconst getHeaderProps = (props, { column }) => [\n  props,\n  {\n    style: {\n      boxSizing: 'border-box',\n      flex: column.totalFlexWidth\n        ? `${column.totalFlexWidth} 0 auto`\n        : undefined,\n      minWidth: `${column.totalMinWidth}px`,\n      width: `${column.totalWidth}px`,\n    },\n  },\n]\n\nconst getCellProps = (props, { cell }) => [\n  props,\n  {\n    style: {\n      boxSizing: 'border-box',\n      flex: `${cell.column.totalFlexWidth} 0 auto`,\n      minWidth: `${cell.column.totalMinWidth}px`,\n      width: `${cell.column.totalWidth}px`,\n    },\n  },\n]\n\nconst getFooterProps = (props, { column }) => [\n  props,\n  {\n    style: {\n      boxSizing: 'border-box',\n      flex: column.totalFlexWidth\n        ? `${column.totalFlexWidth} 0 auto`\n        : undefined,\n      minWidth: `${column.totalMinWidth}px`,\n      width: `${column.totalWidth}px`,\n    },\n  },\n]\n","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nvar Table = React.forwardRef(function (_ref, ref) {\n  var bsPrefix = _ref.bsPrefix,\n      className = _ref.className,\n      striped = _ref.striped,\n      bordered = _ref.bordered,\n      borderless = _ref.borderless,\n      hover = _ref.hover,\n      size = _ref.size,\n      variant = _ref.variant,\n      responsive = _ref.responsive,\n      props = _objectWithoutPropertiesLoose(_ref, [\"bsPrefix\", \"className\", \"striped\", \"bordered\", \"borderless\", \"hover\", \"size\", \"variant\", \"responsive\"]);\n\n  var decoratedBsPrefix = useBootstrapPrefix(bsPrefix, 'table');\n  var classes = classNames(className, decoratedBsPrefix, variant && decoratedBsPrefix + \"-\" + variant, size && decoratedBsPrefix + \"-\" + size, striped && decoratedBsPrefix + \"-striped\", bordered && decoratedBsPrefix + \"-bordered\", borderless && decoratedBsPrefix + \"-borderless\", hover && decoratedBsPrefix + \"-hover\");\n  var table = /*#__PURE__*/React.createElement(\"table\", _extends({}, props, {\n    className: classes,\n    ref: ref\n  }));\n\n  if (responsive) {\n    var responsiveClass = decoratedBsPrefix + \"-responsive\";\n\n    if (typeof responsive === 'string') {\n      responsiveClass = responsiveClass + \"-\" + responsive;\n    }\n\n    return /*#__PURE__*/React.createElement(\"div\", {\n      className: responsiveClass\n    }, table);\n  }\n\n  return table;\n});\nexport default Table;"],"sourceRoot":""}