@tanstack/react-table 8.0.0-alpha.2 → 8.0.0-alpha.5

package/build/umd/index.development.js

@@ -37,7 +37,8 @@
   var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
   var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-  var columnFilterRowsFn = function columnFilterRowsFn(instance, columnFilters, rowModel) {
+  function columnFilterRowsFn(instance, rowModel) {
+    var columnFilters = instance.getState().columnFilters;
     var newFilteredFlatRows = [];
     var newFilteredRowsById = {};
     var filterFromChildrenUp = instance.options.filterFromChildrenUp;
@@ -149,9 +150,10 @@
       flatRows: newFilteredFlatRows,
       rowsById: newFilteredRowsById
     };
-  };
+  }
 
-  var globalFilterRowsFn = function globalFilterRowsFn(instance, globalFilter, rowModel) {
+  function globalFilterRowsFn(instance, rowModel) {
+    var globalFilter = instance.getState().globalFilter;
     var newFilteredFlatRows = [];
     var newFilteredRowsById = {};
     var filterFromChildrenUp = instance.options.filterFromChildrenUp;
@@ -233,9 +235,10 @@
       flatRows: newFilteredFlatRows,
       rowsById: newFilteredRowsById
     };
-  };
+  }
 
-  var sortRowsFn = function sortRowsFn(instance, sortingState, rowModel) {
+  function sortRowsFn(instance, rowModel) {
+    var sortingState = instance.getState().sorting;
     var sortedFlatRows = []; // Filter out sortings that correspond to non existing columns
 
     var availableSorting = sortingState.filter(function (sort) {
@@ -310,7 +313,7 @@
       flatRows: sortedFlatRows,
       rowsById: rowModel.rowsById
     };
-  };
+  }
 
   function _extends() {
     _extends = Object.assign || function (target) {
@@ -444,7 +447,7 @@
 
     return _extends({}, initial, getter != null ? getter : {});
   };
-  function memo(getDeps, fn, key, debug) {
+  function memo(getDeps, fn, opts) {
     var deps = [];
     var result;
     return function () {
@@ -456,8 +459,8 @@
       });
 
       if (depsChanged) {
-        if (debug) {
-          console.info(key, _extends({
+        if (opts != null && opts.debug) {
+          console.info(opts == null ? void 0 : opts.key, _extends({
             length: oldSerializedDeps.length + " -> " + newSerializedDeps.length
           }, newSerializedDeps.map(function (_, index) {
             if (oldSerializedDeps[index] !== newSerializedDeps[index]) {
@@ -474,8 +477,11 @@
           }));
         }
 
+        var oldResult = result;
         result = fn.apply(void 0, newDeps);
         deps = newSerializedDeps;
+        opts == null ? void 0 : opts.onChange == null ? void 0 : opts.onChange(result, oldResult);
+        oldResult = undefined;
       }
 
       return result;
@@ -516,8 +522,9 @@
   //   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString()
   // }
 
-  var groupRowsFn = function groupRowsFn(instance, groupingState, sortedRowModel) {
-    // Filter the grouping list down to columns that exist
+  function groupRowsFn(instance, sortedRowModel) {
+    var groupingState = instance.getState().grouping; // Filter the grouping list down to columns that exist
+
     var existingGrouping = groupingState.filter(function (columnId) {
       return instance.getColumn(columnId);
     }); // Find the columns that can or are aggregating
@@ -634,7 +641,7 @@
       flatRows: groupedFlatRows,
       rowsById: groupedRowsById
     };
-  };
+  }
 
   function groupBy(rows, columnId) {
     var groupMap = new Map();
@@ -652,7 +659,7 @@
     }, groupMap);
   }
 
-  var expandRowsFn = function expandRowsFn(instance, _expandedState, sortedRowModel) {
+  function expandRowsFn(instance, sortedRowModel) {
     var expandedRows = [];
     var expandSubRows = instance.options.expandSubRows;
 
@@ -672,15 +679,41 @@
       flatRows: sortedRowModel.flatRows,
       rowsById: sortedRowModel.rowsById
     };
-  };
+  }
+
+  function paginateRowsFn(instance, rowModel) {
+    var _instance$getState$pa = instance.getState().pagination,
+        pageSize = _instance$getState$pa.pageSize,
+        pageIndex = _instance$getState$pa.pageIndex;
+    var rows = rowModel.rows,
+        flatRows = rowModel.flatRows,
+        rowsById = rowModel.rowsById;
+    var pageStart = pageSize * pageIndex;
+    var pageEnd = pageStart + pageSize;
+    rows = rows.slice(pageStart, pageEnd);
+
+    if (!instance.options.paginateExpandedRows) {
+      return expandRowsFn(instance, {
+        rows: rows,
+        flatRows: flatRows,
+        rowsById: rowsById
+      });
+    }
+
+    return {
+      rows: rows,
+      flatRows: flatRows,
+      rowsById: rowsById
+    };
+  }
 
   //
-  function getInitialState$7() {
+  function getInitialState$9() {
     return {
       columnVisibility: {}
     };
   }
-  function getDefaultOptions$7(instance) {
+  function getDefaultOptions$9(instance) {
     return {
       onColumnVisibilityChange: makeStateUpdater('columnVisibility', instance)
     };
@@ -714,7 +747,7 @@
       }
     };
   }
-  function getInstance$8(instance) {
+  function getInstance$a(instance) {
     return {
       getVisibleFlatColumns: memo(function () {
         return [instance.getAllFlatColumns(), instance.getAllFlatColumns().filter(function (d) {
@@ -726,7 +759,10 @@
         return allFlatColumns.filter(function (d) {
           return d.getIsVisible == null ? void 0 : d.getIsVisible();
         });
-      }, 'getVisibleFlatColumns', instance.options.debug),
+      }, {
+        key: 'getVisibleFlatColumns',
+        debug: instance.options.debug
+      }),
       getVisibleLeafColumns: memo(function () {
         return [instance.getAllLeafColumns(), instance.getAllLeafColumns().filter(function (d) {
           return d.getIsVisible == null ? void 0 : d.getIsVisible();
@@ -737,7 +773,10 @@
         return allFlatColumns.filter(function (d) {
           return d.getIsVisible == null ? void 0 : d.getIsVisible();
         });
-      }, 'getVisibleLeafColumns', instance.options.debug),
+      }, {
+        key: 'getVisibleLeafColumns',
+        debug: instance.options.debug
+      }),
       setColumnVisibility: function setColumnVisibility(updater) {
         return instance.options.onColumnVisibilityChange == null ? void 0 : instance.options.onColumnVisibilityChange(updater, functionalUpdate(updater, instance.getState().columnVisibility));
       },
@@ -811,6 +850,15 @@
     };
   }
 
+  var Visibility = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState$9,
+    getDefaultOptions: getDefaultOptions$9,
+    getDefaultColumn: getDefaultColumn$3,
+    createColumn: createColumn$5,
+    getInstance: getInstance$a
+  });
+
   var aggregationTypes = {
     sum: sum,
     min: min,
@@ -929,12 +977,12 @@
       aggregationType: 'auto'
     };
   }
-  function getInitialState$6() {
+  function getInitialState$8() {
     return {
       grouping: []
     };
   }
-  function getDefaultOptions$6(instance) {
+  function getDefaultOptions$8(instance) {
     return {
       onGroupingChange: makeStateUpdater('grouping', instance),
       autoResetGrouping: true,
@@ -961,8 +1009,23 @@
       }
     };
   }
-  function getInstance$7(instance) {
+  function getInstance$9(instance) {
+    var registered = false;
     return {
+      _notifyGroupingReset: function _notifyGroupingReset() {
+        if (!registered) {
+          registered = true;
+          return;
+        }
+
+        if (instance.options.autoResetAll === false) {
+          return;
+        }
+
+        if (instance.options.autoResetAll === true || instance.options.autoResetGrouping) {
+          instance.resetGrouping();
+        }
+      },
       getColumnAutoAggregationFn: function getColumnAutoAggregationFn(columnId) {
         var firstRow = instance.getCoreFlatRows()[0];
         var value = firstRow == null ? void 0 : firstRow.values[columnId];
@@ -1060,8 +1123,14 @@
         }
 
         if (instance.options.debug) console.info('Grouping...');
-        return groupRowsFn(instance, grouping, rowModel);
-      }, 'getGroupedRowModel', instance.options.debug),
+        return groupRowsFn(instance, rowModel);
+      }, {
+        key: 'getGroupedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyExpandedReset();
+        }
+      }),
       getPreGroupedRows: function getPreGroupedRows() {
         return instance.getSortedRowModel().rows;
       },
@@ -1082,7 +1151,7 @@
       }
     };
   }
-  function createRow$2(row, instance) {
+  function createRow$3(row, instance) {
     return {
       getIsGrouped: function getIsGrouped() {
         return instance.getRowIsGrouped(row.id);
@@ -1125,18 +1194,30 @@
     return [].concat(groupingColumns, nonGroupingColumns);
   }
 
+  var Grouping = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getDefaultColumn: getDefaultColumn$2,
+    getInitialState: getInitialState$8,
+    getDefaultOptions: getDefaultOptions$8,
+    createColumn: createColumn$4,
+    getInstance: getInstance$9,
+    createRow: createRow$3,
+    createCell: createCell,
+    orderColumns: orderColumns
+  });
+
   //
-  function getInitialState$5() {
+  function getInitialState$7() {
     return {
       columnOrder: []
     };
   }
-  function getDefaultOptions$5(instance) {
+  function getDefaultOptions$7(instance) {
     return {
       onColumnOrderChange: makeStateUpdater('columnOrder', instance)
     };
   }
-  function getInstance$6(instance) {
+  function getInstance$8(instance) {
     return {
       setColumnOrder: function setColumnOrder(updater) {
         return instance.options.onColumnOrderChange == null ? void 0 : instance.options.onColumnOrderChange(updater, functionalUpdate(updater, instance.getState().columnOrder));
@@ -1183,12 +1264,22 @@
 
           return orderColumns(orderedColumns, grouping, groupedColumnMode);
         };
-      }, 'getOrderColumnsFn', instance.options.debug)
+      }, {
+        key: 'getOrderColumnsFn',
+        debug: instance.options.debug
+      })
     };
   }
 
+  var Ordering = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState$7,
+    getDefaultOptions: getDefaultOptions$7,
+    getInstance: getInstance$8
+  });
+
   //
-  function getInitialState$4() {
+  function getInitialState$6() {
     return {
       columnPinning: {
         left: [],
@@ -1196,7 +1287,7 @@
       }
     };
   }
-  function getDefaultOptions$4(instance) {
+  function getDefaultOptions$6(instance) {
     return {
       onColumnPinningChange: makeStateUpdater('columnPinning', instance)
     };
@@ -1217,7 +1308,7 @@
       }
     };
   }
-  function getInstance$5(instance) {
+  function getInstance$7(instance) {
     return {
       setColumnPinning: function setColumnPinning(updater) {
         return instance.options.onColumnPinningChange == null ? void 0 : instance.options.onColumnPinningChange(updater, functionalUpdate(updater, instance.getState().columnPinning));
@@ -1304,1892 +1395,2821 @@
         var isRight = leafColumnIds.some(function (d) {
           return right == null ? void 0 : right.includes(d);
         });
-
-        if (isLeft && isRight) {
-          return 'both';
-        }
-
         return isLeft ? 'left' : isRight ? 'right' : false;
       },
       getColumnPinnedIndex: function getColumnPinnedIndex(columnId) {
         var _instance$getState$co2, _instance$getState$co3, _instance$getState$co4;
 
         var position = instance.getColumnIsPinned(columnId);
-
-        if (position === 'both') {
-          {
-            console.warn("Column " + columnId + " has leaf columns that are pinned on both sides");
-          }
-
-          throw new Error();
-        }
-
         return position ? (_instance$getState$co2 = (_instance$getState$co3 = instance.getState().columnPinning) == null ? void 0 : (_instance$getState$co4 = _instance$getState$co3[position]) == null ? void 0 : _instance$getState$co4.indexOf(columnId)) != null ? _instance$getState$co2 : -1 : 0;
       }
     };
   }
 
+  var Pinning = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState$6,
+    getDefaultOptions: getDefaultOptions$6,
+    createColumn: createColumn$3,
+    getInstance: getInstance$7
+  });
+
   //
-  var defaultColumnSizing = {
-    width: 150,
-    minWidth: 20,
-    maxWidth: Number.MAX_SAFE_INTEGER
-  };
-  function getInitialState$3() {
-    return {
-      columnSizing: {},
-      columnSizingInfo: {
-        startOffset: null,
-        startSize: null,
-        deltaOffset: null,
-        deltaPercentage: null,
-        isResizingColumn: false,
-        columnSizingStart: []
-      }
-    };
-  }
-  function getDefaultOptions$3(instance) {
+  function createRow$2(row, instance) {
     return {
-      columnResizeMode: 'onEnd',
-      onColumnSizingChange: makeStateUpdater('columnSizing', instance),
-      onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', instance)
+      _getAllVisibleCells: memo(function () {
+        return [row.getAllCells().filter(function (cell) {
+          return cell.column.getIsVisible();
+        }).map(function (d) {
+          return d.id;
+        }).join('_')];
+      }, function (_) {
+        return row.getAllCells().filter(function (cell) {
+          return cell.column.getIsVisible();
+        });
+      }, {
+        key: 'row._getAllVisibleCells',
+        debug: instance.options.debug
+      }),
+      getVisibleCells: memo(function () {
+        return [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()];
+      }, function (left, center, right) {
+        return [].concat(left, center, right);
+      }, {
+        key: 'row.getVisibleCells',
+        debug: instance.options.debug
+      }),
+      getCenterVisibleCells: memo(function () {
+        return [row._getAllVisibleCells(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
+      }, function (allCells, left, right) {
+        var leftAndRight = [].concat(left != null ? left : [], right != null ? right : []);
+        return allCells.filter(function (d) {
+          return !leftAndRight.includes(d.columnId);
+        });
+      }, {
+        key: 'row.getCenterVisibleCells',
+        debug: instance.options.debug
+      }),
+      getLeftVisibleCells: memo(function () {
+        return [row._getAllVisibleCells(), instance.getState().columnPinning.left,,];
+      }, function (allCells, left) {
+        var cells = (left != null ? left : []).map(function (columnId) {
+          return allCells.find(function (cell) {
+            return cell.columnId === columnId;
+          });
+        }).filter(Boolean);
+        return cells;
+      }, {
+        key: 'row.getLeftVisibleCells',
+        debug: instance.options.debug
+      }),
+      getRightVisibleCells: memo(function () {
+        return [row._getAllVisibleCells(), instance.getState().columnPinning.right];
+      }, function (allCells, right) {
+        var cells = (right != null ? right : []).map(function (columnId) {
+          return allCells.find(function (cell) {
+            return cell.columnId === columnId;
+          });
+        }).filter(Boolean);
+        return cells;
+      }, {
+        key: 'row.getRightVisibleCells',
+        debug: instance.options.debug
+      })
     };
   }
-  function getInstance$4(instance) {
+  function getInstance$6(instance) {
     return {
-      setColumnSizing: function setColumnSizing(updater) {
-        return instance.options.onColumnSizingChange == null ? void 0 : instance.options.onColumnSizingChange(updater, functionalUpdate(updater, instance.getState().columnSizing));
-      },
-      setColumnSizingInfo: function setColumnSizingInfo(updater) {
-        return instance.options.onColumnSizingInfoChange == null ? void 0 : instance.options.onColumnSizingInfoChange(updater, functionalUpdate(updater, instance.getState().columnSizingInfo));
-      },
-      resetColumnSizing: function resetColumnSizing() {
-        var _instance$initialStat;
-
-        instance.setColumnSizing((_instance$initialStat = instance.initialState.columnSizing) != null ? _instance$initialStat : {});
-      },
-      resetHeaderSizeInfo: function resetHeaderSizeInfo() {
-        var _instance$initialStat2;
-
-        instance.setColumnSizingInfo((_instance$initialStat2 = instance.initialState.columnSizingInfo) != null ? _instance$initialStat2 : {});
-      },
-      resetColumnSize: function resetColumnSize(columnId) {
-        instance.setColumnSizing(function (_ref) {
-          _ref[columnId];
-              var rest = _objectWithoutPropertiesLoose(_ref, [columnId].map(_toPropertyKey));
-
-          return rest;
-        });
-      },
-      resetHeaderSize: function resetHeaderSize(headerId) {
-        var header = instance.getHeader(headerId);
-
-        if (!header) {
-          return;
-        }
-
-        return instance.resetColumnSize(header.column.id);
-      },
-      getHeaderCanResize: function getHeaderCanResize(headerId) {
-        var header = instance.getHeader(headerId);
-
-        if (!header) {
-          throw new Error();
-        }
+      createHeader: function createHeader(column, options) {
+        var _options$id;
 
-        return instance.getColumnCanResize(header.column.id);
-      },
-      getColumnCanResize: function getColumnCanResize(columnId) {
-        var _ref2, _ref3, _column$enableResizin;
+        var id = (_options$id = options.id) != null ? _options$id : column.id;
+        var header = {
+          id: id,
+          column: column,
+          isPlaceholder: options.isPlaceholder,
+          placeholderId: options.placeholderId,
+          depth: options.depth,
+          subHeaders: [],
+          colSpan: 0,
+          rowSpan: 0,
+          getWidth: function getWidth() {
+            var sum = 0;
 
-        var column = instance.getColumn(columnId);
+            var recurse = function recurse(header) {
+              if (header.subHeaders.length) {
+                header.subHeaders.forEach(recurse);
+              } else {
+                var _header$column$getWid;
 
-        if (!column) {
-          throw new Error();
-        }
+                sum += (_header$column$getWid = header.column.getWidth()) != null ? _header$column$getWid : 0;
+              }
+            };
 
-        return (_ref2 = (_ref3 = (_column$enableResizin = column.enableResizing) != null ? _column$enableResizin : instance.options.enableColumnResizing) != null ? _ref3 : column.defaultCanResize) != null ? _ref2 : true;
-      },
-      getColumnIsResizing: function getColumnIsResizing(columnId) {
-        var column = instance.getColumn(columnId);
+            recurse(header);
+            return sum;
+          },
+          getLeafHeaders: function getLeafHeaders() {
+            var leafHeaders = [];
 
-        if (!column) {
-          throw new Error();
-        }
+            var recurseHeader = function recurseHeader(h) {
+              if (h.subHeaders && h.subHeaders.length) {
+                h.subHeaders.map(recurseHeader);
+              }
 
-        return instance.getState().columnSizingInfo.isResizingColumn === columnId;
-      },
-      getHeaderIsResizing: function getHeaderIsResizing(headerId) {
-        var header = instance.getHeader(headerId);
+              leafHeaders.push(h);
+            };
 
-        if (!header) {
-          throw new Error();
-        }
+            recurseHeader(header);
+            return leafHeaders;
+          },
+          getHeaderProps: function getHeaderProps(userProps) {
+            return instance.getHeaderProps(header.id, userProps);
+          },
+          getFooterProps: function getFooterProps(userProps) {
+            return instance.getFooterProps(header.id, userProps);
+          },
+          renderHeader: function renderHeader() {
+            return flexRender(column.header, {
+              instance: instance,
+              header: header,
+              column: column
+            });
+          },
+          renderFooter: function renderFooter() {
+            return flexRender(column.footer, {
+              instance: instance,
+              header: header,
+              column: column
+            });
+          }
+        }; // Yes, we have to convert instance to uknown, because we know more than the compiler here.
 
-        return instance.getColumnIsResizing(header.column.id);
+        return header;
       },
-      getHeaderResizerProps: function getHeaderResizerProps(headerId, userProps) {
-        var header = instance.getHeader(headerId);
-
-        if (!header) {
-          return;
-        }
-
-        var column = instance.getColumn(header.column.id);
-
-        if (!column) {
-          return;
-        }
-
-        var canResize = column.getCanResize();
-
-        var onResizeStart = function onResizeStart(e) {
-          if (isTouchStartEvent(e)) {
-            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
-            if (e.touches && e.touches.length > 1) {
-              return;
-            }
+      // Header Groups
+      getHeaderGroups: memo(function () {
+        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
+      }, function (allColumns, leafColumns, left, right) {
+        var leftColumns = leafColumns.filter(function (column) {
+          return left == null ? void 0 : left.includes(column.id);
+        });
+        var rightColumns = leafColumns.filter(function (column) {
+          return right == null ? void 0 : right.includes(column.id);
+        });
+        var centerColumns = leafColumns.filter(function (column) {
+          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
+        });
+        var headerGroups = buildHeaderGroups(allColumns, [].concat(leftColumns, centerColumns, rightColumns), instance);
+        return headerGroups;
+      }, {
+        key: 'getHeaderGroups',
+        debug: instance.options.debug
+      }),
+      getCenterHeaderGroups: memo(function () {
+        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
+      }, function (allColumns, leafColumns, left, right) {
+        leafColumns = leafColumns.filter(function (column) {
+          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
+        });
+        return buildHeaderGroups(allColumns, leafColumns, instance, 'center');
+      }, {
+        key: 'getCenterHeaderGroups',
+        debug: instance.options.debug
+      }),
+      getLeftHeaderGroups: memo(function () {
+        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left];
+      }, function (allColumns, leafColumns, left) {
+        leafColumns = leafColumns.filter(function (column) {
+          return left == null ? void 0 : left.includes(column.id);
+        });
+        return buildHeaderGroups(allColumns, leafColumns, instance, 'left');
+      }, {
+        key: 'getLeftHeaderGroups',
+        debug: instance.options.debug
+      }),
+      getRightHeaderGroups: memo(function () {
+        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.right];
+      }, function (allColumns, leafColumns, right) {
+        leafColumns = leafColumns.filter(function (column) {
+          return right == null ? void 0 : right.includes(column.id);
+        });
+        return buildHeaderGroups(allColumns, leafColumns, instance, 'right');
+      }, {
+        key: 'getRightHeaderGroups',
+        debug: instance.options.debug
+      }),
+      // Footer Groups
+      getFooterGroups: memo(function () {
+        return [instance.getHeaderGroups()];
+      }, function (headerGroups) {
+        return [].concat(headerGroups).reverse();
+      }, {
+        key: 'getFooterGroups',
+        debug: instance.options.debug
+      }),
+      getLeftFooterGroups: memo(function () {
+        return [instance.getLeftHeaderGroups()];
+      }, function (headerGroups) {
+        return [].concat(headerGroups).reverse();
+      }, {
+        key: 'getLeftFooterGroups',
+        debug: instance.options.debug
+      }),
+      getCenterFooterGroups: memo(function () {
+        return [instance.getCenterHeaderGroups()];
+      }, function (headerGroups) {
+        return [].concat(headerGroups).reverse();
+      }, {
+        key: 'getCenterFooterGroups',
+        debug: instance.options.debug
+      }),
+      getRightFooterGroups: memo(function () {
+        return [instance.getRightHeaderGroups()];
+      }, function (headerGroups) {
+        return [].concat(headerGroups).reverse();
+      }, {
+        key: 'getRightFooterGroups',
+        debug: instance.options.debug
+      }),
+      // Flat Headers
+      getFlatHeaders: memo(function () {
+        return [instance.getHeaderGroups()];
+      }, function (headerGroups) {
+        return headerGroups.map(function (headerGroup) {
+          return headerGroup.headers;
+        }).flat();
+      }, {
+        key: 'getFlatHeaders',
+        debug: instance.options.debug
+      }),
+      getLeftFlatHeaders: memo(function () {
+        return [instance.getLeftHeaderGroups()];
+      }, function (left) {
+        return left.map(function (headerGroup) {
+          return headerGroup.headers;
+        }).flat();
+      }, {
+        key: 'getLeftFlatHeaders',
+        debug: instance.options.debug
+      }),
+      getCenterFlatHeaders: memo(function () {
+        return [instance.getCenterHeaderGroups()];
+      }, function (left) {
+        return left.map(function (headerGroup) {
+          return headerGroup.headers;
+        }).flat();
+      }, {
+        key: 'getCenterFlatHeaders',
+        debug: instance.options.debug
+      }),
+      getRightFlatHeaders: memo(function () {
+        return [instance.getRightHeaderGroups()];
+      }, function (left) {
+        return left.map(function (headerGroup) {
+          return headerGroup.headers;
+        }).flat();
+      }, {
+        key: 'getRightFlatHeaders',
+        debug: instance.options.debug
+      }),
+      // Leaf Headers
+      getCenterLeafHeaders: memo(function () {
+        return [instance.getCenterFlatHeaders()];
+      }, function (flatHeaders) {
+        return flatHeaders.filter(function (header) {
+          var _header$subHeaders;
+
+          return !((_header$subHeaders = header.subHeaders) != null && _header$subHeaders.length);
+        });
+      }, {
+        key: 'getCenterLeafHeaders',
+        debug: instance.options.debug
+      }),
+      getLeftLeafHeaders: memo(function () {
+        return [instance.getLeftFlatHeaders()];
+      }, function (flatHeaders) {
+        return flatHeaders.filter(function (header) {
+          var _header$subHeaders2;
+
+          return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length);
+        });
+      }, {
+        key: 'getLeftLeafHeaders',
+        debug: instance.options.debug
+      }),
+      getRightLeafHeaders: memo(function () {
+        return [instance.getRightFlatHeaders()];
+      }, function (flatHeaders) {
+        return flatHeaders.filter(function (header) {
+          var _header$subHeaders3;
+
+          return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length);
+        });
+      }, {
+        key: 'getRightLeafHeaders',
+        debug: instance.options.debug
+      }),
+      getLeafHeaders: memo(function () {
+        return [instance.getLeftHeaderGroups(), instance.getCenterHeaderGroups(), instance.getRightHeaderGroups()];
+      }, function (left, center, right) {
+        var _left$0$headers, _left$, _center$0$headers, _center$, _right$0$headers, _right$;
+
+        return [].concat((_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : [], (_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : [], (_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : []).map(function (header) {
+          return header.getLeafHeaders();
+        }).flat();
+      }, {
+        key: 'getLeafHeaders',
+        debug: instance.options.debug
+      }),
+      getHeader: function getHeader(id) {
+        var header = [].concat(instance.getFlatHeaders(), instance.getCenterFlatHeaders(), instance.getLeftFlatHeaders(), instance.getRightFlatHeaders()).find(function (d) {
+          return d.id === id;
+        });
+
+        if (!header) {
+          {
+            console.warn("Could not find header with id: " + id);
           }
 
-          var columnSizingStart = header.getLeafHeaders().map(function (d) {
-            return [d.column.id, d.getWidth()];
+          throw new Error();
+        }
+
+        return header;
+      },
+      getHeaderGroupProps: function getHeaderGroupProps(id, userProps) {
+        var headerGroup = instance.getHeaderGroups().find(function (d) {
+          return d.id === id;
+        });
+
+        if (!headerGroup) {
+          return;
+        }
+
+        return propGetter({
+          key: headerGroup.id,
+          role: 'row'
+        }, userProps);
+      },
+      getFooterGroupProps: function getFooterGroupProps(id, userProps) {
+        var headerGroup = instance.getFooterGroups().find(function (d) {
+          return d.id === id;
+        });
+
+        if (!headerGroup) {
+          return;
+        }
+
+        var initialProps = {
+          key: headerGroup.id,
+          role: 'row'
+        };
+        return propGetter(initialProps, userProps);
+      },
+      getHeaderProps: function getHeaderProps(id, userProps) {
+        var header = instance.getHeader(id);
+
+        if (!header) {
+          throw new Error();
+        }
+
+        var initialProps = {
+          key: header.id,
+          role: 'columnheader',
+          colSpan: header.colSpan,
+          rowSpan: header.rowSpan
+        };
+        return propGetter(initialProps, userProps);
+      },
+      getFooterProps: function getFooterProps(id, userProps) {
+        var header = instance.getHeader(id);
+
+        if (!header) {
+          return;
+        }
+
+        var initialProps = {
+          key: header.id,
+          role: 'columnfooter',
+          colSpan: header.colSpan,
+          rowSpan: header.rowSpan
+        };
+        return propGetter(initialProps, userProps);
+      },
+      getTotalWidth: function getTotalWidth() {
+        var width = 0;
+        instance.getVisibleLeafColumns().forEach(function (column) {
+          var _column$getWidth;
+
+          width += (_column$getWidth = column.getWidth()) != null ? _column$getWidth : 0;
+        });
+        return width;
+      }
+    };
+  }
+  function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
+    var _headerGroups$0$heade, _headerGroups$;
+
+    // Find the max depth of the columns:
+    // build the leaf column row
+    // build each buffer row going up
+    //    placeholder for non-existent level
+    //    real column for existing level
+    var maxDepth = 0;
+
+    var findMaxDepth = function findMaxDepth(columns, depth) {
+      if (depth === void 0) {
+        depth = 1;
+      }
+
+      maxDepth = Math.max(maxDepth, depth);
+      columns.filter(function (column) {
+        return column.getIsVisible();
+      }).forEach(function (column) {
+        var _column$columns;
+
+        if ((_column$columns = column.columns) != null && _column$columns.length) {
+          findMaxDepth(column.columns, depth + 1);
+        }
+      }, 0);
+    };
+
+    findMaxDepth(allColumns);
+    var headerGroups = [];
+
+    var createHeaderGroup = function createHeaderGroup(headersToGroup, depth) {
+      // The header group we are creating
+      var headerGroup = {
+        depth: depth,
+        id: [headerFamily, "" + depth].filter(Boolean).join('_'),
+        headers: [],
+        getHeaderGroupProps: function getHeaderGroupProps(getterValue) {
+          return instance.getHeaderGroupProps("" + depth, getterValue);
+        },
+        getFooterGroupProps: function getFooterGroupProps(getterValue) {
+          return instance.getFooterGroupProps("" + depth, getterValue);
+        }
+      }; // The parent columns we're going to scan next
+
+      var parentHeaders = []; // Scan each column for parents
+
+      headersToGroup.forEach(function (headerToGroup) {
+        // What is the latest (last) parent column?
+        var latestParentHeader = [].concat(parentHeaders).reverse()[0];
+        var isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
+        var column;
+        var isPlaceholder = false;
+
+        if (isLeafHeader && headerToGroup.column.parent) {
+          // The parent header is new
+          column = headerToGroup.column.parent;
+        } else {
+          // The parent header is repeated
+          column = headerToGroup.column;
+          isPlaceholder = true;
+        }
+
+        var header = instance.createHeader(column, {
+          id: [headerFamily, depth, column.id, headerToGroup == null ? void 0 : headerToGroup.id].filter(Boolean).join('_'),
+          isPlaceholder: isPlaceholder,
+          placeholderId: isPlaceholder ? "" + parentHeaders.filter(function (d) {
+            return d.column === column;
+          }).length : undefined,
+          depth: depth
+        });
+
+        if (!latestParentHeader || latestParentHeader.column !== header.column) {
+          header.subHeaders.push(headerToGroup);
+          parentHeaders.push(header);
+        } else {
+          latestParentHeader.subHeaders.push(headerToGroup);
+        } // if (!headerToGroup.isPlaceholder) {
+        //   headerToGroup.column.header = headerToGroup;
+        // }
+
+
+        headerGroup.headers.push(headerToGroup);
+      });
+      headerGroups.push(headerGroup);
+
+      if (depth > 0) {
+        createHeaderGroup(parentHeaders, depth - 1);
+      }
+    };
+
+    var bottomHeaders = columnsToGroup.map(function (column) {
+      return instance.createHeader(column, {
+        depth: maxDepth
+      });
+    });
+    createHeaderGroup(bottomHeaders, maxDepth - 1);
+    headerGroups.reverse(); // headerGroups = headerGroups.filter(headerGroup => {
+    //   return !headerGroup.headers.every(header => header.isPlaceholder)
+    // })
+
+    var recurseHeadersForSpans = function recurseHeadersForSpans(headers) {
+      var filteredHeaders = headers.filter(function (header) {
+        return header.column.getIsVisible();
+      });
+      return filteredHeaders.map(function (header) {
+        var colSpan = 0;
+        var rowSpan = 0;
+        var childRowSpans = [0];
+
+        if (header.subHeaders && header.subHeaders.length) {
+          childRowSpans = [];
+          recurseHeadersForSpans(header.subHeaders).forEach(function (_ref) {
+            var childColSpan = _ref.colSpan,
+                childRowSpan = _ref.rowSpan;
+            colSpan += childColSpan;
+            childRowSpans.push(childRowSpan);
           });
-          var clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
+        } else {
+          colSpan = 1;
+        }
 
-          var updateOffset = function updateOffset(eventType, clientXPos) {
-            if (typeof clientXPos !== 'number') {
-              return;
-            }
+        var minChildRowSpan = Math.min.apply(Math, childRowSpans);
+        rowSpan = rowSpan + minChildRowSpan;
+        header.colSpan = colSpan > 0 ? colSpan : undefined;
+        header.rowSpan = rowSpan > 0 ? rowSpan : undefined;
+        return {
+          colSpan: colSpan,
+          rowSpan: rowSpan
+        };
+      });
+    };
 
-            var newColumnSizing = {};
-            instance.setColumnSizingInfo(function (old) {
-              var _old$startOffset, _old$startSize;
+    recurseHeadersForSpans((_headerGroups$0$heade = (_headerGroups$ = headerGroups[0]) == null ? void 0 : _headerGroups$.headers) != null ? _headerGroups$0$heade : []);
+    return headerGroups;
+  }
 
-              var deltaOffset = clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0);
-              var deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999);
-              old.columnSizingStart.forEach(function (_ref4) {
-                var columnId = _ref4[0],
-                    headerWidth = _ref4[1];
-                newColumnSizing[columnId] = Math.max(headerWidth + headerWidth * deltaPercentage, 0);
-              });
-              return _extends({}, old, {
-                deltaOffset: deltaOffset,
-                deltaPercentage: deltaPercentage
-              });
-            });
+  var Headers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createRow: createRow$2,
+    getInstance: getInstance$6,
+    buildHeaderGroups: buildHeaderGroups
+  });
 
-            if (instance.options.columnResizeMode === 'onChange' || eventType === 'end') {
-              instance.setColumnSizing(function (old) {
-                return _extends({}, old, newColumnSizing);
-              });
-            }
-          };
+  var filterTypes = {
+    includesString: includesString,
+    includesStringSensitive: includesStringSensitive,
+    equalsString: equalsString,
+    equalsStringSensitive: equalsStringSensitive,
+    arrIncludes: arrIncludes,
+    arrIncludesAll: arrIncludesAll,
+    equals: equals,
+    weakEquals: weakEquals,
+    betweenNumberRange: betweenNumberRange
+  };
 
-          var onMove = function onMove(clientXPos) {
-            return updateOffset('move', clientXPos);
-          };
+  function includesString(rows, columnIds, filterValue) {
+    var search = String(filterValue).toLowerCase();
+    rows = rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        return String(row.values[id]).toLowerCase().includes(search);
+      });
+    });
+    return rows;
+  }
 
-          var onEnd = function onEnd(clientXPos) {
-            updateOffset('end', clientXPos);
-            instance.setColumnSizingInfo(function (old) {
-              return _extends({}, old, {
-                isResizingColumn: false,
-                startOffset: null,
-                startSize: null,
-                deltaOffset: null,
-                deltaPercentage: null,
-                columnSizingStart: []
-              });
-            });
-          };
+  includesString.autoRemove = function (val) {
+    return testFalsey(val);
+  };
 
-          var mouseEvents = {
-            moveHandler: function moveHandler(e) {
-              return onMove(e.clientX);
-            },
-            upHandler: function upHandler(e) {
-              document.removeEventListener('mousemove', mouseEvents.moveHandler);
-              document.removeEventListener('mouseup', mouseEvents.upHandler);
-              onEnd(e.clientX);
-            }
-          };
-          var touchEvents = {
-            moveHandler: function moveHandler(e) {
-              if (e.cancelable) {
-                e.preventDefault();
-                e.stopPropagation();
-              }
+  function includesStringSensitive(rows, columnIds, filterValue) {
+    var search = String(filterValue);
+    rows = rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        return String(row.values[id]).includes(search);
+      });
+    });
+    return rows;
+  }
+
+  includesStringSensitive.autoRemove = function (val) {
+    return testFalsey(val);
+  };
+
+  function equalsString(rows, columnIds, filterValue) {
+    var search = String(filterValue).toLowerCase();
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue !== undefined ? String(rowValue).toLowerCase() === search : true;
+      });
+    });
+  }
 
-              onMove(e.touches[0].clientX);
-              return false;
-            },
-            upHandler: function upHandler(e) {
-              document.removeEventListener('touchmove', touchEvents.moveHandler);
-              document.removeEventListener('touchend', touchEvents.upHandler);
+  equalsString.autoRemove = function (val) {
+    return testFalsey(val);
+  };
 
-              if (e.cancelable) {
-                e.preventDefault();
-                e.stopPropagation();
-              }
+  function equalsStringSensitive(rows, columnIds, filterValue) {
+    var search = String(filterValue);
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue !== undefined ? String(rowValue) === search : true;
+      });
+    });
+  }
 
-              onEnd(e.touches[0].clientX);
-            }
-          };
-          var passiveIfSupported = passiveEventSupported() ? {
-            passive: false
-          } : false;
+  equalsStringSensitive.autoRemove = function (val) {
+    return testFalsey(val);
+  };
 
-          if (isTouchStartEvent(e)) {
-            document.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported);
-            document.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported);
-          } else {
-            document.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported);
-            document.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported);
-          }
+  function arrIncludes(rows, columnIds, filterValue) {
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue.includes(filterValue);
+      });
+    });
+  }
 
-          instance.setColumnSizingInfo(function (old) {
-            return _extends({}, old, {
-              startOffset: clientX,
-              startSize: header.getWidth(),
-              deltaOffset: 0,
-              deltaPercentage: 0,
-              columnSizingStart: columnSizingStart,
-              isResizingColumn: header.column.id
-            });
-          });
-        };
+  arrIncludes.autoRemove = function (val) {
+    return testFalsey(val) || !(val != null && val.length);
+  };
 
-        var initialProps = canResize ? {
-          title: 'Toggle Grouping',
-          draggable: false,
-          role: 'separator',
-          onMouseDown: function onMouseDown(e) {
-            e.persist();
-            onResizeStart(e);
-          },
-          onTouchStart: function onTouchStart(e) {
-            e.persist();
-            onResizeStart(e);
-          }
-        } : {};
-        return propGetter(initialProps, userProps);
-      }
-    };
+  function arrIncludesAll(rows, columnIds, filterValue) {
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue && rowValue.length && filterValue.every(function (val) {
+          return rowValue.includes(val);
+        });
+      });
+    });
   }
-  function createColumn$2(column, instance) {
-    return {
-      getIsResizing: function getIsResizing() {
-        return instance.getColumnIsResizing(column.id);
-      },
-      getCanResize: function getCanResize() {
-        return instance.getColumnCanResize(column.id);
-      },
-      resetSize: function resetSize() {
-        return instance.resetColumnSize(column.id);
-      }
-    };
+
+  arrIncludesAll.autoRemove = function (val) {
+    return testFalsey(val) || !(val != null && val.length);
+  };
+
+  function equals(rows, columnIds, filterValue) {
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue === filterValue;
+      });
+    });
   }
-  function createHeader(header, instance) {
-    return {
-      getIsResizing: function getIsResizing() {
-        return instance.getHeaderIsResizing(header.id);
-      },
-      getCanResize: function getCanResize() {
-        return instance.getHeaderCanResize(header.id);
-      },
-      getResizerProps: function getResizerProps(userProps) {
-        return instance.getHeaderResizerProps(header.id, userProps);
-      },
-      resetSize: function resetSize() {
-        return instance.resetHeaderSize(header.id);
-      }
-    };
+
+  equals.autoRemove = function (val) {
+    return testFalsey(val);
+  };
+
+  function weakEquals(rows, columnIds, filterValue) {
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id]; // eslint-disable-next-line eqeqeq
+
+        return rowValue == filterValue;
+      });
+    });
   }
-  var passiveSupported = null;
-  function passiveEventSupported() {
-    if (typeof passiveSupported === 'boolean') return passiveSupported;
-    var supported = false;
 
-    try {
-      var options = {
-        get passive() {
-          supported = true;
-          return false;
-        }
+  weakEquals.autoRemove = function (val) {
+    return testFalsey(val);
+  };
 
-      };
+  function betweenNumberRange(rows, columnIds, filterValue) {
+    var _ref = filterValue || [],
+        unsafeMin = _ref[0],
+        unsafeMax = _ref[1];
 
-      var noop = function noop() {};
+    var parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
+    var parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
+    var min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
+    var max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
 
-      window.addEventListener('test', noop, options);
-      window.removeEventListener('test', noop);
-    } catch (err) {
-      supported = false;
+    if (min > max) {
+      var temp = min;
+      min = max;
+      max = temp;
     }
 
-    passiveSupported = supported;
-    return passiveSupported;
+    return rows.filter(function (row) {
+      return columnIds.some(function (id) {
+        var rowValue = row.values[id];
+        return rowValue >= min && rowValue <= max;
+      });
+    });
   }
 
-  function isTouchStartEvent(e) {
-    return e.type === 'touchstart';
+  betweenNumberRange.autoRemove = function (val) {
+    return testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
+  }; // Utils
+
+
+  function testFalsey(val) {
+    return val === undefined || val === null || val === '';
   }
 
   //
-  function createRow$1(row, instance) {
+  function getDefaultColumn$1() {
     return {
-      _getAllVisibleCells: memo(function () {
-        return [row.getAllCells().filter(function (cell) {
-          return cell.column.getIsVisible();
-        }).map(function (d) {
-          return d.id;
-        }).join('_')];
-      }, function (_) {
-        return row.getAllCells().filter(function (cell) {
-          return cell.column.getIsVisible();
-        });
-      }, 'row._getAllVisibleCells', instance.options.debug),
-      getVisibleCells: memo(function () {
-        return [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()];
-      }, function (left, center, right) {
-        return [].concat(left, center, right);
-      }, 'row.getVisibleCells', instance.options.debug),
-      getCenterVisibleCells: memo(function () {
-        return [row._getAllVisibleCells(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
-      }, function (allCells, left, right) {
-        var leftAndRight = [].concat(left != null ? left : [], right != null ? right : []);
-        return allCells.filter(function (d) {
-          return !leftAndRight.includes(d.columnId);
-        });
-      }, 'row.getCenterVisibleCells', instance.options.debug),
-      getLeftVisibleCells: memo(function () {
-        return [row._getAllVisibleCells(), instance.getState().columnPinning.left,,];
-      }, function (allCells, left) {
-        var cells = (left != null ? left : []).map(function (columnId) {
-          return allCells.find(function (cell) {
-            return cell.columnId === columnId;
-          });
-        }).filter(Boolean);
-        return cells;
-      }, 'row.getLeftVisibleCells', instance.options.debug),
-      getRightVisibleCells: memo(function () {
-        return [row._getAllVisibleCells(), instance.getState().columnPinning.right];
-      }, function (allCells, right) {
-        var cells = (right != null ? right : []).map(function (columnId) {
-          return allCells.find(function (cell) {
-            return cell.columnId === columnId;
-          });
-        }).filter(Boolean);
-        return cells;
-      }, 'row.getRightVisibleCells', instance.options.debug)
+      filterType: 'auto'
     };
   }
-  function getInstance$3(instance) {
+  function getInitialState$5() {
     return {
-      createHeader: function createHeader$1(column, options) {
-        var _options$id;
+      columnFilters: [],
+      globalFilter: undefined
+    };
+  }
+  function getDefaultOptions$5(instance) {
+    return {
+      onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
+      onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
+      autoResetColumnFilters: true,
+      filterFromChildrenUp: true,
+      autoResetGlobalFilter: true,
+      globalFilterType: 'auto',
+      getColumnCanGlobalFilterFn: function getColumnCanGlobalFilterFn(column) {
+        var _instance$getCoreFlat, _instance$getCoreFlat2;
+
+        var value = (_instance$getCoreFlat = instance.getCoreFlatRows()[0]) == null ? void 0 : (_instance$getCoreFlat2 = _instance$getCoreFlat.getAllCellsByColumnId()[column.id]) == null ? void 0 : _instance$getCoreFlat2.value;
+        return typeof value === 'string';
+      }
+    };
+  }
+  function createColumn$2(column, instance) {
+    var getFacetInfo = memo(function () {
+      return [column.getPreFilteredRows()];
+    }, function (rows) {
+      var _rows$0$values$column, _rows$, _rows$0$values$column2, _rows$2;
+
+      if (rows === void 0) {
+        rows = [];
+      }
 
-        var id = (_options$id = options.id) != null ? _options$id : column.id;
-        var header = {
-          id: id,
-          column: column,
-          isPlaceholder: options.isPlaceholder,
-          placeholderId: options.placeholderId,
-          depth: options.depth,
-          subHeaders: [],
-          colSpan: 0,
-          rowSpan: 0,
-          getWidth: function getWidth() {
-            var sum = 0;
+      var preFilteredUniqueValues = new Map();
+      var preFilteredMinMaxValues = [(_rows$0$values$column = (_rows$ = rows[0]) == null ? void 0 : _rows$.values[column.id]) != null ? _rows$0$values$column : null, (_rows$0$values$column2 = (_rows$2 = rows[0]) == null ? void 0 : _rows$2.values[column.id]) != null ? _rows$0$values$column2 : null];
 
-            var recurse = function recurse(header) {
-              if (header.subHeaders.length) {
-                header.subHeaders.forEach(recurse);
-              } else {
-                var _header$column$getWid;
+      for (var i = 0; i < rows.length; i++) {
+        var _rows$i;
 
-                sum += (_header$column$getWid = header.column.getWidth()) != null ? _header$column$getWid : 0;
-              }
-            };
+        var _value = (_rows$i = rows[i]) == null ? void 0 : _rows$i.values[column.id];
 
-            recurse(header);
-            return sum;
-          },
-          getLeafHeaders: function getLeafHeaders() {
-            var leafHeaders = [];
+        if (preFilteredUniqueValues.has(_value)) {
+          var _preFilteredUniqueVal;
 
-            var recurseHeader = function recurseHeader(h) {
-              if (h.subHeaders && h.subHeaders.length) {
-                h.subHeaders.map(recurseHeader);
-              }
+          preFilteredUniqueValues.set(_value, ((_preFilteredUniqueVal = preFilteredUniqueValues.get(_value)) != null ? _preFilteredUniqueVal : 0) + 1);
+        } else {
+          preFilteredUniqueValues.set(_value, 1);
+        }
 
-              leafHeaders.push(h);
-            };
+        if (_value < preFilteredMinMaxValues[0]) {
+          preFilteredMinMaxValues[0] = _value;
+        } else if (_value > preFilteredMinMaxValues[1]) {
+          preFilteredMinMaxValues[1] = _value;
+        }
+      }
 
-            recurseHeader(header);
-            return leafHeaders;
-          },
-          getHeaderProps: function getHeaderProps(userProps) {
-            return instance.getHeaderProps(header.id, userProps);
-          },
-          getFooterProps: function getFooterProps(userProps) {
-            return instance.getFooterProps(header.id, userProps);
-          },
-          renderHeader: function renderHeader() {
-            return flexRender(column.header, {
-              header: header,
-              column: column
-            });
-          },
-          renderFooter: function renderFooter() {
-            return flexRender(column.footer, {
-              header: header,
-              column: column
-            });
+      return {
+        preFilteredUniqueValues: preFilteredUniqueValues,
+        preFilteredMinMaxValues: preFilteredMinMaxValues
+      };
+    }, {
+      key: 'column.getFacetInfo',
+      debug: instance.options.debug
+    });
+    return {
+      filterType: column.filterType,
+      getCanColumnFilter: function getCanColumnFilter() {
+        return instance.getColumnCanColumnFilter(column.id);
+      },
+      getCanGlobalFilter: function getCanGlobalFilter() {
+        return instance.getColumnCanGlobalFilter(column.id);
+      },
+      getColumnFilterIndex: function getColumnFilterIndex() {
+        return instance.getColumnFilterIndex(column.id);
+      },
+      getIsColumnFiltered: function getIsColumnFiltered() {
+        return instance.getColumnIsFiltered(column.id);
+      },
+      getColumnFilterValue: function getColumnFilterValue() {
+        return instance.getColumnFilterValue(column.id);
+      },
+      setColumnFilterValue: function setColumnFilterValue(val) {
+        return instance.setColumnFilterValue(column.id, val);
+      },
+      getPreFilteredUniqueValues: function getPreFilteredUniqueValues() {
+        return getFacetInfo().preFilteredUniqueValues;
+      },
+      getPreFilteredMinMaxValues: function getPreFilteredMinMaxValues() {
+        return getFacetInfo().preFilteredMinMaxValues;
+      },
+      getPreFilteredRows: function getPreFilteredRows() {
+        return undefined;
+      }
+    };
+  }
+  function getInstance$5(instance) {
+    var registered = false;
+    return {
+      _notifyFiltersReset: function _notifyFiltersReset() {
+        if (!registered) {
+          registered = true;
+          return;
+        }
+
+        if (instance.options.autoResetAll === false) {
+          return;
+        }
+
+        if (instance.options.autoResetAll === true) {
+          instance.resetSorting();
+        } else {
+          if (instance.options.autoResetColumnFilters) {
+            instance.resetColumnFilters();
           }
-        };
-        header = Object.assign(header, createHeader(header, instance)); // Yes, we have to convert instance to uknown, because we know more than the compiler here.
 
-        return header;
+          if (instance.options.autoResetGlobalFilter) {
+            instance.resetGlobalFilter();
+          }
+        }
       },
-      // Header Groups
-      getHeaderGroups: memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, left, right) {
-        var leftColumns = leafColumns.filter(function (column) {
-          return left == null ? void 0 : left.includes(column.id);
-        });
-        var rightColumns = leafColumns.filter(function (column) {
-          return right == null ? void 0 : right.includes(column.id);
-        });
-        var centerColumns = leafColumns.filter(function (column) {
-          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
-        });
-        var headerGroups = buildHeaderGroups(allColumns, [].concat(leftColumns, centerColumns, rightColumns), instance);
-        return headerGroups;
-      }, 'getHeaderGroups', instance.options.debug),
-      getCenterHeaderGroups: memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, left, right) {
-        leafColumns = leafColumns.filter(function (column) {
-          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
-        });
-        return buildHeaderGroups(allColumns, leafColumns, instance, 'center');
-      }, 'getCenterHeaderGroups', instance.options.debug),
-      getLeftHeaderGroups: memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left];
-      }, function (allColumns, leafColumns, left) {
-        leafColumns = leafColumns.filter(function (column) {
-          return left == null ? void 0 : left.includes(column.id);
-        });
-        return buildHeaderGroups(allColumns, leafColumns, instance, 'left');
-      }, 'getLeftHeaderGroups', instance.options.debug),
-      getRightHeaderGroups: memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, right) {
-        leafColumns = leafColumns.filter(function (column) {
-          return right == null ? void 0 : right.includes(column.id);
-        });
-        return buildHeaderGroups(allColumns, leafColumns, instance, 'right');
-      }, 'getRightHeaderGroups', instance.options.debug),
-      // Footer Groups
-      getFooterGroups: memo(function () {
-        return [instance.getHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
-      }, 'getFooterGroups', instance.options.debug),
-      getLeftFooterGroups: memo(function () {
-        return [instance.getLeftHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
-      }, 'getLeftFooterGroups', instance.options.debug),
-      getCenterFooterGroups: memo(function () {
-        return [instance.getCenterHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
-      }, 'getCenterFooterGroups', instance.options.debug),
-      getRightFooterGroups: memo(function () {
-        return [instance.getRightHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
-      }, 'getRightFooterGroups', instance.options.debug),
-      // Flat Headers
-      getFlatHeaders: memo(function () {
-        return [instance.getHeaderGroups()];
-      }, function (headerGroups) {
-        return headerGroups.map(function (headerGroup) {
-          return headerGroup.headers;
-        }).flat();
-      }, 'getFlatHeaders', instance.options.debug),
-      getLeftFlatHeaders: memo(function () {
-        return [instance.getLeftHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
-          return headerGroup.headers;
-        }).flat();
-      }, 'getLeftFlatHeaders', instance.options.debug),
-      getCenterFlatHeaders: memo(function () {
-        return [instance.getCenterHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
-          return headerGroup.headers;
-        }).flat();
-      }, 'getCenterFlatHeaders', instance.options.debug),
-      getRightFlatHeaders: memo(function () {
-        return [instance.getRightHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
-          return headerGroup.headers;
-        }).flat();
-      }, 'getRightFlatHeaders', instance.options.debug),
-      // Leaf Headers
-      getCenterLeafHeaders: memo(function () {
-        return [instance.getCenterFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
-          var _header$subHeaders;
+      getColumnAutoFilterFn: function getColumnAutoFilterFn(columnId) {
+        var firstRow = instance.getCoreFlatRows()[0];
+        var value = firstRow == null ? void 0 : firstRow.values[columnId];
 
-          return !((_header$subHeaders = header.subHeaders) != null && _header$subHeaders.length);
-        });
-      }, 'getCenterLeafHeaders', instance.options.debug),
-      getLeftLeafHeaders: memo(function () {
-        return [instance.getLeftFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
-          var _header$subHeaders2;
+        if (typeof value === 'string') {
+          return filterTypes.includesString;
+        }
 
-          return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length);
-        });
-      }, 'getLeftLeafHeaders', instance.options.debug),
-      getRightLeafHeaders: memo(function () {
-        return [instance.getRightFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
-          var _header$subHeaders3;
+        if (typeof value === 'number') {
+          return filterTypes.betweenNumberRange;
+        }
 
-          return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length);
-        });
-      }, 'getRightLeafHeaders', instance.options.debug),
-      getLeafHeaders: memo(function () {
-        return [instance.getLeftHeaderGroups(), instance.getCenterHeaderGroups(), instance.getRightHeaderGroups()];
-      }, function (left, center, right) {
-        var _left$0$headers, _left$, _center$0$headers, _center$, _right$0$headers, _right$;
+        if (value !== null && typeof value === 'object') {
+          return filterTypes.equals;
+        }
 
-        return [].concat((_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : [], (_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : [], (_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : []).map(function (header) {
-          return header.getLeafHeaders();
-        }).flat();
-      }, 'getLeafHeaders', instance.options.debug),
-      getHeader: function getHeader(id) {
-        var header = [].concat(instance.getFlatHeaders(), instance.getCenterFlatHeaders(), instance.getLeftFlatHeaders(), instance.getRightFlatHeaders()).find(function (d) {
-          return d.id === id;
-        });
+        if (Array.isArray(value)) {
+          return filterTypes.arrIncludes;
+        }
 
-        if (!header) {
-          {
-            console.warn("Could not find header with id: " + id);
-          }
+        return filterTypes.weakEquals;
+      },
+      getGlobalAutoFilterFn: function getGlobalAutoFilterFn() {
+        return filterTypes.includesString;
+      },
+      getColumnFilterFn: function getColumnFilterFn(columnId) {
+        var _ref;
+
+        var column = instance.getColumn(columnId);
+        var userFilterTypes = instance.options.filterTypes;
 
+        if (!column) {
           throw new Error();
         }
 
-        return header;
+        return isFunction(column.filterType) ? column.filterType : column.filterType === 'auto' ? instance.getColumnAutoFilterFn(columnId) : (_ref = userFilterTypes == null ? void 0 : userFilterTypes[column.filterType]) != null ? _ref : filterTypes[column.filterType];
       },
-      getHeaderGroupProps: function getHeaderGroupProps(id, userProps) {
-        var headerGroup = instance.getHeaderGroups().find(function (d) {
-          return d.id === id;
-        });
-
-        if (!headerGroup) {
-          return;
-        }
+      getGlobalFilterFn: function getGlobalFilterFn() {
+        var _ref2;
 
-        return propGetter({
-          key: headerGroup.id,
-          role: 'row'
-        }, userProps);
+        var _instance$options = instance.options,
+            userFilterTypes = _instance$options.filterTypes,
+            globalFilterType = _instance$options.globalFilterType;
+        return isFunction(globalFilterType) ? globalFilterType : globalFilterType === 'auto' ? instance.getGlobalAutoFilterFn() : (_ref2 = userFilterTypes == null ? void 0 : userFilterTypes[globalFilterType]) != null ? _ref2 : filterTypes[globalFilterType];
       },
-      getFooterGroupProps: function getFooterGroupProps(id, userProps) {
-        var headerGroup = instance.getFooterGroups().find(function (d) {
-          return d.id === id;
-        });
+      setColumnFilters: function setColumnFilters(updater) {
+        var leafColumns = instance.getAllLeafColumns();
 
-        if (!headerGroup) {
-          return;
-        }
+        var updateFn = function updateFn(old) {
+          var _functionalUpdate;
 
-        var initialProps = {
-          key: headerGroup.id,
-          role: 'row'
+          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(function (filter) {
+            var column = leafColumns.find(function (d) {
+              return d.id === filter.id;
+            });
+
+            if (column) {
+              var filterFn = instance.getColumnFilterFn(column.id);
+
+              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
+                return false;
+              }
+            }
+
+            return true;
+          });
         };
-        return propGetter(initialProps, userProps);
+
+        instance.options.onColumnFiltersChange == null ? void 0 : instance.options.onColumnFiltersChange(updateFn, updateFn(instance.getState().columnFilters));
       },
-      getHeaderProps: function getHeaderProps(id, userProps) {
-        var header = instance.getHeader(id);
+      setGlobalFilter: function setGlobalFilter(updater) {
+        instance.options.onGlobalFilterChange == null ? void 0 : instance.options.onGlobalFilterChange(updater, functionalUpdate(updater, instance.getState().globalFilter));
+      },
+      resetGlobalFilter: function resetGlobalFilter() {
+        instance.setGlobalFilter(undefined);
+      },
+      getColumnCanColumnFilter: function getColumnCanColumnFilter(columnId) {
+        var _ref3, _ref4, _ref5, _ref6, _ref7, _column$enableAllFilt;
 
-        if (!header) {
+        var column = instance.getColumn(columnId);
+
+        if (!column) {
           throw new Error();
         }
 
-        var initialProps = {
-          key: header.id,
-          role: 'columnheader',
-          colSpan: header.colSpan,
-          rowSpan: header.rowSpan
-        };
-        return propGetter(initialProps, userProps);
+        return (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_ref7 = (_column$enableAllFilt = column.enableAllFilters) != null ? _column$enableAllFilt : column.enableColumnFilter) != null ? _ref7 : instance.options.enableFilters) != null ? _ref6 : instance.options.enableColumnFilters) != null ? _ref5 : column.defaultCanFilter) != null ? _ref4 : column.defaultCanColumnFilter) != null ? _ref3 : !!column.accessorFn;
       },
-      getFooterProps: function getFooterProps(id, userProps) {
-        var header = instance.getHeader(id);
+      getColumnCanGlobalFilter: function getColumnCanGlobalFilter(columnId) {
+        var _ref8, _ref9, _ref10, _ref11, _ref12, _ref13, _instance$options$ena;
 
-        if (!header) {
-          return;
+        var column = instance.getColumn(columnId);
+
+        if (!column) {
+          throw new Error();
         }
 
-        var initialProps = {
-          key: header.id,
-          role: 'columnfooter',
-          colSpan: header.colSpan,
-          rowSpan: header.rowSpan
-        };
-        return propGetter(initialProps, userProps);
+        return (_ref8 = ((_ref9 = (_ref10 = (_ref11 = (_ref12 = (_ref13 = (_instance$options$ena = instance.options.enableFilters) != null ? _instance$options$ena : instance.options.enableGlobalFilter) != null ? _ref13 : column.enableAllFilters) != null ? _ref12 : column.enableGlobalFilter) != null ? _ref11 : column.defaultCanFilter) != null ? _ref10 : column.defaultCanGlobalFilter) != null ? _ref9 : !!column.accessorFn) && (instance.options.getColumnCanGlobalFilterFn == null ? void 0 : instance.options.getColumnCanGlobalFilterFn(column))) != null ? _ref8 : true;
       },
-      getTotalWidth: function getTotalWidth() {
-        var width = 0;
-        instance.getVisibleLeafColumns().forEach(function (column) {
-          var _column$getWidth;
+      getColumnIsFiltered: function getColumnIsFiltered(columnId) {
+        return instance.getColumnFilterIndex(columnId) > -1;
+      },
+      getColumnFilterValue: function getColumnFilterValue(columnId) {
+        var _instance$getState$co, _instance$getState$co2;
 
-          width += (_column$getWidth = column.getWidth()) != null ? _column$getWidth : 0;
-        });
-        return width;
-      }
-    };
-  }
-  function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
-    var _headerGroups$0$heade, _headerGroups$;
+        return (_instance$getState$co = instance.getState().columnFilters) == null ? void 0 : (_instance$getState$co2 = _instance$getState$co.find(function (d) {
+          return d.id === columnId;
+        })) == null ? void 0 : _instance$getState$co2.value;
+      },
+      getColumnFilterIndex: function getColumnFilterIndex(columnId) {
+        var _instance$getState$co3, _instance$getState$co4;
 
-    // Find the max depth of the columns:
-    // build the leaf column row
-    // build each buffer row going up
-    //    placeholder for non-existent level
-    //    real column for existing level
-    var maxDepth = 0;
+        return (_instance$getState$co3 = (_instance$getState$co4 = instance.getState().columnFilters) == null ? void 0 : _instance$getState$co4.findIndex(function (d) {
+          return d.id === columnId;
+        })) != null ? _instance$getState$co3 : -1;
+      },
+      setColumnFilterValue: function setColumnFilterValue(columnId, value) {
+        if (!columnId) return;
+        instance.setColumnFilters(function (old) {
+          var column = instance.getColumn(columnId);
 
-    var findMaxDepth = function findMaxDepth(columns, depth) {
-      if (depth === void 0) {
-        depth = 1;
-      }
+          if (!column) {
+            {
+              console.warn("React-Table: Could not find a column with id: " + columnId);
+            }
 
-      maxDepth = Math.max(maxDepth, depth);
-      columns.filter(function (column) {
-        return column.getIsVisible();
-      }).forEach(function (column) {
-        var _column$columns;
+            throw new Error();
+          }
 
-        if ((_column$columns = column.columns) != null && _column$columns.length) {
-          findMaxDepth(column.columns, depth + 1);
-        }
-      }, 0);
-    };
+          var filterFn = instance.getColumnFilterFn(column.id);
+          var previousfilter = old == null ? void 0 : old.find(function (d) {
+            return d.id === columnId;
+          });
+          var newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined); //
 
-    findMaxDepth(allColumns);
-    var headerGroups = [];
+          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
+            var _old$filter;
 
-    var createHeaderGroup = function createHeaderGroup(headersToGroup, depth) {
-      // The header group we are creating
-      var headerGroup = {
-        depth: depth,
-        id: [headerFamily, "" + depth].filter(Boolean).join('_'),
-        headers: [],
-        getHeaderGroupProps: function getHeaderGroupProps(getterValue) {
-          return instance.getHeaderGroupProps("" + depth, getterValue);
-        },
-        getFooterGroupProps: function getFooterGroupProps(getterValue) {
-          return instance.getFooterGroupProps("" + depth, getterValue);
-        }
-      }; // The parent columns we're going to scan next
+            return (_old$filter = old == null ? void 0 : old.filter(function (d) {
+              return d.id !== columnId;
+            })) != null ? _old$filter : [];
+          }
 
-      var parentHeaders = []; // Scan each column for parents
+          var newFilterObj = {
+            id: columnId,
+            value: newFilter
+          };
 
-      headersToGroup.forEach(function (headerToGroup) {
-        // What is the latest (last) parent column?
-        var latestParentHeader = [].concat(parentHeaders).reverse()[0];
-        var isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
-        var column;
-        var isPlaceholder = false;
+          if (previousfilter) {
+            var _old$map;
 
-        if (isLeafHeader && headerToGroup.column.parent) {
-          // The parent header is new
-          column = headerToGroup.column.parent;
-        } else {
-          // The parent header is repeated
-          column = headerToGroup.column;
-          isPlaceholder = true;
-        }
+            return (_old$map = old == null ? void 0 : old.map(function (d) {
+              if (d.id === columnId) {
+                return newFilterObj;
+              }
 
-        var header = instance.createHeader(column, {
-          id: [headerFamily, depth, column.id, headerToGroup == null ? void 0 : headerToGroup.id].filter(Boolean).join('_'),
-          isPlaceholder: isPlaceholder,
-          placeholderId: isPlaceholder ? "" + parentHeaders.filter(function (d) {
-            return d.column === column;
-          }).length : undefined,
-          depth: depth
+              return d;
+            })) != null ? _old$map : [];
+          }
+
+          if (old != null && old.length) {
+            return [].concat(old, [newFilterObj]);
+          }
+
+          return [newFilterObj];
         });
+      },
+      resetColumnFilters: function resetColumnFilters() {
+        var _instance$options$ini, _instance$options2, _instance$options2$in;
 
-        if (!latestParentHeader || latestParentHeader.column !== header.column) {
-          header.subHeaders.push(headerToGroup);
-          parentHeaders.push(header);
-        } else {
-          latestParentHeader.subHeaders.push(headerToGroup);
-        } // if (!headerToGroup.isPlaceholder) {
-        //   headerToGroup.column.header = headerToGroup;
-        // }
+        instance.setColumnFilters((_instance$options$ini = (_instance$options2 = instance.options) == null ? void 0 : (_instance$options2$in = _instance$options2.initialState) == null ? void 0 : _instance$options2$in.columnFilters) != null ? _instance$options$ini : []);
+      },
+      getColumnFilteredRowModel: memo(function () {
+        return [instance.getState().columnFilters, instance.getCoreRowModel(), instance.options.columnFilterRowsFn];
+      }, function (columnFilters, rowModel, columnFiltersFn) {
+        var columnFilteredRowModel = function () {
+          if (!(columnFilters != null && columnFilters.length) || !columnFiltersFn) {
+            return rowModel;
+          }
+
+          if (instance.options.debug) console.info('Column Filtering...');
+          return columnFiltersFn(instance, rowModel);
+        }(); // Now that each filtered column has it's partially filtered rows,
+        // lets assign the final filtered rows to all of the other columns
+
+
+        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
+          var _instance$getState$co5;
+
+          return !((_instance$getState$co5 = instance.getState().columnFilters) != null && _instance$getState$co5.find(function (d) {
+            return d.id === column.id;
+          }));
+        }); // This essentially enables faceted filter options to be built easily
+        // using every column's preFilteredRows value
 
+        nonFilteredColumns.forEach(function (column) {
+          column.getPreFilteredRows = function () {
+            return columnFilteredRowModel.rows;
+          };
+        });
+        return columnFilteredRowModel;
+      }, {
+        key: 'getColumnFilteredRowModel',
+        debug: instance.options.debug
+      }),
+      // These might be easier to remember than "column" filtered rows
+      getPreFilteredRowModel: function getPreFilteredRowModel() {
+        return instance.getCoreRowModel();
+      },
+      getPreFilteredRows: function getPreFilteredRows() {
+        return instance.getCoreRowModel().rows;
+      },
+      getPreFilteredFlatRows: function getPreFilteredFlatRows() {
+        return instance.getCoreRowModel().flatRows;
+      },
+      getPreFilteredRowsById: function getPreFilteredRowsById() {
+        return instance.getCoreRowModel().rowsById;
+      },
+      // Pre Column Filter
+      getPreColumnFilteredRows: function getPreColumnFilteredRows() {
+        return instance.getCoreRowModel().rows;
+      },
+      getPreColumnFilteredFlatRows: function getPreColumnFilteredFlatRows() {
+        return instance.getCoreRowModel().flatRows;
+      },
+      getPreColumnFilteredRowsById: function getPreColumnFilteredRowsById() {
+        return instance.getCoreRowModel().rowsById;
+      },
+      getColumnFilteredRows: function getColumnFilteredRows() {
+        return instance.getColumnFilteredRowModel().rows;
+      },
+      getColumnFilteredFlatRows: function getColumnFilteredFlatRows() {
+        return instance.getColumnFilteredRowModel().flatRows;
+      },
+      getColumnFilteredRowsById: function getColumnFilteredRowsById() {
+        return instance.getColumnFilteredRowModel().rowsById;
+      },
+      getGlobalFilteredRowModel: memo(function () {
+        return [instance.getState().globalFilter, instance.getColumnFilteredRowModel(), instance.options.globalFilterRowsFn];
+      }, function (globalFilterValue, columnFilteredRowModel, globalFiltersFn) {
+        var globalFilteredRowModel = function () {
+          if (!globalFiltersFn || !globalFilterValue) {
+            return columnFilteredRowModel;
+          }
 
-        headerGroup.headers.push(headerToGroup);
-      });
-      headerGroups.push(headerGroup);
+          if (instance.options.debug) console.info('Global Filtering...');
+          return globalFiltersFn(instance, columnFilteredRowModel);
+        }(); // Now that each filtered column has it's partially filtered rows,
+        // lets assign the final filtered rows to all of the other columns
 
-      if (depth > 0) {
-        createHeaderGroup(parentHeaders, depth - 1);
-      }
-    };
 
-    var bottomHeaders = columnsToGroup.map(function (column) {
-      return instance.createHeader(column, {
-        depth: maxDepth
-      });
-    });
-    createHeaderGroup(bottomHeaders, maxDepth - 1);
-    headerGroups.reverse(); // headerGroups = headerGroups.filter(headerGroup => {
-    //   return !headerGroup.headers.every(header => header.isPlaceholder)
-    // })
+        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
+          var _instance$getState$co6;
 
-    var recurseHeadersForSpans = function recurseHeadersForSpans(headers) {
-      var filteredHeaders = headers.filter(function (header) {
-        return header.column.getIsVisible();
-      });
-      return filteredHeaders.map(function (header) {
-        var colSpan = 0;
-        var rowSpan = 0;
-        var childRowSpans = [0];
+          return !((_instance$getState$co6 = instance.getState().columnFilters) != null && _instance$getState$co6.find(function (d) {
+            return d.id === column.id;
+          }));
+        }); // This essentially enables faceted filter options to be built easily
+        // using every column's preFilteredRows value
 
-        if (header.subHeaders && header.subHeaders.length) {
-          childRowSpans = [];
-          recurseHeadersForSpans(header.subHeaders).forEach(function (_ref) {
-            var childColSpan = _ref.colSpan,
-                childRowSpan = _ref.rowSpan;
-            colSpan += childColSpan;
-            childRowSpans.push(childRowSpan);
-          });
-        } else {
-          colSpan = 1;
+        nonFilteredColumns.forEach(function (column) {
+          column.getPreFilteredRows = function () {
+            return globalFilteredRowModel.rows;
+          };
+        });
+        return globalFilteredRowModel;
+      }, {
+        key: 'getGlobalFilteredRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifySortingReset();
         }
-
-        var minChildRowSpan = Math.min.apply(Math, childRowSpans);
-        rowSpan = rowSpan + minChildRowSpan;
-        header.colSpan = colSpan > 0 ? colSpan : undefined;
-        header.rowSpan = rowSpan > 0 ? rowSpan : undefined;
-        return {
-          colSpan: colSpan,
-          rowSpan: rowSpan
-        };
-      });
+      }),
+      getPreGlobalFilteredRows: function getPreGlobalFilteredRows() {
+        return instance.getColumnFilteredRowModel().rows;
+      },
+      getPreGlobalFilteredFlatRows: function getPreGlobalFilteredFlatRows() {
+        return instance.getColumnFilteredRowModel().flatRows;
+      },
+      getPreGlobalFilteredRowsById: function getPreGlobalFilteredRowsById() {
+        return instance.getColumnFilteredRowModel().rowsById;
+      },
+      getGlobalFilteredRows: function getGlobalFilteredRows() {
+        return instance.getGlobalFilteredRowModel().rows;
+      },
+      getGlobalFilteredFlatRows: function getGlobalFilteredFlatRows() {
+        return instance.getGlobalFilteredRowModel().flatRows;
+      },
+      getGlobalFilteredRowsById: function getGlobalFilteredRowsById() {
+        return instance.getGlobalFilteredRowModel().rowsById;
+      }
     };
-
-    recurseHeadersForSpans((_headerGroups$0$heade = (_headerGroups$ = headerGroups[0]) == null ? void 0 : _headerGroups$.headers) != null ? _headerGroups$0$heade : []);
-    return headerGroups;
+  }
+  function shouldAutoRemoveFilter(filterFn, value, column) {
+    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
   }
 
-  var filterTypes = {
-    includesString: includesString,
-    includesStringSensitive: includesStringSensitive,
-    equalsString: equalsString,
-    equalsStringSensitive: equalsStringSensitive,
-    arrIncludes: arrIncludes,
-    arrIncludesAll: arrIncludesAll,
-    equals: equals,
-    weakEquals: weakEquals,
-    betweenNumberRange: betweenNumberRange
+  var Filters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getDefaultColumn: getDefaultColumn$1,
+    getInitialState: getInitialState$5,
+    getDefaultOptions: getDefaultOptions$5,
+    createColumn: createColumn$2,
+    getInstance: getInstance$5,
+    shouldAutoRemoveFilter: shouldAutoRemoveFilter
+  });
+
+  var reSplitAlphaNumeric = /([0-9]+)/gm;
+  var sortTypes = {
+    alphanumeric: alphanumeric,
+    alphanumericCaseSensitive: alphanumericCaseSensitive,
+    text: text,
+    textCaseSensitive: textCaseSensitive,
+    datetime: datetime,
+    basic: basic
   };
 
-  function includesString(rows, columnIds, filterValue) {
-    var search = String(filterValue).toLowerCase();
-    rows = rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        return String(row.values[id]).toLowerCase().includes(search);
-      });
-    });
-    return rows;
+  function alphanumeric(rowA, rowB, columnId) {
+    return compareAlphanumeric(toString(rowA.values[columnId]).toLowerCase(), toString(rowB.values[columnId]).toLowerCase());
   }
 
-  includesString.autoRemove = function (val) {
-    return testFalsey(val);
-  };
+  function alphanumericCaseSensitive(rowA, rowB, columnId) {
+    return compareAlphanumeric(toString(rowA.values[columnId]), toString(rowB.values[columnId]));
+  } // Mixed sorting is slow, but very inclusive of many edge cases.
+  // It handles numbers, mixed alphanumeric combinations, and even
+  // null, undefined, and Infinity
 
-  function includesStringSensitive(rows, columnIds, filterValue) {
-    var search = String(filterValue);
-    rows = rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        return String(row.values[id]).includes(search);
-      });
-    });
-    return rows;
-  }
 
-  includesStringSensitive.autoRemove = function (val) {
-    return testFalsey(val);
-  };
+  function compareAlphanumeric(aStr, bStr) {
+    // Split on number groups, but keep the delimiter
+    // Then remove falsey split values
+    var a = aStr.split(reSplitAlphaNumeric).filter(Boolean);
+    var b = bStr.split(reSplitAlphaNumeric).filter(Boolean); // While
 
-  function equalsString(rows, columnIds, filterValue) {
-    var search = String(filterValue).toLowerCase();
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue !== undefined ? String(rowValue).toLowerCase() === search : true;
-      });
-    });
-  }
+    while (a.length && b.length) {
+      var aa = a.shift();
+      var bb = b.shift();
+      var an = parseInt(aa, 10);
+      var bn = parseInt(bb, 10);
+      var combo = [an, bn].sort(); // Both are string
 
-  equalsString.autoRemove = function (val) {
-    return testFalsey(val);
-  };
+      if (isNaN(combo[0])) {
+        if (aa > bb) {
+          return 1;
+        }
 
-  function equalsStringSensitive(rows, columnIds, filterValue) {
-    var search = String(filterValue);
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue !== undefined ? String(rowValue) === search : true;
-      });
-    });
-  }
+        if (bb > aa) {
+          return -1;
+        }
 
-  equalsStringSensitive.autoRemove = function (val) {
-    return testFalsey(val);
-  };
+        continue;
+      } // One is a string, one is a number
 
-  function arrIncludes(rows, columnIds, filterValue) {
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue.includes(filterValue);
-      });
-    });
-  }
 
-  arrIncludes.autoRemove = function (val) {
-    return testFalsey(val) || !(val != null && val.length);
-  };
+      if (isNaN(combo[1])) {
+        return isNaN(an) ? -1 : 1;
+      } // Both are numbers
 
-  function arrIncludesAll(rows, columnIds, filterValue) {
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue && rowValue.length && filterValue.every(function (val) {
-          return rowValue.includes(val);
-        });
-      });
-    });
-  }
 
-  arrIncludesAll.autoRemove = function (val) {
-    return testFalsey(val) || !(val != null && val.length);
-  };
+      if (an > bn) {
+        return 1;
+      }
 
-  function equals(rows, columnIds, filterValue) {
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue === filterValue;
-      });
-    });
-  }
+      if (bn > an) {
+        return -1;
+      }
+    }
 
-  equals.autoRemove = function (val) {
-    return testFalsey(val);
-  };
+    return a.length - b.length;
+  } // The text filter is more basic (less numeric support)
+  // but is much faster
 
-  function weakEquals(rows, columnIds, filterValue) {
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id]; // eslint-disable-next-line eqeqeq
 
-        return rowValue == filterValue;
-      });
-    });
-  }
+  function text(rowA, rowB, columnId) {
+    return compareBasic(toString(rowA.values[columnId]).toLowerCase(), toString(rowB.values[columnId]).toLowerCase());
+  } // The text filter is more basic (less numeric support)
+  // but is much faster
 
-  weakEquals.autoRemove = function (val) {
-    return testFalsey(val);
-  };
 
-  function betweenNumberRange(rows, columnIds, filterValue) {
-    var _ref = filterValue || [],
-        unsafeMin = _ref[0],
-        unsafeMax = _ref[1];
+  function textCaseSensitive(rowA, rowB, columnId) {
+    return compareBasic(toString(rowA.values[columnId]), toString(rowB.values[columnId]));
+  }
 
-    var parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
-    var parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
-    var min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
-    var max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
+  function datetime(rowA, rowB, columnId) {
+    return compareBasic(rowA.values[columnId].getTime(), rowB.values[columnId].getTime());
+  }
 
-    if (min > max) {
-      var temp = min;
-      min = max;
-      max = temp;
-    }
+  function basic(rowA, rowB, columnId) {
+    return compareBasic(rowA.values[columnId], rowB.values[columnId]);
+  } // Utils
 
-    return rows.filter(function (row) {
-      return columnIds.some(function (id) {
-        var rowValue = row.values[id];
-        return rowValue >= min && rowValue <= max;
-      });
-    });
+
+  function compareBasic(a, b) {
+    return a === b ? 0 : a > b ? 1 : -1;
   }
 
-  betweenNumberRange.autoRemove = function (val) {
-    return testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
-  }; // Utils
+  function toString(a) {
+    if (typeof a === 'number') {
+      if (isNaN(a) || a === Infinity || a === -Infinity) {
+        return '';
+      }
+
+      return String(a);
+    }
 
+    if (typeof a === 'string') {
+      return a;
+    }
 
-  function testFalsey(val) {
-    return val === undefined || val === null || val === '';
+    return '';
   }
 
   //
-  function getDefaultColumn$1() {
+  function getDefaultColumn() {
     return {
-      filterType: 'auto'
+      sortType: 'auto'
     };
   }
-  function getInitialState$2() {
+  function getInitialState$4() {
     return {
-      columnFilters: [],
-      globalFilter: undefined
+      sorting: []
     };
   }
-  function getDefaultOptions$2(instance) {
+  function getDefaultOptions$4(instance) {
     return {
-      onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
-      onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
-      autoResetColumnFilters: true,
-      filterFromChildrenUp: true,
-      autoResetGlobalFilter: true,
-      globalFilterType: 'auto',
-      getColumnCanGlobalFilterFn: function getColumnCanGlobalFilterFn(column) {
-        var _instance$getCoreFlat, _instance$getCoreFlat2;
-
-        var value = (_instance$getCoreFlat = instance.getCoreFlatRows()[0]) == null ? void 0 : (_instance$getCoreFlat2 = _instance$getCoreFlat.getAllCellsByColumnId()[column.id]) == null ? void 0 : _instance$getCoreFlat2.value;
-        return typeof value === 'string';
+      onSortingChange: makeStateUpdater('sorting', instance),
+      autoResetSorting: true,
+      isMultiSortEvent: function isMultiSortEvent(e) {
+        return e.shiftKey;
       }
     };
   }
   function createColumn$1(column, instance) {
-    var getFacetInfo = memo(function () {
-      return [column.getPreFilteredRows()];
-    }, function (rows) {
-      var _rows$0$values$column, _rows$, _rows$0$values$column2, _rows$2;
-
-      if (rows === void 0) {
-        rows = [];
+    return {
+      sortType: column.sortType,
+      getCanSort: function getCanSort() {
+        return instance.getColumnCanSort(column.id);
+      },
+      getCanMultiSort: function getCanMultiSort() {
+        return instance.getColumnCanMultiSort(column.id);
+      },
+      getSortIndex: function getSortIndex() {
+        return instance.getColumnSortIndex(column.id);
+      },
+      getIsSorted: function getIsSorted() {
+        return instance.getColumnIsSorted(column.id);
+      },
+      toggleSorting: function toggleSorting(desc, isMulti) {
+        return instance.toggleColumnSorting(column.id, desc, isMulti);
+      },
+      getToggleSortingProps: function getToggleSortingProps(userProps) {
+        return instance.getToggleSortingProps(column.id, userProps);
       }
+    };
+  }
+  function getInstance$4(instance) {
+    var registered = false;
+    return {
+      _notifySortingReset: function _notifySortingReset() {
+        if (!registered) {
+          registered = true;
+          return;
+        }
 
-      var preFilteredUniqueValues = new Map();
-      var preFilteredMinMaxValues = [(_rows$0$values$column = (_rows$ = rows[0]) == null ? void 0 : _rows$.values[column.id]) != null ? _rows$0$values$column : null, (_rows$0$values$column2 = (_rows$2 = rows[0]) == null ? void 0 : _rows$2.values[column.id]) != null ? _rows$0$values$column2 : null];
+        if (instance.options.autoResetAll === false) {
+          return;
+        }
 
-      for (var i = 0; i < rows.length; i++) {
-        var _rows$i;
+        if (instance.options.autoResetAll === true || instance.options.autoResetSorting) {
+          instance.resetSorting();
+        }
+      },
+      getColumnAutoSortingFn: function getColumnAutoSortingFn(columnId) {
+        var firstRows = instance.getGlobalFilteredRowModel().flatRows.slice(100);
+        var isString = false;
 
-        var _value = (_rows$i = rows[i]) == null ? void 0 : _rows$i.values[column.id];
+        for (var _iterator = _createForOfIteratorHelperLoose(firstRows), _step; !(_step = _iterator()).done;) {
+          var row = _step.value;
+          var value = row == null ? void 0 : row.values[columnId];
 
-        if (preFilteredUniqueValues.has(_value)) {
-          var _preFilteredUniqueVal;
+          if (Object.prototype.toString.call(value) === '[object Date]') {
+            return sortTypes.datetime;
+          }
 
-          preFilteredUniqueValues.set(_value, ((_preFilteredUniqueVal = preFilteredUniqueValues.get(_value)) != null ? _preFilteredUniqueVal : 0) + 1);
-        } else {
-          preFilteredUniqueValues.set(_value, 1);
+          if (typeof value === 'string') {
+            isString = true;
+
+            if (value.split(reSplitAlphaNumeric).length > 1) {
+              return sortTypes.alphanumeric;
+            }
+          }
         }
 
-        if (_value < preFilteredMinMaxValues[0]) {
-          preFilteredMinMaxValues[0] = _value;
-        } else if (_value > preFilteredMinMaxValues[1]) {
-          preFilteredMinMaxValues[1] = _value;
+        if (isString) {
+          return sortTypes.text;
         }
-      }
 
-      return {
-        preFilteredUniqueValues: preFilteredUniqueValues,
-        preFilteredMinMaxValues: preFilteredMinMaxValues
-      };
-    }, 'column.getFacetInfo', instance.options.debug);
-    return {
-      filterType: column.filterType,
-      getCanColumnFilter: function getCanColumnFilter() {
-        return instance.getColumnCanColumnFilter(column.id);
-      },
-      getCanGlobalFilter: function getCanGlobalFilter() {
-        return instance.getColumnCanGlobalFilter(column.id);
-      },
-      getColumnFilterIndex: function getColumnFilterIndex() {
-        return instance.getColumnFilterIndex(column.id);
-      },
-      getIsColumnFiltered: function getIsColumnFiltered() {
-        return instance.getColumnIsFiltered(column.id);
-      },
-      getColumnFilterValue: function getColumnFilterValue() {
-        return instance.getColumnFilterValue(column.id);
+        return sortTypes.basic;
       },
-      setColumnFilterValue: function setColumnFilterValue(val) {
-        return instance.setColumnFilterValue(column.id, val);
+      getColumnAutoSortDir: function getColumnAutoSortDir(columnId) {
+        var firstRow = instance.getGlobalFilteredRowModel().flatRows[0];
+        var value = firstRow == null ? void 0 : firstRow.values[columnId];
+
+        if (typeof value === 'string') {
+          return 'asc';
+        }
+
+        return 'desc';
       },
-      getPreFilteredUniqueValues: function getPreFilteredUniqueValues() {
-        return getFacetInfo().preFilteredUniqueValues;
+      getColumnSortingFn: function getColumnSortingFn(columnId) {
+        var _ref;
+
+        var column = instance.getColumn(columnId);
+        var userSortTypes = instance.options.sortTypes;
+
+        if (!column) {
+          throw new Error();
+        }
+
+        return isFunction(column.sortType) ? column.sortType : column.sortType === 'auto' ? instance.getColumnAutoSortingFn(columnId) : (_ref = userSortTypes == null ? void 0 : userSortTypes[column.sortType]) != null ? _ref : sortTypes[column.sortType];
       },
-      getPreFilteredMinMaxValues: function getPreFilteredMinMaxValues() {
-        return getFacetInfo().preFilteredMinMaxValues;
+      setSorting: function setSorting(updater) {
+        return instance.options.onSortingChange == null ? void 0 : instance.options.onSortingChange(updater, functionalUpdate(updater, instance.getState().sorting));
       },
-      getPreFilteredRows: function getPreFilteredRows() {
-        return undefined;
-      }
-    };
-  }
-  function getInstance$2(instance) {
-    return {
-      getColumnAutoFilterFn: function getColumnAutoFilterFn(columnId) {
-        var firstRow = instance.getCoreFlatRows()[0];
-        var value = firstRow == null ? void 0 : firstRow.values[columnId];
+      toggleColumnSorting: function toggleColumnSorting(columnId, desc, multi) {
+        var column = instance.getColumn(columnId);
+
+        if (!column) {
+          throw new Error();
+        } // if (column.columns.length) {
+        //   column.columns.forEach((c, i) => {
+        //     if (c.id) {
+        //       instance.toggleColumnSorting(c.id, undefined, multi || !!i)
+        //     }
+        //   })
+        //   return
+        // }
+
+
+        instance.setSorting(function (old) {
+          var _ref2, _column$sortDescFirst, _instance$options$ena, _instance$options$ena2;
+
+          // Find any existing sorting for this column
+          var existingSorting = old == null ? void 0 : old.find(function (d) {
+            return d.id === columnId;
+          });
+          var existingIndex = old == null ? void 0 : old.findIndex(function (d) {
+            return d.id === columnId;
+          });
+          var hasDescDefined = typeof desc !== 'undefined' && desc !== null;
+          var newSorting = []; // What should we do with this sort action?
+
+          var sortAction;
+
+          if (column.getCanMultiSort() && multi) {
+            if (existingSorting) {
+              sortAction = 'toggle';
+            } else {
+              sortAction = 'add';
+            }
+          } else {
+            // Normal mode
+            if (old != null && old.length && existingIndex !== old.length - 1) {
+              sortAction = 'replace';
+            } else if (existingSorting) {
+              sortAction = 'toggle';
+            } else {
+              sortAction = 'replace';
+            }
+          }
+
+          var sortDescFirst = (_ref2 = (_column$sortDescFirst = column.sortDescFirst) != null ? _column$sortDescFirst : instance.options.sortDescFirst) != null ? _ref2 : instance.getColumnAutoSortDir(columnId) === 'desc'; // Handle toggle states that will remove the sorting
+
+          if (sortAction === 'toggle' && ( // Must be toggling
+          (_instance$options$ena = instance.options.enableSortingRemoval) != null ? _instance$options$ena : true) && // If enableSortRemove, enable in general
+          !hasDescDefined && ( // Must not be setting desc
+          multi ? (_instance$options$ena2 = instance.options.enableMultiRemove) != null ? _instance$options$ena2 : true : true) && ( // If multi, don't allow if enableMultiRemove
+          existingSorting != null && existingSorting.desc // Finally, detect if it should indeed be removed
+          ? !sortDescFirst : sortDescFirst)) {
+            sortAction = 'remove';
+          }
+
+          if (sortAction === 'replace') {
+            newSorting = [{
+              id: columnId,
+              desc: hasDescDefined ? desc : !!sortDescFirst
+            }];
+          } else if (sortAction === 'add' && old != null && old.length) {
+            var _instance$options$max;
 
-        if (typeof value === 'string') {
-          return filterTypes.includesString;
-        }
+            newSorting = [].concat(old, [{
+              id: columnId,
+              desc: hasDescDefined ? desc : !!sortDescFirst
+            }]); // Take latest n columns
 
-        if (typeof value === 'number') {
-          return filterTypes.betweenNumberRange;
-        }
+            newSorting.splice(0, newSorting.length - ((_instance$options$max = instance.options.maxMultiSortColCount) != null ? _instance$options$max : Number.MAX_SAFE_INTEGER));
+          } else if (sortAction === 'toggle' && old != null && old.length) {
+            // This flips (or sets) the
+            newSorting = old.map(function (d) {
+              if (d.id === columnId) {
+                return _extends({}, d, {
+                  desc: hasDescDefined ? desc : !(existingSorting != null && existingSorting.desc)
+                });
+              }
 
-        if (value !== null && typeof value === 'object') {
-          return filterTypes.equals;
-        }
+              return d;
+            });
+          } else if (sortAction === 'remove' && old != null && old.length) {
+            newSorting = old.filter(function (d) {
+              return d.id !== columnId;
+            });
+          }
 
-        if (Array.isArray(value)) {
-          return filterTypes.arrIncludes;
+          return newSorting;
+        });
+      },
+      getColumnCanSort: function getColumnCanSort(columnId) {
+        var _ref3, _ref4, _column$enableSorting;
+
+        var column = instance.getColumn(columnId);
+
+        if (!column) {
+          throw new Error();
         }
 
-        return filterTypes.weakEquals;
-      },
-      getGlobalAutoFilterFn: function getGlobalAutoFilterFn() {
-        return filterTypes.includesString;
+        return (_ref3 = (_ref4 = (_column$enableSorting = column.enableSorting) != null ? _column$enableSorting : instance.options.enableSorting) != null ? _ref4 : column.defaultCanSort) != null ? _ref3 : !!column.accessorFn // (!!column.accessorFn ||
+        //   column.columns?.some(c => c.id && instance.getColumnCanSort(c.id))) ??
+        // false
+        ;
       },
-      getColumnFilterFn: function getColumnFilterFn(columnId) {
-        var _ref;
+      getColumnCanMultiSort: function getColumnCanMultiSort(columnId) {
+        var _ref5, _column$enableMultiSo;
 
         var column = instance.getColumn(columnId);
-        var userFilterTypes = instance.options.filterTypes;
 
         if (!column) {
           throw new Error();
         }
 
-        return isFunction(column.filterType) ? column.filterType : column.filterType === 'auto' ? instance.getColumnAutoFilterFn(columnId) : (_ref = userFilterTypes == null ? void 0 : userFilterTypes[column.filterType]) != null ? _ref : filterTypes[column.filterType];
+        return (_ref5 = (_column$enableMultiSo = column.enableMultiSort) != null ? _column$enableMultiSo : instance.options.enableMultiSort) != null ? _ref5 : !!column.accessorFn;
       },
-      getGlobalFilterFn: function getGlobalFilterFn() {
-        var _ref2;
+      getColumnIsSorted: function getColumnIsSorted(columnId) {
+        var _instance$getState$so;
 
-        var _instance$options = instance.options,
-            userFilterTypes = _instance$options.filterTypes,
-            globalFilterType = _instance$options.globalFilterType;
-        return isFunction(globalFilterType) ? globalFilterType : globalFilterType === 'auto' ? instance.getGlobalAutoFilterFn() : (_ref2 = userFilterTypes == null ? void 0 : userFilterTypes[globalFilterType]) != null ? _ref2 : filterTypes[globalFilterType];
+        var columnSort = (_instance$getState$so = instance.getState().sorting) == null ? void 0 : _instance$getState$so.find(function (d) {
+          return d.id === columnId;
+        });
+        return !columnSort ? false : columnSort.desc ? 'desc' : 'asc';
       },
-      setColumnFilters: function setColumnFilters(updater) {
-        var leafColumns = instance.getAllLeafColumns();
-
-        var updateFn = function updateFn(old) {
-          var _functionalUpdate;
+      getColumnSortIndex: function getColumnSortIndex(columnId) {
+        var _instance$getState$so2, _instance$getState$so3;
 
-          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(function (filter) {
-            var column = leafColumns.find(function (d) {
-              return d.id === filter.id;
-            });
+        return (_instance$getState$so2 = (_instance$getState$so3 = instance.getState().sorting) == null ? void 0 : _instance$getState$so3.findIndex(function (d) {
+          return d.id === columnId;
+        })) != null ? _instance$getState$so2 : -1;
+      },
+      resetSorting: function resetSorting() {
+        var _instance$options$ini, _instance$options, _instance$options$ini2;
 
-            if (column) {
-              var filterFn = instance.getColumnFilterFn(column.id);
+        instance.setSorting((_instance$options$ini = (_instance$options = instance.options) == null ? void 0 : (_instance$options$ini2 = _instance$options.initialState) == null ? void 0 : _instance$options$ini2.sorting) != null ? _instance$options$ini : []);
+      },
+      getToggleSortingProps: function getToggleSortingProps(columnId, userProps) {
+        var column = instance.getColumn(columnId);
 
-              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
-                return false;
-              }
-            }
+        if (!column) {
+          throw new Error();
+        }
 
-            return true;
-          });
+        var canSort = column.getCanSort();
+        var initialProps = {
+          title: canSort ? 'Toggle Sorting' : undefined,
+          onClick: canSort ? function (e) {
+            e.persist();
+            column.toggleSorting == null ? void 0 : column.toggleSorting(undefined, column.getCanMultiSort() ? instance.options.isMultiSortEvent == null ? void 0 : instance.options.isMultiSortEvent(e) : false);
+          } : undefined
         };
+        return propGetter(initialProps, userProps);
+      },
+      getSortedRowModel: memo(function () {
+        return [instance.getState().sorting, instance.getGlobalFilteredRowModel(), instance.options.sortRowsFn];
+      }, function (sorting, rowModel, sortingFn) {
+        if (!sortingFn || !(sorting != null && sorting.length)) {
+          return rowModel;
+        }
 
-        instance.options.onColumnFiltersChange == null ? void 0 : instance.options.onColumnFiltersChange(updateFn, updateFn(instance.getState().columnFilters));
+        if (instance.options.debug) console.info('Sorting...');
+        return sortingFn(instance, rowModel);
+      }, {
+        key: 'getSortedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyGroupingReset();
+        }
+      }),
+      getPreSortedRows: function getPreSortedRows() {
+        return instance.getGlobalFilteredRowModel().rows;
       },
-      setGlobalFilter: function setGlobalFilter(updater) {
-        instance.options.onGlobalFilterChange == null ? void 0 : instance.options.onGlobalFilterChange(updater, functionalUpdate(updater, instance.getState().globalFilter));
+      getPreSortedFlatRows: function getPreSortedFlatRows() {
+        return instance.getGlobalFilteredRowModel().flatRows;
       },
-      resetGlobalFilter: function resetGlobalFilter() {
-        instance.setGlobalFilter(undefined);
+      getPreSortedRowsById: function getPreSortedRowsById() {
+        return instance.getGlobalFilteredRowModel().rowsById;
       },
-      getColumnCanColumnFilter: function getColumnCanColumnFilter(columnId) {
-        var _ref3, _ref4, _ref5, _ref6, _ref7, _column$enableAllFilt;
-
-        var column = instance.getColumn(columnId);
+      getSortedRows: function getSortedRows() {
+        return instance.getSortedRowModel().rows;
+      },
+      getSortedFlatRows: function getSortedFlatRows() {
+        return instance.getSortedRowModel().flatRows;
+      },
+      getSortedRowsById: function getSortedRowsById() {
+        return instance.getSortedRowModel().rowsById;
+      }
+    };
+  }
 
-        if (!column) {
-          throw new Error();
-        }
+  var Sorting = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getDefaultColumn: getDefaultColumn,
+    getInitialState: getInitialState$4,
+    getDefaultOptions: getDefaultOptions$4,
+    createColumn: createColumn$1,
+    getInstance: getInstance$4
+  });
 
-        return (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_ref7 = (_column$enableAllFilt = column.enableAllFilters) != null ? _column$enableAllFilt : column.enableColumnFilter) != null ? _ref7 : instance.options.enableFilters) != null ? _ref6 : instance.options.enableColumnFilters) != null ? _ref5 : column.defaultCanFilter) != null ? _ref4 : column.defaultCanColumnFilter) != null ? _ref3 : !!column.accessorFn;
+  //
+  function getInitialState$3() {
+    return {
+      expanded: {}
+    };
+  }
+  function getDefaultOptions$3(instance) {
+    return {
+      onExpandedChange: makeStateUpdater('expanded', instance),
+      autoResetExpanded: true,
+      getIsRowExpanded: function getIsRowExpanded(row) {
+        return !!(row == null ? void 0 : row.original).expanded;
       },
-      getColumnCanGlobalFilter: function getColumnCanGlobalFilter(columnId) {
-        var _ref8, _ref9, _ref10, _ref11, _ref12, _ref13, _instance$options$ena;
-
-        var column = instance.getColumn(columnId);
+      expandSubRows: true,
+      paginateExpandedRows: true
+    };
+  }
+  function getInstance$3(instance) {
+    var registered = false;
+    return {
+      _notifyExpandedReset: function _notifyExpandedReset() {
+        if (!registered) {
+          registered = true;
+          return;
+        }
 
-        if (!column) {
-          throw new Error();
+        if (instance.options.autoResetAll === false) {
+          return;
         }
 
-        return (_ref8 = ((_ref9 = (_ref10 = (_ref11 = (_ref12 = (_ref13 = (_instance$options$ena = instance.options.enableFilters) != null ? _instance$options$ena : instance.options.enableGlobalFilter) != null ? _ref13 : column.enableAllFilters) != null ? _ref12 : column.enableGlobalFilter) != null ? _ref11 : column.defaultCanFilter) != null ? _ref10 : column.defaultCanGlobalFilter) != null ? _ref9 : !!column.accessorFn) && (instance.options.getColumnCanGlobalFilterFn == null ? void 0 : instance.options.getColumnCanGlobalFilterFn(column))) != null ? _ref8 : true;
+        if (instance.options.autoResetAll === true || instance.options.autoResetExpanded) {
+          instance.resetExpanded();
+        }
       },
-      getColumnIsFiltered: function getColumnIsFiltered(columnId) {
-        return instance.getColumnFilterIndex(columnId) > -1;
+      setExpanded: function setExpanded(updater) {
+        return instance.options.onExpandedChange == null ? void 0 : instance.options.onExpandedChange(updater, functionalUpdate(updater, instance.getState().expanded));
       },
-      getColumnFilterValue: function getColumnFilterValue(columnId) {
-        var _instance$getState$co, _instance$getState$co2;
+      toggleRowExpanded: function toggleRowExpanded(rowId, expanded) {
+        if (!rowId) return;
+        instance.setExpanded(function (old) {
+          var _old, _expanded;
 
-        return (_instance$getState$co = instance.getState().columnFilters) == null ? void 0 : (_instance$getState$co2 = _instance$getState$co.find(function (d) {
-          return d.id === columnId;
-        })) == null ? void 0 : _instance$getState$co2.value;
-      },
-      getColumnFilterIndex: function getColumnFilterIndex(columnId) {
-        var _instance$getState$co3, _instance$getState$co4;
+          if (old === void 0) {
+            old = {};
+          }
 
-        return (_instance$getState$co3 = (_instance$getState$co4 = instance.getState().columnFilters) == null ? void 0 : _instance$getState$co4.findIndex(function (d) {
-          return d.id === columnId;
-        })) != null ? _instance$getState$co3 : -1;
-      },
-      setColumnFilterValue: function setColumnFilterValue(columnId, value) {
-        if (!columnId) return;
-        instance.setColumnFilters(function (old) {
-          var column = instance.getColumn(columnId);
+          var exists = old === true ? true : !!((_old = old) != null && _old[rowId]);
+          var oldExpanded = {};
 
-          if (!column) {
-            {
-              console.warn("React-Table: Could not find a column with id: " + columnId);
-            }
+          if (old === true) {
+            Object.keys(instance.getRowsById()).forEach(function (rowId) {
+              oldExpanded[rowId] = true;
+            });
+          } else {
+            oldExpanded = old;
+          }
 
-            throw new Error();
+          expanded = (_expanded = expanded) != null ? _expanded : !exists;
+
+          if (!exists && expanded) {
+            var _extends2;
+
+            return _extends({}, oldExpanded, (_extends2 = {}, _extends2[rowId] = true, _extends2));
           }
 
-          var filterFn = instance.getColumnFilterFn(column.id);
-          var previousfilter = old == null ? void 0 : old.find(function (d) {
-            return d.id === columnId;
-          });
-          var newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined); //
+          if (exists && !expanded) {
+            var _oldExpanded = oldExpanded;
+                _oldExpanded[rowId];
+                var rest = _objectWithoutPropertiesLoose(_oldExpanded, [rowId].map(_toPropertyKey));
 
-          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
-            var _old$filter;
+            return rest;
+          }
 
-            return (_old$filter = old == null ? void 0 : old.filter(function (d) {
-              return d.id !== columnId;
-            })) != null ? _old$filter : [];
+          return old;
+        });
+      },
+      toggleAllRowsExpanded: function toggleAllRowsExpanded(expanded) {
+        if (expanded != null ? expanded : !instance.getIsAllRowsExpanded()) {
+          instance.setExpanded(true);
+        } else {
+          instance.setExpanded({});
+        }
+      },
+      resetExpanded: function resetExpanded() {
+        var _instance$options$ini, _instance$options, _instance$options$ini2;
+
+        instance.setExpanded((_instance$options$ini = (_instance$options = instance.options) == null ? void 0 : (_instance$options$ini2 = _instance$options.initialState) == null ? void 0 : _instance$options$ini2.expanded) != null ? _instance$options$ini : {});
+      },
+      getIsRowExpanded: function getIsRowExpanded(rowId) {
+        var _instance$options$get;
+
+        var row = instance.getRow(rowId);
+
+        if (!row) {
+          {
+            console.warn("[ReactTable] getIsRowExpanded: no row found with id " + rowId);
           }
 
-          var newFilterObj = {
-            id: columnId,
-            value: newFilter
-          };
+          throw new Error();
+        }
 
-          if (previousfilter) {
-            var _old$map;
+        var expanded = instance.getState().expanded;
+        return !!((_instance$options$get = instance.options.getIsRowExpanded == null ? void 0 : instance.options.getIsRowExpanded(row)) != null ? _instance$options$get : expanded || (expanded == null ? void 0 : expanded[rowId]));
+      },
+      getRowCanExpand: function getRowCanExpand(rowId) {
+        var _ref, _ref2, _instance$options$get2, _row$subRows;
 
-            return (_old$map = old == null ? void 0 : old.map(function (d) {
-              if (d.id === columnId) {
-                return newFilterObj;
-              }
+        var row = instance.getRow(rowId);
 
-              return d;
-            })) != null ? _old$map : [];
+        if (!row) {
+          {
+            console.warn("[ReactTable] getRowCanExpand: no row found with id " + rowId);
           }
 
-          if (old != null && old.length) {
-            return [].concat(old, [newFilterObj]);
-          }
+          throw new Error();
+        }
 
-          return [newFilterObj];
-        });
+        return (_ref = (_ref2 = (_instance$options$get2 = instance.options.getRowCanExpand == null ? void 0 : instance.options.getRowCanExpand(row)) != null ? _instance$options$get2 : instance.options.enableExpanded) != null ? _ref2 : instance.options.defaultCanExpand) != null ? _ref : !!((_row$subRows = row.subRows) != null && _row$subRows.length);
       },
-      resetColumnFilters: function resetColumnFilters() {
-        var _instance$options$ini, _instance$options2, _instance$options2$in;
+      getToggleExpandedProps: function getToggleExpandedProps(rowId, userProps) {
+        var row = instance.getRow(rowId);
 
-        instance.setColumnFilters((_instance$options$ini = (_instance$options2 = instance.options) == null ? void 0 : (_instance$options2$in = _instance$options2.initialState) == null ? void 0 : _instance$options2$in.columnFilters) != null ? _instance$options$ini : []);
+        if (!row) {
+          return;
+        }
+
+        var canExpand = instance.getRowCanExpand(rowId);
+        var initialProps = {
+          title: canExpand ? 'Toggle Expanded' : undefined,
+          onClick: canExpand ? function (e) {
+            e.persist();
+            instance.toggleRowExpanded(rowId);
+          } : undefined
+        };
+        return propGetter(initialProps, userProps);
       },
-      getColumnFilteredRowModel: memo(function () {
-        return [instance.getState().columnFilters, instance.getCoreRowModel(), instance.options.columnFilterRowsFn];
-      }, function (columnFilters, rowModel, columnFiltersFn) {
-        var columnFilteredRowModel = function () {
-          if (!(columnFilters != null && columnFilters.length) || !columnFiltersFn) {
-            return rowModel;
+      getToggleAllRowsExpandedProps: function getToggleAllRowsExpandedProps(userProps) {
+        var initialProps = {
+          title: 'Toggle All Expanded',
+          onClick: function onClick(e) {
+            e.persist();
+            instance.toggleAllRowsExpanded();
           }
+        };
+        return propGetter(initialProps, userProps);
+      },
+      getIsAllRowsExpanded: function getIsAllRowsExpanded() {
+        var expanded = instance.getState().expanded; // If expanded is true, save some cycles and return true
 
-          if (instance.options.debug) console.info('Column Filtering...');
-          return columnFiltersFn(instance, columnFilters, rowModel);
-        }(); // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
+        if (expanded === true) {
+          return true;
+        } // If any row is not expanded, return false
 
 
-        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
-          var _instance$getState$co5;
+        if (Object.keys(instance.getRowsById()).some(function (id) {
+          return !instance.getIsRowExpanded(id);
+        })) {
+          return false;
+        } // They must all be expanded :shrug:
 
-          return !((_instance$getState$co5 = instance.getState().columnFilters) != null && _instance$getState$co5.find(function (d) {
-            return d.id === column.id;
-          }));
-        }); // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
 
-        nonFilteredColumns.forEach(function (column) {
-          column.getPreFilteredRows = function () {
-            return columnFilteredRowModel.rows;
-          };
+        return true;
+      },
+      getExpandedDepth: function getExpandedDepth() {
+        var maxDepth = 0;
+        var rowIds = instance.getState().expanded === true ? Object.keys(instance.getRowsById()) : Object.keys(instance.getState().expanded);
+        rowIds.forEach(function (id) {
+          var splitId = id.split('.');
+          maxDepth = Math.max(maxDepth, splitId.length);
         });
-        return columnFilteredRowModel;
-      }, 'getColumnFilteredRowModel', instance.options.debug),
-      getPreColumnFilteredRows: function getPreColumnFilteredRows() {
-        return instance.getCoreRowModel().rows;
+        return maxDepth;
       },
-      getPreColumnFilteredFlatRows: function getPreColumnFilteredFlatRows() {
-        return instance.getCoreRowModel().flatRows;
+      getExpandedRowModel: memo(function () {
+        return [instance.getState().expanded, instance.getGroupedRowModel(), instance.options.expandRowsFn, instance.options.paginateExpandedRows];
+      }, function (expanded, rowModel, expandRowsFn, paginateExpandedRows) {
+        if (!expandRowsFn || // Do not expand if rows are not included in pagination
+        !paginateExpandedRows || !Object.keys(expanded != null ? expanded : {}).length) {
+          return rowModel;
+        }
+
+        if (instance.options.debug) console.info('Expanding...');
+        return expandRowsFn(instance, rowModel);
+      }, {
+        key: 'getExpandedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyPageIndexReset();
+        }
+      }),
+      getPreExpandedRows: function getPreExpandedRows() {
+        return instance.getGroupedRowModel().rows;
       },
-      getPreColumnFilteredRowsById: function getPreColumnFilteredRowsById() {
-        return instance.getCoreRowModel().rowsById;
+      getPreExpandedFlatRows: function getPreExpandedFlatRows() {
+        return instance.getGroupedRowModel().flatRows;
       },
-      getColumnFilteredRows: function getColumnFilteredRows() {
-        return instance.getColumnFilteredRowModel().rows;
+      getPreExpandedRowsById: function getPreExpandedRowsById() {
+        return instance.getGroupedRowModel().rowsById;
       },
-      getColumnFilteredFlatRows: function getColumnFilteredFlatRows() {
-        return instance.getColumnFilteredRowModel().flatRows;
+      getExpandedRows: function getExpandedRows() {
+        return instance.getExpandedRowModel().rows;
       },
-      getColumnFilteredRowsById: function getColumnFilteredRowsById() {
-        return instance.getColumnFilteredRowModel().rowsById;
+      getExpandedFlatRows: function getExpandedFlatRows() {
+        return instance.getExpandedRowModel().flatRows;
       },
-      getGlobalFilteredRowModel: memo(function () {
-        return [instance.getState().globalFilter, instance.getColumnFilteredRowModel(), instance.options.globalFilterRowsFn];
-      }, function (globalFilterValue, columnFilteredRowModel, globalFiltersFn) {
-        var globalFilteredRowModel = function () {
-          if (!globalFiltersFn || !globalFilterValue) {
-            return columnFilteredRowModel;
+      getExpandedRowsById: function getExpandedRowsById() {
+        return instance.getExpandedRowModel().rowsById;
+      }
+    };
+  }
+  function createRow$1(row, instance) {
+    return {
+      toggleExpanded: function toggleExpanded(expanded) {
+        return void instance.toggleRowExpanded(row.id, expanded);
+      },
+      getIsExpanded: function getIsExpanded() {
+        return instance.getIsRowExpanded(row.id);
+      },
+      getCanExpand: function getCanExpand() {
+        return row.subRows && !!row.subRows.length;
+      },
+      getToggleExpandedProps: function getToggleExpandedProps(userProps) {
+        var initialProps = {
+          title: 'Toggle Row Expanded',
+          onClick: function onClick(e) {
+            e.stopPropagation();
+            instance.toggleRowExpanded(row.id);
           }
+        };
+        return propGetter(initialProps, userProps);
+      }
+    };
+  }
 
-          if (instance.options.debug) console.info('Global Filtering...');
-          return globalFiltersFn(instance, globalFilterValue, columnFilteredRowModel);
-        }(); // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
+  var Expanding = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState$3,
+    getDefaultOptions: getDefaultOptions$3,
+    getInstance: getInstance$3,
+    createRow: createRow$1
+  });
 
+  //
+  var defaultColumnSizing = {
+    width: 150,
+    minWidth: 20,
+    maxWidth: Number.MAX_SAFE_INTEGER
+  };
+  function getInitialState$2() {
+    return {
+      columnSizing: {},
+      columnSizingInfo: {
+        startOffset: null,
+        startSize: null,
+        deltaOffset: null,
+        deltaPercentage: null,
+        isResizingColumn: false,
+        columnSizingStart: []
+      }
+    };
+  }
+  function getDefaultOptions$2(instance) {
+    return {
+      columnResizeMode: 'onEnd',
+      onColumnSizingChange: makeStateUpdater('columnSizing', instance),
+      onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', instance)
+    };
+  }
+  function getInstance$2(instance) {
+    return {
+      setColumnSizing: function setColumnSizing(updater) {
+        return instance.options.onColumnSizingChange == null ? void 0 : instance.options.onColumnSizingChange(updater, functionalUpdate(updater, instance.getState().columnSizing));
+      },
+      setColumnSizingInfo: function setColumnSizingInfo(updater) {
+        return instance.options.onColumnSizingInfoChange == null ? void 0 : instance.options.onColumnSizingInfoChange(updater, functionalUpdate(updater, instance.getState().columnSizingInfo));
+      },
+      resetColumnSizing: function resetColumnSizing() {
+        var _instance$initialStat;
 
-        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
-          var _instance$getState$co6;
+        instance.setColumnSizing((_instance$initialStat = instance.initialState.columnSizing) != null ? _instance$initialStat : {});
+      },
+      resetHeaderSizeInfo: function resetHeaderSizeInfo() {
+        var _instance$initialStat2;
 
-          return !((_instance$getState$co6 = instance.getState().columnFilters) != null && _instance$getState$co6.find(function (d) {
-            return d.id === column.id;
-          }));
-        }); // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
+        instance.setColumnSizingInfo((_instance$initialStat2 = instance.initialState.columnSizingInfo) != null ? _instance$initialStat2 : {});
+      },
+      resetColumnSize: function resetColumnSize(columnId) {
+        instance.setColumnSizing(function (_ref) {
+          _ref[columnId];
+              var rest = _objectWithoutPropertiesLoose(_ref, [columnId].map(_toPropertyKey));
 
-        nonFilteredColumns.forEach(function (column) {
-          column.getPreFilteredRows = function () {
-            return globalFilteredRowModel.rows;
-          };
+          return rest;
         });
-        return globalFilteredRowModel;
-      }, 'getGlobalFilteredRowModel', instance.options.debug),
-      getPreGlobalFilteredRows: function getPreGlobalFilteredRows() {
-        return instance.getColumnFilteredRowModel().rows;
       },
-      getPreGlobalFilteredFlatRows: function getPreGlobalFilteredFlatRows() {
-        return instance.getColumnFilteredRowModel().flatRows;
-      },
-      getPreGlobalFilteredRowsById: function getPreGlobalFilteredRowsById() {
-        return instance.getColumnFilteredRowModel().rowsById;
-      },
-      getGlobalFilteredRows: function getGlobalFilteredRows() {
-        return instance.getGlobalFilteredRowModel().rows;
+      resetHeaderSize: function resetHeaderSize(headerId) {
+        var header = instance.getHeader(headerId);
+
+        if (!header) {
+          return;
+        }
+
+        return instance.resetColumnSize(header.column.id);
       },
-      getGlobalFilteredFlatRows: function getGlobalFilteredFlatRows() {
-        return instance.getGlobalFilteredRowModel().flatRows;
+      getHeaderCanResize: function getHeaderCanResize(headerId) {
+        var header = instance.getHeader(headerId);
+
+        if (!header) {
+          throw new Error();
+        }
+
+        return instance.getColumnCanResize(header.column.id);
       },
-      getGlobalFilteredRowsById: function getGlobalFilteredRowsById() {
-        return instance.getGlobalFilteredRowModel().rowsById;
-      }
-    };
-  }
-  function shouldAutoRemoveFilter(filterFn, value, column) {
-    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
-  }
+      getColumnCanResize: function getColumnCanResize(columnId) {
+        var _ref2, _ref3, _column$enableResizin;
 
-  var reSplitAlphaNumeric = /([0-9]+)/gm;
-  var sortTypes = {
-    alphanumeric: alphanumeric,
-    alphanumericCaseSensitive: alphanumericCaseSensitive,
-    text: text,
-    textCaseSensitive: textCaseSensitive,
-    datetime: datetime,
-    basic: basic
-  };
+        var column = instance.getColumn(columnId);
 
-  function alphanumeric(rowA, rowB, columnId) {
-    return compareAlphanumeric(toString(rowA.values[columnId]).toLowerCase(), toString(rowB.values[columnId]).toLowerCase());
-  }
+        if (!column) {
+          throw new Error();
+        }
 
-  function alphanumericCaseSensitive(rowA, rowB, columnId) {
-    return compareAlphanumeric(toString(rowA.values[columnId]), toString(rowB.values[columnId]));
-  } // Mixed sorting is slow, but very inclusive of many edge cases.
-  // It handles numbers, mixed alphanumeric combinations, and even
-  // null, undefined, and Infinity
+        return (_ref2 = (_ref3 = (_column$enableResizin = column.enableResizing) != null ? _column$enableResizin : instance.options.enableColumnResizing) != null ? _ref3 : column.defaultCanResize) != null ? _ref2 : true;
+      },
+      getColumnIsResizing: function getColumnIsResizing(columnId) {
+        var column = instance.getColumn(columnId);
 
+        if (!column) {
+          throw new Error();
+        }
 
-  function compareAlphanumeric(aStr, bStr) {
-    // Split on number groups, but keep the delimiter
-    // Then remove falsey split values
-    var a = aStr.split(reSplitAlphaNumeric).filter(Boolean);
-    var b = bStr.split(reSplitAlphaNumeric).filter(Boolean); // While
+        return instance.getState().columnSizingInfo.isResizingColumn === columnId;
+      },
+      getHeaderIsResizing: function getHeaderIsResizing(headerId) {
+        var header = instance.getHeader(headerId);
 
-    while (a.length && b.length) {
-      var aa = a.shift();
-      var bb = b.shift();
-      var an = parseInt(aa, 10);
-      var bn = parseInt(bb, 10);
-      var combo = [an, bn].sort(); // Both are string
+        if (!header) {
+          throw new Error();
+        }
 
-      if (isNaN(combo[0])) {
-        if (aa > bb) {
-          return 1;
+        return instance.getColumnIsResizing(header.column.id);
+      },
+      getColumnResizerProps: function getColumnResizerProps(headerId, userProps) {
+        var header = instance.getHeader(headerId);
+
+        if (!header) {
+          return;
         }
 
-        if (bb > aa) {
-          return -1;
+        var column = instance.getColumn(header.column.id);
+
+        if (!column) {
+          return;
         }
 
-        continue;
-      } // One is a string, one is a number
+        var canResize = column.getCanResize();
 
+        var onResizeStart = function onResizeStart(e) {
+          if (isTouchStartEvent(e)) {
+            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
+            if (e.touches && e.touches.length > 1) {
+              return;
+            }
+          }
 
-      if (isNaN(combo[1])) {
-        return isNaN(an) ? -1 : 1;
-      } // Both are numbers
+          var columnSizingStart = header.getLeafHeaders().map(function (d) {
+            return [d.column.id, d.getWidth()];
+          });
+          var clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
 
+          var updateOffset = function updateOffset(eventType, clientXPos) {
+            if (typeof clientXPos !== 'number') {
+              return;
+            }
 
-      if (an > bn) {
-        return 1;
-      }
+            var newColumnSizing = {};
+            instance.setColumnSizingInfo(function (old) {
+              var _old$startOffset, _old$startSize;
 
-      if (bn > an) {
-        return -1;
-      }
-    }
+              var deltaOffset = clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0);
+              var deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999);
+              old.columnSizingStart.forEach(function (_ref4) {
+                var columnId = _ref4[0],
+                    headerWidth = _ref4[1];
+                newColumnSizing[columnId] = Math.max(headerWidth + headerWidth * deltaPercentage, 0);
+              });
+              return _extends({}, old, {
+                deltaOffset: deltaOffset,
+                deltaPercentage: deltaPercentage
+              });
+            });
 
-    return a.length - b.length;
-  } // The text filter is more basic (less numeric support)
-  // but is much faster
+            if (instance.options.columnResizeMode === 'onChange' || eventType === 'end') {
+              instance.setColumnSizing(function (old) {
+                return _extends({}, old, newColumnSizing);
+              });
+            }
+          };
+
+          var onMove = function onMove(clientXPos) {
+            return updateOffset('move', clientXPos);
+          };
 
+          var onEnd = function onEnd(clientXPos) {
+            updateOffset('end', clientXPos);
+            instance.setColumnSizingInfo(function (old) {
+              return _extends({}, old, {
+                isResizingColumn: false,
+                startOffset: null,
+                startSize: null,
+                deltaOffset: null,
+                deltaPercentage: null,
+                columnSizingStart: []
+              });
+            });
+          };
 
-  function text(rowA, rowB, columnId) {
-    return compareBasic(toString(rowA.values[columnId]).toLowerCase(), toString(rowB.values[columnId]).toLowerCase());
-  } // The text filter is more basic (less numeric support)
-  // but is much faster
+          var mouseEvents = {
+            moveHandler: function moveHandler(e) {
+              return onMove(e.clientX);
+            },
+            upHandler: function upHandler(e) {
+              document.removeEventListener('mousemove', mouseEvents.moveHandler);
+              document.removeEventListener('mouseup', mouseEvents.upHandler);
+              onEnd(e.clientX);
+            }
+          };
+          var touchEvents = {
+            moveHandler: function moveHandler(e) {
+              if (e.cancelable) {
+                e.preventDefault();
+                e.stopPropagation();
+              }
 
+              onMove(e.touches[0].clientX);
+              return false;
+            },
+            upHandler: function upHandler(e) {
+              document.removeEventListener('touchmove', touchEvents.moveHandler);
+              document.removeEventListener('touchend', touchEvents.upHandler);
 
-  function textCaseSensitive(rowA, rowB, columnId) {
-    return compareBasic(toString(rowA.values[columnId]), toString(rowB.values[columnId]));
-  }
+              if (e.cancelable) {
+                e.preventDefault();
+                e.stopPropagation();
+              }
 
-  function datetime(rowA, rowB, columnId) {
-    return compareBasic(rowA.values[columnId].getTime(), rowB.values[columnId].getTime());
-  }
+              onEnd(e.touches[0].clientX);
+            }
+          };
+          var passiveIfSupported = passiveEventSupported() ? {
+            passive: false
+          } : false;
 
-  function basic(rowA, rowB, columnId) {
-    return compareBasic(rowA.values[columnId], rowB.values[columnId]);
-  } // Utils
+          if (isTouchStartEvent(e)) {
+            document.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported);
+            document.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported);
+          } else {
+            document.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported);
+            document.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported);
+          }
 
+          instance.setColumnSizingInfo(function (old) {
+            return _extends({}, old, {
+              startOffset: clientX,
+              startSize: header.getWidth(),
+              deltaOffset: 0,
+              deltaPercentage: 0,
+              columnSizingStart: columnSizingStart,
+              isResizingColumn: header.column.id
+            });
+          });
+        };
 
-  function compareBasic(a, b) {
-    return a === b ? 0 : a > b ? 1 : -1;
+        var initialProps = canResize ? {
+          title: 'Toggle Grouping',
+          draggable: false,
+          role: 'separator',
+          onMouseDown: function onMouseDown(e) {
+            e.persist();
+            onResizeStart(e);
+          },
+          onTouchStart: function onTouchStart(e) {
+            e.persist();
+            onResizeStart(e);
+          }
+        } : {};
+        return propGetter(initialProps, userProps);
+      }
+    };
   }
-
-  function toString(a) {
-    if (typeof a === 'number') {
-      if (isNaN(a) || a === Infinity || a === -Infinity) {
-        return '';
+  function createColumn(column, instance) {
+    return {
+      getIsResizing: function getIsResizing() {
+        return instance.getColumnIsResizing(column.id);
+      },
+      getCanResize: function getCanResize() {
+        return instance.getColumnCanResize(column.id);
+      },
+      resetSize: function resetSize() {
+        return instance.resetColumnSize(column.id);
+      },
+      getResizerProps: function getResizerProps(userProps) {
+        return instance.getColumnResizerProps(column.id, userProps);
       }
+    };
+  }
+  var passiveSupported = null;
+  function passiveEventSupported() {
+    if (typeof passiveSupported === 'boolean') return passiveSupported;
+    var supported = false;
+
+    try {
+      var options = {
+        get passive() {
+          supported = true;
+          return false;
+        }
+
+      };
+
+      var noop = function noop() {};
 
-      return String(a);
+      window.addEventListener('test', noop, options);
+      window.removeEventListener('test', noop);
+    } catch (err) {
+      supported = false;
     }
 
-    if (typeof a === 'string') {
-      return a;
-    }
+    passiveSupported = supported;
+    return passiveSupported;
+  }
 
-    return '';
+  function isTouchStartEvent(e) {
+    return e.type === 'touchstart';
   }
 
+  var ColumnSizing = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    defaultColumnSizing: defaultColumnSizing,
+    getInitialState: getInitialState$2,
+    getDefaultOptions: getDefaultOptions$2,
+    getInstance: getInstance$2,
+    createColumn: createColumn,
+    passiveEventSupported: passiveEventSupported
+  });
+
   //
-  function getDefaultColumn() {
-    return {
-      sortType: 'auto'
-    };
-  }
   function getInitialState$1() {
     return {
-      sorting: []
+      pagination: {
+        pageIndex: 0,
+        pageSize: 10
+      }
     };
   }
   function getDefaultOptions$1(instance) {
     return {
-      onSortingChange: makeStateUpdater('sorting', instance),
-      autoResetSorting: true
-    };
-  }
-  function createColumn(column, instance) {
-    return {
-      sortType: column.sortType,
-      getCanSort: function getCanSort() {
-        return instance.getColumnCanSort(column.id);
-      },
-      getCanMultiSort: function getCanMultiSort() {
-        return instance.getColumnCanMultiSort(column.id);
-      },
-      getSortIndex: function getSortIndex() {
-        return instance.getColumnSortIndex(column.id);
-      },
-      getIsSorted: function getIsSorted() {
-        return instance.getColumnIsSorted(column.id);
-      },
-      toggleSorting: function toggleSorting(desc, isMulti) {
-        return instance.toggleColumnSorting(column.id, desc, isMulti);
-      },
-      getToggleSortingProps: function getToggleSortingProps(userProps) {
-        return instance.getToggleSortingProps(column.id, userProps);
-      }
+      onPaginationChange: makeStateUpdater('pagination', instance),
+      autoResetPageIndex: true
     };
   }
   function getInstance$1(instance) {
+    var registered = false;
     return {
-      getColumnAutoSortingFn: function getColumnAutoSortingFn(columnId) {
-        var firstRow = instance.getGlobalFilteredRowModel().flatRows[0];
-        var value = firstRow == null ? void 0 : firstRow.values[columnId];
-
-        if (typeof value === 'string') {
-          return sortTypes.alphanumeric;
+      _notifyPageIndexReset: function _notifyPageIndexReset() {
+        if (!registered) {
+          registered = true;
+          return;
         }
 
-        if (Object.prototype.toString.call(value) === '[object Date]') {
-          return sortTypes.datetime;
+        if (instance.options.autoResetAll === false) {
+          return;
         }
 
-        return sortTypes.basic;
-      },
-      getColumnSortingFn: function getColumnSortingFn(columnId) {
-        var _ref;
-
-        var column = instance.getColumn(columnId);
-        var userSortTypes = instance.options.sortTypes;
-
-        if (!column) {
-          throw new Error();
+        if (instance.options.autoResetAll === true || instance.options.autoResetPageIndex) {
+          instance.resetPageSize();
         }
-
-        return isFunction(column.sortType) ? column.sortType : column.sortType === 'auto' ? instance.getColumnAutoFilterFn(columnId) : (_ref = userSortTypes == null ? void 0 : userSortTypes[column.sortType]) != null ? _ref : sortTypes[column.sortType];
-      },
-      setSorting: function setSorting(updater) {
-        return instance.options.onSortingChange == null ? void 0 : instance.options.onSortingChange(updater, functionalUpdate(updater, instance.getState().sorting));
       },
-      toggleColumnSorting: function toggleColumnSorting(columnId, desc, multi) {
-        var column = instance.getColumn(columnId);
-
-        if (!column) {
-          throw new Error();
-        }
-
-        instance.setSorting(function (old) {
-          var _column$sortDescFirst, _instance$options$ena, _instance$options$ena2;
-
-          // Find any existing sorting for this column
-          var existingSorting = old == null ? void 0 : old.find(function (d) {
-            return d.id === columnId;
-          });
-          var existingIndex = old == null ? void 0 : old.findIndex(function (d) {
-            return d.id === columnId;
-          });
-          var hasDescDefined = typeof desc !== 'undefined' && desc !== null;
-          var newSorting = []; // What should we do with this sort action?
+      setPagination: function setPagination(updater) {
+        var safeUpdater = function safeUpdater(old) {
+          var newState = functionalUpdate(updater, old);
 
-          var sortAction;
+          if (instance.options.paginateRowsFn) {
+            var _instance$getPrePagin;
 
-          if (!column.getCanMultiSort() && multi) {
-            if (existingSorting) {
-              sortAction = 'toggle';
-            } else {
-              sortAction = 'add';
-            }
-          } else {
-            // Normal mode
-            if (old != null && old.length && existingIndex !== old.length - 1) {
-              sortAction = 'replace';
-            } else if (existingSorting) {
-              sortAction = 'toggle';
-            } else {
-              sortAction = 'replace';
-            }
+            newState.pageCount = (_instance$getPrePagin = instance.getPrePaginationRows()) != null && _instance$getPrePagin.length ? Math.ceil(instance.getPrePaginationRows().length / instance.getState().pagination.pageSize) : 0;
           }
 
-          var sortDescFirst = (_column$sortDescFirst = column.sortDescFirst) != null ? _column$sortDescFirst : instance.options.sortDescFirst; // Handle toggle states that will remove the sorting
-
-          if (sortAction === 'toggle' && ( // Must be toggling
-          (_instance$options$ena = instance.options.enableSortingRemoval) != null ? _instance$options$ena : true) && // If enableSortRemove, enable in general
-          !hasDescDefined && ( // Must not be setting desc
-          multi ? (_instance$options$ena2 = instance.options.enableMultiRemove) != null ? _instance$options$ena2 : true : true) && ( // If multi, don't allow if enableMultiRemove
-          existingSorting != null && existingSorting.desc // Finally, detect if it should indeed be removed
-          ? !sortDescFirst : sortDescFirst)) {
-            sortAction = 'remove';
-          }
+          return newState;
+        };
 
-          if (sortAction === 'replace') {
-            newSorting = [{
-              id: columnId,
-              desc: hasDescDefined ? desc : !!sortDescFirst
-            }];
-          } else if (sortAction === 'add' && old != null && old.length) {
-            var _instance$options$max;
+        return instance.options.onPaginationChange == null ? void 0 : instance.options.onPaginationChange(safeUpdater, functionalUpdate(safeUpdater, instance.getState().pagination));
+      },
+      resetPagination: function resetPagination() {
+        var _instance$initialStat;
 
-            newSorting = [].concat(old, [{
-              id: columnId,
-              desc: hasDescDefined ? desc : !!sortDescFirst
-            }]); // Take latest n columns
+        instance.setPagination((_instance$initialStat = instance.initialState.pagination) != null ? _instance$initialStat : {
+          pageIndex: 0,
+          pageSize: 10,
+          pageCount: -1
+        });
+      },
+      setPageIndex: function setPageIndex(updater) {
+        instance.setPagination(function (old) {
+          var pageIndex = functionalUpdate(updater, old.pageIndex);
+          var maxPageIndex = old.pageCount && old.pageCount > 0 ? old.pageCount - 1 : Number.MAX_SAFE_INTEGER;
+          pageIndex = Math.min(Math.max(0, pageIndex), maxPageIndex);
+          return _extends({}, old, {
+            pageIndex: pageIndex
+          });
+        });
+      },
+      resetPageIndex: function resetPageIndex() {
+        instance.setPageIndex(0);
+      },
+      resetPageSize: function resetPageSize() {
+        var _instance$options$ini, _instance$options$ini2, _instance$options$ini3;
 
-            newSorting.splice(0, newSorting.length - ((_instance$options$max = instance.options.maxMultiSortColCount) != null ? _instance$options$max : Number.MAX_SAFE_INTEGER));
-          } else if (sortAction === 'toggle' && old != null && old.length) {
-            // This flips (or sets) the
-            newSorting = old.map(function (d) {
-              if (d.id === columnId) {
-                return _extends({}, d, {
-                  desc: hasDescDefined ? desc : !(existingSorting != null && existingSorting.desc)
-                });
-              }
+        instance.setPageSize((_instance$options$ini = (_instance$options$ini2 = instance.options.initialState) == null ? void 0 : (_instance$options$ini3 = _instance$options$ini2.pagination) == null ? void 0 : _instance$options$ini3.pageSize) != null ? _instance$options$ini : 10);
+      },
+      setPageSize: function setPageSize(updater) {
+        instance.setPagination(function (old) {
+          var pageSize = Math.max(1, functionalUpdate(updater, old.pageSize));
+          var topRowIndex = old.pageSize * old.pageIndex;
+          var pageIndex = Math.floor(topRowIndex / pageSize);
+          return _extends({}, old, {
+            pageIndex: pageIndex,
+            pageSize: pageSize
+          });
+        });
+      },
+      setPageCount: function setPageCount(updater) {
+        return instance.setPagination(function (old) {
+          var newPageCount = functionalUpdate(updater, old.pageCount);
 
-              return d;
-            });
-          } else if (sortAction === 'remove' && old != null && old.length) {
-            newSorting = old.filter(function (d) {
-              return d.id !== columnId;
-            });
+          if (typeof newPageCount === 'number') {
+            newPageCount = Math.max(-1, newPageCount);
           }
 
-          return newSorting;
+          return _extends({}, old, {
+            pageCount: newPageCount
+          });
         });
       },
-      getColumnCanSort: function getColumnCanSort(columnId) {
-        var _ref2, _ref3, _column$enableSorting;
-
-        var column = instance.getColumn(columnId);
+      getPageOptions: memo(function () {
+        return [instance.getState().pagination.pageSize, instance.getState().pagination.pageCount];
+      }, function (pageSize, pageCount) {
+        var pageOptions = [];
 
-        if (!column) {
-          throw new Error();
+        if (pageCount && pageCount > 0) {
+          pageOptions = [].concat(new Array(pageCount)).fill(null).map(function (_, i) {
+            return i;
+          });
         }
 
-        return (_ref2 = (_ref3 = (_column$enableSorting = column.enableSorting) != null ? _column$enableSorting : instance.options.enableSorting) != null ? _ref3 : column.defaultCanSort) != null ? _ref2 : !!column.accessorFn;
-      },
-      getColumnCanMultiSort: function getColumnCanMultiSort(columnId) {
-        var _ref4, _column$enableMultiSo;
-
-        var column = instance.getColumn(columnId);
+        return pageOptions;
+      }, {
+        key: 'getPageOptions',
+        debug: instance.options.debug
+      }),
+      getCanPreviousPage: function getCanPreviousPage() {
+        return instance.getState().pagination.pageIndex > 0;
+      },
+      getCanNextPage: function getCanNextPage() {
+        var _instance$getState$pa = instance.getState().pagination,
+            pageIndex = _instance$getState$pa.pageIndex,
+            pageCount = _instance$getState$pa.pageCount,
+            pageSize = _instance$getState$pa.pageSize;
+
+        if (pageCount === -1) {
+          return true;
+        }
 
-        if (!column) {
-          throw new Error();
+        if (pageCount === 0) {
+          return false;
         }
 
-        return (_ref4 = (_column$enableMultiSo = column.enableMultiSort) != null ? _column$enableMultiSo : instance.options.enableMultiSort) != null ? _ref4 : !!column.accessorFn;
+        return pageIndex < Math.ceil(instance.getPrePaginationRows().length / pageSize) - 1;
       },
-      getColumnIsSorted: function getColumnIsSorted(columnId) {
-        var _instance$getState$so;
-
-        var columnSort = (_instance$getState$so = instance.getState().sorting) == null ? void 0 : _instance$getState$so.find(function (d) {
-          return d.id === columnId;
+      previousPage: function previousPage() {
+        return instance.setPageIndex(function (old) {
+          return old - 1;
         });
-        return !columnSort ? false : columnSort.desc ? 'desc' : 'asc';
-      },
-      getColumnSortIndex: function getColumnSortIndex(columnId) {
-        var _instance$getState$so2, _instance$getState$so3;
-
-        return (_instance$getState$so2 = (_instance$getState$so3 = instance.getState().sorting) == null ? void 0 : _instance$getState$so3.findIndex(function (d) {
-          return d.id === columnId;
-        })) != null ? _instance$getState$so2 : -1;
-      },
-      resetSorting: function resetSorting() {
-        var _instance$options$ini, _instance$options, _instance$options$ini2;
-
-        instance.setSorting((_instance$options$ini = (_instance$options = instance.options) == null ? void 0 : (_instance$options$ini2 = _instance$options.initialState) == null ? void 0 : _instance$options$ini2.sorting) != null ? _instance$options$ini : []);
       },
-      getToggleSortingProps: function getToggleSortingProps(columnId, userProps) {
-        var column = instance.getColumn(columnId);
-
-        if (!column) {
-          throw new Error();
-        }
-
-        var canSort = column.getCanSort();
-        var initialProps = {
-          title: canSort ? 'Toggle Sorting' : undefined,
-          onClick: canSort ? function (e) {
-            e.persist();
-            column.toggleSorting == null ? void 0 : column.toggleSorting(undefined, column.getCanMultiSort() ? instance.options.isMultiSortEvent == null ? void 0 : instance.options.isMultiSortEvent(e) : false);
-          } : undefined
-        };
-        return propGetter(initialProps, userProps);
+      nextPage: function nextPage() {
+        return instance.setPageIndex(function (old) {
+          return old + 1;
+        });
       },
-      getSortedRowModel: memo(function () {
-        return [instance.getState().sorting, instance.getGlobalFilteredRowModel(), instance.options.sortRowsFn];
-      }, function (sorting, rowModel, sortingFn) {
-        if (!sortingFn || !(sorting != null && sorting.length)) {
+      getPaginationRowModel: memo(function () {
+        return [instance.getState().pagination, instance.getExpandedRowModel(), instance.options.paginateRowsFn];
+      }, function (_pagination, rowModel, paginateRowsFn) {
+        if (!paginateRowsFn || !rowModel.rows.length) {
           return rowModel;
         }
 
-        if (instance.options.debug) console.info('Sorting...');
-        return sortingFn(instance, sorting, rowModel);
-      }, 'getSortedRowModel', instance.options.debug),
-      getPreSortedRows: function getPreSortedRows() {
-        return instance.getGlobalFilteredRowModel().rows;
+        if (instance.options.debug) console.info('Paginating...');
+        return paginateRowsFn(instance, rowModel);
+      }, {
+        key: 'getPaginationRowModel',
+        debug: instance.options.debug
+      }),
+      getPrePaginationRows: function getPrePaginationRows() {
+        return instance.getExpandedRowModel().rows;
       },
-      getPreSortedFlatRows: function getPreSortedFlatRows() {
-        return instance.getGlobalFilteredRowModel().flatRows;
+      getPrePaginationFlatRows: function getPrePaginationFlatRows() {
+        return instance.getExpandedRowModel().flatRows;
       },
-      getPreSortedRowsById: function getPreSortedRowsById() {
-        return instance.getGlobalFilteredRowModel().rowsById;
+      getPrePaginationRowsById: function getPrePaginationRowsById() {
+        return instance.getExpandedRowModel().rowsById;
       },
-      getSortedRows: function getSortedRows() {
-        return instance.getSortedRowModel().rows;
+      getPaginationRows: function getPaginationRows() {
+        return instance.getPaginationRowModel().rows;
       },
-      getSortedFlatRows: function getSortedFlatRows() {
-        return instance.getSortedRowModel().flatRows;
+      getPaginationFlatRows: function getPaginationFlatRows() {
+        return instance.getPaginationRowModel().flatRows;
       },
-      getSortedRowsById: function getSortedRowsById() {
-        return instance.getSortedRowModel().rowsById;
+      getPaginationRowsById: function getPaginationRowsById() {
+        return instance.getPaginationRowModel().rowsById;
       }
     };
   }
 
+  var Pagination = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState$1,
+    getDefaultOptions: getDefaultOptions$1,
+    getInstance: getInstance$1
+  });
+
   //
   function getInitialState() {
     return {
-      expanded: {}
+      rowSelection: {}
     };
   }
   function getDefaultOptions(instance) {
     return {
-      onExpandedChange: makeStateUpdater('expanded', instance),
-      autoResetExpanded: true,
-      getIsRowExpanded: function getIsRowExpanded(row) {
-        return !!(row == null ? void 0 : row.original).expanded;
-      },
-      expandSubRows: true,
-      paginateExpandedRows: true
+      onRowSelectionChange: makeStateUpdater('rowSelection', instance),
+      autoResetRowSelection: true,
+      enableRowSelection: true,
+      enableMultiRowSelection: true,
+      enableSubRowSelection: true // enableGroupingRowSelection: false,
+      // isAdditiveSelectEvent: (e: MouseEvent | TouchEvent) => !!e.metaKey,
+      // isInclusiveSelectEvent: (e: MouseEvent | TouchEvent) => !!e.shiftKey,
+
     };
   }
   function getInstance(instance) {
+    var registered = false; // const pageRows = instance.getPageRows()
+
     return {
-      setExpanded: function setExpanded(updater) {
-        return instance.options.onExpandedChange == null ? void 0 : instance.options.onExpandedChange(updater, functionalUpdate(updater, instance.getState().expanded));
-      },
-      toggleRowExpanded: function toggleRowExpanded(rowId, expanded) {
-        if (!rowId) return;
-        instance.setExpanded(function (old) {
-          var _old, _expanded;
+      _notifyRowSelectionReset: function _notifyRowSelectionReset() {
+        if (!registered) {
+          registered = true;
+          return;
+        }
 
-          if (old === void 0) {
-            old = {};
-          }
+        if (instance.options.autoResetAll === false) {
+          return;
+        }
 
-          var exists = old === true ? true : !!((_old = old) != null && _old[rowId]);
-          var oldExpanded = {};
+        if (instance.options.autoResetAll === true || instance.options.autoResetRowSelection) {
+          instance.resetRowSelection();
+        }
+      },
+      setRowSelection: function setRowSelection(updater) {
+        return instance.options.onRowSelectionChange == null ? void 0 : instance.options.onRowSelectionChange(updater, functionalUpdate(updater, instance.getState().rowSelection));
+      },
+      resetRowSelection: function resetRowSelection() {
+        var _getInitialState$rowS;
 
-          if (old === true) {
-            Object.keys(instance.getRowsById()).forEach(function (rowId) {
-              oldExpanded[rowId] = true;
+        return instance.setRowSelection((_getInitialState$rowS = getInitialState().rowSelection) != null ? _getInitialState$rowS : {});
+      },
+      toggleAllRowsSelected: function toggleAllRowsSelected(value) {
+        instance.setRowSelection(function (old) {
+          value = typeof value !== 'undefined' ? value : !instance.getIsAllRowsSelected(); // Only remove/add the rows that are visible on the screen
+          //  Leave all the other rows that are selected alone.
+
+          var rowSelection = Object.assign({}, old);
+          var preGroupedFlatRows = instance.getPreGroupedFlatRows(); // We don't use `mutateRowIsSelected` here for performance reasons.
+          // All of the rows are flat already, so it wouldn't be worth it
+
+          if (value) {
+            preGroupedFlatRows.forEach(function (row) {
+              rowSelection[row.id] = true;
             });
           } else {
-            oldExpanded = old;
+            preGroupedFlatRows.forEach(function (row) {
+              delete rowSelection[row.id];
+            });
           }
 
-          expanded = (_expanded = expanded) != null ? _expanded : !exists;
-
-          if (!exists && expanded) {
-            var _extends2;
+          return rowSelection;
+        });
+      },
+      toggleAllPageRowsSelected: function toggleAllPageRowsSelected(value) {
+        return instance.setRowSelection(function (old) {
+          typeof value !== 'undefined' ? value : !instance.getIsAllPageRowsSelected();
 
-            return _extends({}, oldExpanded, (_extends2 = {}, _extends2[rowId] = true, _extends2));
-          }
+          var rowSelection = _extends({}, old);
 
-          if (exists && !expanded) {
-            var _oldExpanded = oldExpanded;
-                _oldExpanded[rowId];
-                var rest = _objectWithoutPropertiesLoose(_oldExpanded, [rowId].map(_toPropertyKey));
+          instance.getRows().forEach(function (row) {
+            mutateRowIsSelected(rowSelection, row.id, value, instance);
+          });
+          return rowSelection;
+        });
+      },
+      toggleRowSelected: function toggleRowSelected(rowId, value) {
+        var row = instance.getRow(rowId);
+        var isSelected = row.getIsSelected();
+        instance.setRowSelection(function (old) {
+          value = typeof value !== 'undefined' ? value : !isSelected;
 
-            return rest;
+          if (isSelected === value) {
+            return old;
           }
 
-          return old;
+          var selectedRowIds = _extends({}, old);
+
+          mutateRowIsSelected(selectedRowIds, rowId, value, instance);
+          return selectedRowIds;
         });
       },
-      toggleAllRowsExpanded: function toggleAllRowsExpanded(expanded) {
-        if (expanded != null ? expanded : !instance.getIsAllRowsExpanded()) {
-          instance.setExpanded(true);
-        } else {
-          instance.setExpanded({});
+      // addRowSelectionRange: rowId => {
+      //   const {
+      //     rows,
+      //     rowsById,
+      //     options: { selectGroupingRows, selectSubRows },
+      //   } = instance
+      //   const findSelectedRow = (rows: Row[]) => {
+      //     let found
+      //     rows.find(d => {
+      //       if (d.getIsSelected()) {
+      //         found = d
+      //         return true
+      //       }
+      //       const subFound = findSelectedRow(d.subRows || [])
+      //       if (subFound) {
+      //         found = subFound
+      //         return true
+      //       }
+      //       return false
+      //     })
+      //     return found
+      //   }
+      //   const firstRow = findSelectedRow(rows) || rows[0]
+      //   const lastRow = rowsById[rowId]
+      //   let include = false
+      //   const selectedRowIds = {}
+      //   const addRow = (row: Row) => {
+      //     mutateRowIsSelected(selectedRowIds, row.id, true, {
+      //       rowsById,
+      //       selectGroupingRows: selectGroupingRows!,
+      //       selectSubRows: selectSubRows!,
+      //     })
+      //   }
+      //   instance.rows.forEach(row => {
+      //     const isFirstRow = row.id === firstRow.id
+      //     const isLastRow = row.id === lastRow.id
+      //     if (isFirstRow || isLastRow) {
+      //       if (!include) {
+      //         include = true
+      //       } else if (include) {
+      //         addRow(row)
+      //         include = false
+      //       }
+      //     }
+      //     if (include) {
+      //       addRow(row)
+      //     }
+      //   })
+      //   instance.setRowSelection(selectedRowIds)
+      // },
+      getSelectedRowModel: memo(function () {
+        return [instance.getState().rowSelection, instance.getCoreRowModel()];
+      }, function (rowSelection, rowModel) {
+        if (!Object.keys(rowSelection).length) {
+          return {
+            rows: [],
+            flatRows: [],
+            rowsById: {}
+          };
+        }
+
+        if (instance.options.debug) console.info('Selecting...');
+        return selectRowsFn(instance, rowModel);
+      }, {
+        key: 'getSelectedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyExpandedReset();
         }
+      }),
+      getSelectedRows: function getSelectedRows() {
+        return instance.getSelectedRowModel().rows;
       },
-      resetExpanded: function resetExpanded() {
-        var _instance$options$ini, _instance$options, _instance$options$ini2;
+      getSelectedFlatRows: function getSelectedFlatRows() {
+        return instance.getSelectedRowModel().flatRows;
+      },
+      getSelectedRowsById: function getSelectedRowsById() {
+        return instance.getSelectedRowModel().rowsById;
+      },
+      getFilteredSelectedRowModel: memo(function () {
+        return [instance.getState().rowSelection, instance.getGlobalFilteredRowModel()];
+      }, function (rowSelection, rowModel) {
+        if (!Object.keys(rowSelection).length) {
+          return {
+            rows: [],
+            flatRows: [],
+            rowsById: {}
+          };
+        }
 
-        instance.setExpanded((_instance$options$ini = (_instance$options = instance.options) == null ? void 0 : (_instance$options$ini2 = _instance$options.initialState) == null ? void 0 : _instance$options$ini2.expanded) != null ? _instance$options$ini : {});
+        if (instance.options.debug) console.info('Selecting...');
+        return selectRowsFn(instance, rowModel);
+      }, {
+        key: 'getFilteredSelectedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyExpandedReset();
+        }
+      }),
+      getFilteredSelectedRows: function getFilteredSelectedRows() {
+        return instance.getFilteredSelectedRowModel().rows;
       },
-      getIsRowExpanded: function getIsRowExpanded(rowId) {
-        var _instance$options$get;
+      getFilteredSelectedFlatRows: function getFilteredSelectedFlatRows() {
+        return instance.getFilteredSelectedRowModel().flatRows;
+      },
+      getFilteredSelectedRowsById: function getFilteredSelectedRowsById() {
+        return instance.getFilteredSelectedRowModel().rowsById;
+      },
+      getGroupedSelectedRowModel: memo(function () {
+        return [instance.getState().rowSelection, instance.getGroupedRowModel()];
+      }, function (rowSelection, rowModel) {
+        if (!Object.keys(rowSelection).length) {
+          return {
+            rows: [],
+            flatRows: [],
+            rowsById: {}
+          };
+        }
+
+        if (instance.options.debug) console.info('Selecting...');
+        return selectRowsFn(instance, rowModel);
+      }, {
+        key: 'getGroupedSelectedRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          return instance._notifyExpandedReset();
+        }
+      }),
+      getGroupedSelectedRows: function getGroupedSelectedRows() {
+        return instance.getGroupedSelectedRowModel().rows;
+      },
+      getGroupedSelectedFlatRows: function getGroupedSelectedFlatRows() {
+        return instance.getGroupedSelectedRowModel().flatRows;
+      },
+      getGroupedSelectedRowsById: function getGroupedSelectedRowsById() {
+        return instance.getGroupedSelectedRowModel().rowsById;
+      },
+      ///
+      getRowIsSelected: function getRowIsSelected(rowId) {
+        var _instance$getState = instance.getState(),
+            rowSelection = _instance$getState.rowSelection;
 
         var row = instance.getRow(rowId);
 
         if (!row) {
-          {
-            console.warn("[ReactTable] getIsRowExpanded: no row found with id " + rowId);
-          }
-
           throw new Error();
         }
 
-        var expanded = instance.getState().expanded;
-        return !!((_instance$options$get = instance.options.getIsRowExpanded == null ? void 0 : instance.options.getIsRowExpanded(row)) != null ? _instance$options$get : expanded || (expanded == null ? void 0 : expanded[rowId]));
+        return isRowSelected(row, rowSelection) === true;
       },
-      getRowCanExpand: function getRowCanExpand(rowId) {
-        var _ref, _ref2, _instance$options$get2, _row$subRows;
+      getRowIsSomeSelected: function getRowIsSomeSelected(rowId) {
+        var _instance$getState2 = instance.getState(),
+            rowSelection = _instance$getState2.rowSelection;
 
         var row = instance.getRow(rowId);
 
         if (!row) {
-          {
-            console.warn("[ReactTable] getRowCanExpand: no row found with id " + rowId);
-          }
-
           throw new Error();
         }
 
-        return (_ref = (_ref2 = (_instance$options$get2 = instance.options.getRowCanExpand == null ? void 0 : instance.options.getRowCanExpand(row)) != null ? _instance$options$get2 : instance.options.enableExpanded) != null ? _ref2 : instance.options.defaultCanExpand) != null ? _ref : !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+        return isRowSelected(row, rowSelection) === 'some';
       },
-      getToggleExpandedProps: function getToggleExpandedProps(rowId, userProps) {
+      getRowCanSelect: function getRowCanSelect(rowId) {
+        var _instance$options$ena;
+
         var row = instance.getRow(rowId);
 
         if (!row) {
-          return;
+          throw new Error();
         }
 
-        var canExpand = instance.getRowCanExpand(rowId);
-        var initialProps = {
-          title: canExpand ? 'Toggle Expanded' : undefined,
-          onClick: canExpand ? function (e) {
-            e.persist();
-            instance.toggleRowExpanded(rowId);
-          } : undefined
-        };
-        return propGetter(initialProps, userProps);
+        if (typeof instance.options.enableRowSelection === 'function') {
+          return instance.options.enableRowSelection(row);
+        }
+
+        return (_instance$options$ena = instance.options.enableRowSelection) != null ? _instance$options$ena : true;
       },
-      getToggleAllRowsExpandedProps: function getToggleAllRowsExpandedProps(userProps) {
-        var initialProps = {
-          title: 'Toggle All Expanded',
-          onClick: function onClick(e) {
-            e.persist();
-            instance.toggleAllRowsExpanded();
-          }
-        };
-        return propGetter(initialProps, userProps);
+      getRowCanSelectSubRows: function getRowCanSelectSubRows(rowId) {
+        var _instance$options$ena2;
+
+        var row = instance.getRow(rowId);
+
+        if (!row) {
+          throw new Error();
+        }
+
+        if (typeof instance.options.enableSubRowSelection === 'function') {
+          return instance.options.enableSubRowSelection(row);
+        }
+
+        return (_instance$options$ena2 = instance.options.enableSubRowSelection) != null ? _instance$options$ena2 : true;
       },
-      getIsAllRowsExpanded: function getIsAllRowsExpanded() {
-        var expanded = instance.getState().expanded; // If expanded is true, save some cycles and return true
+      getRowCanMultiSelect: function getRowCanMultiSelect(rowId) {
+        var _instance$options$ena3;
 
-        if (expanded === true) {
-          return true;
-        } // If any row is not expanded, return false
+        var row = instance.getRow(rowId);
 
+        if (!row) {
+          throw new Error();
+        }
 
-        if (Object.keys(instance.getRowsById()).some(function (id) {
-          return !instance.getIsRowExpanded(id);
-        })) {
-          return false;
-        } // They must all be expanded :shrug:
+        if (typeof instance.options.enableMultiRowSelection === 'function') {
+          return instance.options.enableMultiRowSelection(row);
+        }
 
+        return (_instance$options$ena3 = instance.options.enableMultiRowSelection) != null ? _instance$options$ena3 : true;
+      },
+      // getGroupingRowCanSelect: rowId => {
+      //   const row = instance.getRow(rowId)
+      //   if (!row) {
+      //     throw new Error()
+      //   }
+      //   if (typeof instance.options.enableGroupingRowSelection === 'function') {
+      //     return instance.options.enableGroupingRowSelection(row)
+      //   }
+      //   return instance.options.enableGroupingRowSelection ?? false
+      // },
+      getIsAllRowsSelected: function getIsAllRowsSelected() {
+        var preFilteredFlatRows = instance.getPreGlobalFilteredFlatRows();
+
+        var _instance$getState3 = instance.getState(),
+            rowSelection = _instance$getState3.rowSelection;
+
+        var isAllRowsSelected = Boolean(preFilteredFlatRows.length && Object.keys(rowSelection).length);
+
+        if (isAllRowsSelected) {
+          if (preFilteredFlatRows.some(function (row) {
+            return !rowSelection[row.id];
+          })) {
+            isAllRowsSelected = false;
+          }
+        }
 
-        return true;
-      },
-      getExpandedDepth: function getExpandedDepth() {
-        var maxDepth = 0;
-        var rowIds = instance.getState().expanded === true ? Object.keys(instance.getRowsById()) : Object.keys(instance.getState().expanded);
-        rowIds.forEach(function (id) {
-          var splitId = id.split('.');
-          maxDepth = Math.max(maxDepth, splitId.length);
-        });
-        return maxDepth;
+        return isAllRowsSelected;
       },
-      getExpandedRowModel: memo(function () {
-        return [instance.getState().expanded, instance.getGroupedRowModel(), instance.options.expandRowsFn, instance.options.paginateExpandedRows];
-      }, function (expanded, rowModel, expandRowsFn, paginateExpandedRows) {
-        if (!expandRowsFn || // Do not expand if rows are not included in pagination
-        !paginateExpandedRows || !Object.keys(expanded != null ? expanded : {}).length) {
-          return rowModel;
+      getIsAllPageRowsSelected: function getIsAllPageRowsSelected() {
+        var paginationFlatRows = instance.getPaginationFlatRows();
+
+        var _instance$getState4 = instance.getState(),
+            rowSelection = _instance$getState4.rowSelection;
+
+        var isAllPageRowsSelected = !!paginationFlatRows.length;
+
+        if (isAllPageRowsSelected && paginationFlatRows.some(function (row) {
+          return !rowSelection[row.id];
+        })) {
+          isAllPageRowsSelected = false;
         }
 
-        if (instance.options.debug) console.info('Expanding...');
-        return expandRowsFn(instance, expanded, rowModel);
-      }, 'getExpandedRowModel', instance.options.debug),
-      getPreExpandedRows: function getPreExpandedRows() {
-        return instance.getGroupedRowModel().rows;
+        return isAllPageRowsSelected;
       },
-      getPreExpandedFlatRows: function getPreExpandedFlatRows() {
-        return instance.getGroupedRowModel().flatRows;
+      getIsSomeRowsSelected: function getIsSomeRowsSelected() {
+        var _instance$getState$ro;
+
+        return !instance.getIsAllRowsSelected() && !!Object.keys((_instance$getState$ro = instance.getState().rowSelection) != null ? _instance$getState$ro : {}).length;
       },
-      getPreExpandedRowsById: function getPreExpandedRowsById() {
-        return instance.getGroupedRowModel().rowsById;
+      getIsSomePageRowsSelected: function getIsSomePageRowsSelected() {
+        var paginationFlatRows = instance.getPaginationFlatRows();
+        return instance.getIsAllPageRowsSelected() ? false : !!(paginationFlatRows != null && paginationFlatRows.length);
       },
-      getExpandedRows: function getExpandedRows() {
-        return instance.getExpandedRowModel().rows;
+      getToggleRowSelectedProps: function getToggleRowSelectedProps(rowId, userProps) {
+        var row = instance.getRow(rowId);
+        var isSelected = row.getIsSelected();
+        var isSomeSelected = row.getIsSomeSelected();
+        var canSelect = row.getCanSelect();
+        var initialProps = {
+          onChange: canSelect ? function (e) {
+            row.toggleSelected(e.target.checked);
+          } : undefined,
+          checked: isSelected,
+          title: 'Toggle Row Selected',
+          indeterminate: isSomeSelected // onChange: forInput
+          //   ? (e: Event) => e.stopPropagation()
+          //   : (e: Event) => {
+          //       if (instance.options.isAdditiveSelectEvent(e)) {
+          //         row.toggleSelected()
+          //       } else if (instance.options.isInclusiveSelectEvent(e)) {
+          //         instance.addRowSelectionRange(row.id)
+          //       } else {
+          //         instance.setRowSelection({})
+          //         row.toggleSelected()
+          //       }
+          //       if (props.onClick) props.onClick(e)
+          //     },
+
+        };
+        return propGetter(initialProps, userProps);
       },
-      getExpandedFlatRows: function getExpandedFlatRows() {
-        return instance.getExpandedRowModel().flatRows;
+      getToggleAllRowsSelectedProps: function getToggleAllRowsSelectedProps(userProps) {
+        var isSomeRowsSelected = instance.getIsSomeRowsSelected();
+        var isAllRowsSelected = instance.getIsAllRowsSelected();
+        var initialProps = {
+          onChange: function onChange(e) {
+            instance.toggleAllRowsSelected(e.target.checked);
+          },
+          checked: isAllRowsSelected,
+          title: 'Toggle All Rows Selected',
+          indeterminate: isSomeRowsSelected
+        };
+        return propGetter(initialProps, userProps);
       },
-      getExpandedRowsById: function getExpandedRowsById() {
-        return instance.getExpandedRowModel().rowsById;
+      getToggleAllPageRowsSelectedProps: function getToggleAllPageRowsSelectedProps(userProps) {
+        var isSomePageRowsSelected = instance.getIsSomePageRowsSelected();
+        var isAllPageRowsSelected = instance.getIsAllPageRowsSelected();
+        var initialProps = {
+          onChange: function onChange(e) {
+            instance.toggleAllPageRowsSelected(e.target.checked);
+          },
+          checked: isAllPageRowsSelected,
+          title: 'Toggle All Current Page Rows Selected',
+          indeterminate: isSomePageRowsSelected
+        };
+        return propGetter(initialProps, userProps);
       }
     };
   }
   function createRow(row, instance) {
     return {
-      toggleExpanded: function toggleExpanded(expanded) {
-        return void instance.toggleRowExpanded(row.id, expanded);
+      getIsSelected: function getIsSelected() {
+        return instance.getRowIsSelected(row.id);
       },
-      getIsExpanded: function getIsExpanded() {
-        return instance.getIsRowExpanded(row.id);
+      getIsSomeSelected: function getIsSomeSelected() {
+        return instance.getRowIsSomeSelected(row.id);
       },
-      getCanExpand: function getCanExpand() {
-        return row.subRows && !!row.subRows.length;
+      toggleSelected: function toggleSelected(value) {
+        return instance.toggleRowSelected(row.id, value);
       },
-      getToggleExpandedProps: function getToggleExpandedProps(userProps) {
-        var initialProps = {
-          title: 'Toggle Row Expanded',
-          onClick: function onClick(e) {
-            e.stopPropagation();
-            instance.toggleRowExpanded(row.id);
-          }
-        };
-        return propGetter(initialProps, userProps);
+      getToggleSelectedProps: function getToggleSelectedProps(userProps) {
+        return instance.getToggleRowSelectedProps(row.id, userProps);
+      },
+      getCanMultiSelect: function getCanMultiSelect() {
+        return instance.getRowCanMultiSelect(row.id);
+      },
+      getCanSelect: function getCanSelect() {
+        return instance.getRowCanSelect(row.id);
       }
     };
   }
 
+  var mutateRowIsSelected = function mutateRowIsSelected(selectedRowIds, id, value, instance) {
+    var _row$subRows;
+
+    var row = instance.getRow(id);
+    row.getIsGrouped(); // if ( // TODO: enforce grouping row selection rules
+    //   !isGrouped ||
+    //   (isGrouped && instance.options.enableGroupingRowSelection)
+    // ) {
+
+    if (value) {
+      selectedRowIds[id] = true;
+    } else {
+      delete selectedRowIds[id];
+    } // }
+
+
+    if ((_row$subRows = row.subRows) != null && _row$subRows.length && instance.getRowCanSelectSubRows(row.id)) {
+      row.subRows.forEach(function (row) {
+        return mutateRowIsSelected(selectedRowIds, row.id, value, instance);
+      });
+    }
+  };
+
+  function selectRowsFn(instance, rowModel) {
+    var rowSelection = instance.getState().rowSelection;
+    var newSelectedFlatRows = [];
+    var newSelectedRowsById = {}; // Filters top level and nested rows
+
+    var recurseRows = function recurseRows(rows, depth) {
+
+      return rows.map(function (row) {
+        var _row$subRows2;
+
+        var isSelected = isRowSelected(row, rowSelection) === true;
+
+        if (isSelected) {
+          newSelectedFlatRows.push(row);
+          newSelectedRowsById[row.id] = row;
+        }
+
+        if ((_row$subRows2 = row.subRows) != null && _row$subRows2.length) {
+          row = _extends({}, row, {
+            subRows: recurseRows(row.subRows)
+          });
+        }
+
+        if (isSelected) {
+          return row;
+        }
+      }).filter(Boolean);
+    };
+
+    return {
+      rows: recurseRows(rowModel.rows),
+      flatRows: newSelectedFlatRows,
+      rowsById: newSelectedRowsById
+    };
+  }
+  function isRowSelected(row, selection, instance) {
+    if (selection[row.id]) {
+      return true;
+    }
+
+    if (row.subRows && row.subRows.length) {
+      var allChildrenSelected = true;
+      var someSelected = false;
+      row.subRows.forEach(function (subRow) {
+        // Bail out early if we know both of these
+        if (someSelected && !allChildrenSelected) {
+          return;
+        }
+
+        if (isRowSelected(subRow, selection)) {
+          someSelected = true;
+        } else {
+          allChildrenSelected = false;
+        }
+      });
+      return allChildrenSelected ? true : someSelected ? 'some' : false;
+    }
+
+    return false;
+  }
+
+  var RowSelection = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getInitialState: getInitialState,
+    getDefaultOptions: getDefaultOptions,
+    getInstance: getInstance,
+    createRow: createRow,
+    selectRowsFn: selectRowsFn,
+    isRowSelected: isRowSelected
+  });
+
+  var features = [Visibility, Ordering, Pinning, Headers, Filters, Sorting, Grouping, Expanding, ColumnSizing, Pagination, RowSelection];
   function createTableInstance(options, rerender) {
     var _options$initialState;
 
@@ -3198,9 +4218,9 @@
     }
 
     var instance = {};
-
-    var defaultOptions = _extends({}, getDefaultOptions$7(instance), getDefaultOptions$5(instance), getDefaultOptions$4(instance), getDefaultOptions$2(instance), getDefaultOptions$1(instance), getDefaultOptions$6(instance), getDefaultOptions(instance), getDefaultOptions$3(instance));
-
+    var defaultOptions = features.reduce(function (obj, feature) {
+      return Object.assign(obj, feature.getDefaultOptions == null ? void 0 : feature.getDefaultOptions(instance));
+    }, {});
     var defaultState = {};
 
     var buildOptions = function buildOptions(options) {
@@ -3211,9 +4231,13 @@
 
     instance.options = buildOptions(options);
 
-    var initialState = _extends({}, getInitialState$7(), getInitialState$5(), getInitialState$4(), getInitialState$2(), getInitialState$1(), getInitialState$6(), getInitialState(), getInitialState$3(), (_options$initialState = options.initialState) != null ? _options$initialState : {});
+    var initialState = _extends({}, features.reduce(function (obj, feature) {
+      return Object.assign(obj, feature.getInitialState == null ? void 0 : feature.getInitialState());
+    }, {}), (_options$initialState = options.initialState) != null ? _options$initialState : {});
 
-    var finalInstance = _extends({}, instance, getInstance$8(instance), getInstance$6(instance), getInstance$5(instance), getInstance$3(instance), getInstance$2(instance), getInstance$1(instance), getInstance$7(instance), getInstance(instance), getInstance$4(instance), {
+    var finalInstance = _extends({}, instance, features.reduce(function (obj, feature) {
+      return Object.assign(obj, feature.getInstance == null ? void 0 : feature.getInstance(instance));
+    }, {}), {
       rerender: rerender,
       initialState: initialState,
       internalState: initialState,
@@ -3227,15 +4251,18 @@
         return "" + (parent ? [parent.id, index].join('.') : index);
       },
       getState: function getState() {
-        return _extends({}, instance.internalState, instance.options.state);
+        var state = _extends({}, instance.internalState, instance.options.state);
+
+        return state;
       },
       setState: function setState(updater, shouldRerender) {
         if (shouldRerender === void 0) {
           shouldRerender = true;
         }
 
-        var newState = functionalUpdate(updater, instance.internalState);
         var onStateChange = instance.options.onStateChange;
+        var internalState = instance.internalState;
+        var newState = functionalUpdate(updater, internalState);
         instance.internalState = newState;
 
         if (onStateChange) {
@@ -3265,12 +4292,17 @@
                 value = _ref$value === void 0 ? '' : _ref$value;
             return typeof value === 'boolean' ? value.toString() : value;
           }
-        }, getDefaultColumn$3(), getDefaultColumn$1(), getDefaultColumn(), getDefaultColumn$2(), defaultColumn);
-      }, 'getDefaultColumn', instance.options.debug),
+        }, features.reduce(function (obj, feature) {
+          return Object.assign(obj, feature.getDefaultColumn == null ? void 0 : feature.getDefaultColumn());
+        }, {}), defaultColumn);
+      }, {
+        debug: instance.options.debug,
+        key: 'getDefaultColumn'
+      }),
       getColumnDefs: function getColumnDefs() {
         return instance.options.columns;
       },
-      createColumn: function createColumn$6(columnDef, depth, parent) {
+      createColumn: function createColumn(columnDef, depth, parent) {
         var _ref2, _columnDef$id;
 
         var defaultColumn = instance.getDefaultColumn();
@@ -3309,7 +4341,10 @@
             return [column].concat((_column$columns = column.columns) == null ? void 0 : _column$columns.flatMap(function (d) {
               return d.getFlatColumns();
             }));
-          }, 'column.getFlatColumns', instance.options.debug),
+          }, {
+            key: 'column.getFlatColumns',
+            debug: instance.options.debug
+          }),
           getLeafColumns: memo(function () {
             return [instance.getOrderColumnsFn()];
           }, function (orderColumns) {
@@ -3323,10 +4358,15 @@
             }
 
             return [column];
-          }, 'column.getLeafColumns', instance.options.debug)
+          }, {
+            key: 'column.getLeafColumns',
+            debug: instance.options.debug
+          })
         });
 
-        column = Object.assign(column, createColumn$5(column, instance), createColumn$3(column, instance), createColumn$1(column, instance), createColumn(column, instance), createColumn$4(column, instance), createColumn$2(column, instance)); // Yes, we have to convert instance to uknown, because we know more than the compiler here.
+        column = features.reduce(function (obj, feature) {
+          return Object.assign(obj, feature.createColumn == null ? void 0 : feature.createColumn(column, instance));
+        }, column); // Yes, we have to convert instance to uknown, because we know more than the compiler here.
 
         return column;
       },
@@ -3348,14 +4388,20 @@
         };
 
         return recurseColumns(columnDefs);
-      }, 'getAllColumns', instance.options.debug),
+      }, {
+        key: 'getAllColumns',
+        debug: instance.options.debug
+      }),
       getAllFlatColumns: memo(function () {
         return [instance.getAllColumns()];
       }, function (allColumns) {
         return allColumns.flatMap(function (column) {
           return column.getFlatColumns();
         });
-      }, 'getAllFlatColumns', instance.options.debug),
+      }, {
+        key: 'getAllFlatColumns',
+        debug: instance.options.debug
+      }),
       getAllFlatColumnsById: memo(function () {
         return [instance.getAllFlatColumns()];
       }, function (flatColumns) {
@@ -3363,7 +4409,10 @@
           acc[column.id] = column;
           return acc;
         }, {});
-      }, 'getAllFlatColumnsById', instance.options.debug),
+      }, {
+        key: 'getAllFlatColumnsById',
+        debug: instance.options.debug
+      }),
       getAllLeafColumns: memo(function () {
         return [instance.getAllColumns(), instance.getOrderColumnsFn()];
       }, function (allColumns, orderColumns) {
@@ -3371,7 +4420,10 @@
           return column.getLeafColumns();
         });
         return orderColumns(leafColumns);
-      }, 'getAllLeafColumns', instance.options.debug),
+      }, {
+        key: 'getAllLeafColumns',
+        debug: instance.options.debug
+      }),
       getColumn: function getColumn(columnId) {
         var column = instance.getAllFlatColumnsById()[columnId];
 
@@ -3397,7 +4449,7 @@
         var columnSize = instance.getState().columnSizing[column.id];
         return Math.min(Math.max((_column$minWidth = column.minWidth) != null ? _column$minWidth : defaultColumnSizing.minWidth, (_ref3 = columnSize != null ? columnSize : column.width) != null ? _ref3 : defaultColumnSizing.width), (_column$maxWidth = column.maxWidth) != null ? _column$maxWidth : defaultColumnSizing.maxWidth);
       },
-      createCell: function createCell$1(row, column, value) {
+      createCell: function createCell(row, column, value) {
         var cell = {
           id: row.id + "_" + column.id,
           rowId: row.id,
@@ -3410,16 +4462,20 @@
           },
           renderCell: function renderCell() {
             return flexRender(column.cell, {
+              instance: instance,
               column: column,
+              row: row,
               cell: cell,
               value: value
             });
           }
         };
-        Object.assign(cell, _extends({}, createCell(cell, column, row)));
+        features.forEach(function (feature) {
+          Object.assign(cell, feature.createCell == null ? void 0 : feature.createCell(cell, column, row, instance));
+        }, {});
         return cell;
       },
-      createRow: function createRow$3(id, original, rowIndex, depth, values) {
+      createRow: function createRow(id, original, rowIndex, depth, values) {
         var row = {
           id: id,
           index: rowIndex,
@@ -3440,7 +4496,10 @@
           return leafColumns.map(function (column) {
             return instance.createCell(row, column, row.values[column.id]);
           });
-        }, 'row.getAllCells' , instance.options.debug);
+        }, {
+          key: 'row.getAllCells' ,
+          debug: instance.options.debug
+        });
         row.getAllCellsByColumnId = memo(function () {
           return [row.getAllCells()];
         }, function (allCells) {
@@ -3448,42 +4507,19 @@
             acc[cell.columnId] = cell;
             return acc;
           }, {});
-        }, 'row.getAllCellsByColumnId', instance.options.debug);
-        row = Object.assign(row, createRow$1(row, instance), createRow$2(row, instance), createRow(row, instance));
+        }, {
+          key: 'row.getAllCellsByColumnId',
+          debug: instance.options.debug
+        });
+        features.forEach(function (feature) {
+          Object.assign(row, feature.createRow == null ? void 0 : feature.createRow(row, instance));
+        });
         return row;
       },
       getCoreRowModel: memo(function () {
         return [instance.options.data];
       }, function (data) {
-        if (instance.options.debug) console.info('Accessing...'); // Auto-reset data-dependent states if configured
-
-        if (instance.options.autoResetColumnFilters && // @ts-ignore
-        instance.getRowModelNonFirst) {
-          instance.resetColumnFilters();
-        }
-
-        if (instance.options.autoResetGlobalFilter && // @ts-ignore
-        instance.getRowModelNonFirst) {
-          instance.resetGlobalFilter();
-        }
-
-        if (instance.options.autoResetSorting && // @ts-ignore
-        instance.getRowModelNonFirst) {
-          instance.resetSorting();
-        }
-
-        if (instance.options.autoResetGrouping && // @ts-ignore
-        instance.getRowModelNonFirst) {
-          instance.resetGrouping();
-        }
-
-        if (instance.options.autoResetExpanded && // @ts-ignore
-        instance.getRowModelNonFirst) {
-          instance.resetExpanded();
-        } // @ts-ignore
-
-
-        instance.getRowModelNonFirst = true; // Access the row model using initial columns
+        if (instance.options.debug) console.info('Accessing...'); // Access the row model using initial columns
 
         var rows = [];
         var flatRows = [];
@@ -3551,7 +4587,15 @@
           flatRows: flatRows,
           rowsById: rowsById
         };
-      }, 'getRowModel', instance.options.debug),
+      }, {
+        key: 'getRowModel',
+        debug: instance.options.debug,
+        onChange: function onChange() {
+          instance._notifyRowSelectionReset();
+
+          instance._notifyFiltersReset();
+        }
+      }),
       // The standard
       getCoreRows: function getCoreRows() {
         return instance.getCoreRowModel().rows;
@@ -3565,7 +4609,7 @@
       // The final calls start at the bottom of the model,
       // expanded rows, which then work their way up
       getRowModel: function getRowModel() {
-        return instance.getExpandedRowModel();
+        return instance.getPaginationRowModel();
       },
       getRows: function getRows() {
         return instance.getRowModel().rows;
@@ -3670,7 +4714,13 @@
       }
     });
 
-    return Object.assign(instance, finalInstance);
+    instance = Object.assign(instance, finalInstance); // This won't trigger a rerender yet, but it will force
+    // pagination derivation to run (particularly pageSize detection)
+
+    instance.setPagination(function (d) {
+      return d;
+    });
+    return instance;
   }
 
   function createTable() {
@@ -3690,7 +4740,17 @@
       createColumns: function createColumns(columns) {
         return columns;
       },
-      createColumn: function createColumn(accessor, column) {
+      createDisplayColumn: function createDisplayColumn(column) {
+        return _extends({}, column, {
+          __generated: true
+        });
+      },
+      createGroup: function createGroup(column) {
+        return _extends({}, column, {
+          __generated: true
+        });
+      },
+      createDataColumn: function createDataColumn(accessor, column) {
         column = _extends({}, column, {
           id: column.id
         });
@@ -3714,11 +4774,6 @@
 
         throw new Error('Invalid accessor');
       },
-      createGroup: function createGroup(column) {
-        return _extends({}, column, {
-          __generated: true
-        });
-      },
       useTable: function useTable(options) {
         var instanceRef = React__namespace.useRef(undefined);
         var rerender = React__namespace.useReducer(function () {
@@ -3741,6 +4796,7 @@
   exports.expandRowsFn = expandRowsFn;
   exports.globalFilterRowsFn = globalFilterRowsFn;
   exports.groupRowsFn = groupRowsFn;
+  exports.paginateRowsFn = paginateRowsFn;
   exports.sortRowsFn = sortRowsFn;
 
   Object.defineProperty(exports, '__esModule', { value: true });