@tanstack/react-table 8.13.1 → 8.14.0

package/build/umd/index.development.js

@@ -43,6 +43,63 @@
      *
      * @license MIT
      */
+  // type Person = {
+  //   firstName: string
+  //   lastName: string
+  //   age: number
+  //   visits: number
+  //   status: string
+  //   progress: number
+  //   createdAt: Date
+  //   nested: {
+  //     foo: [
+  //       {
+  //         bar: 'bar'
+  //       }
+  //     ]
+  //     bar: { subBar: boolean }[]
+  //     baz: {
+  //       foo: 'foo'
+  //       bar: {
+  //         baz: 'baz'
+  //       }
+  //     }
+  //   }
+  // }
+
+  // const test: DeepKeys<Person> = 'nested.foo.0.bar'
+  // const test2: DeepKeys<Person> = 'nested.bar'
+
+  // const helper = createColumnHelper<Person>()
+
+  // helper.accessor('nested.foo', {
+  //   cell: info => info.getValue(),
+  // })
+
+  // helper.accessor('nested.foo.0.bar', {
+  //   cell: info => info.getValue(),
+  // })
+
+  // helper.accessor('nested.bar', {
+  //   cell: info => info.getValue(),
+  // })
+
+  function createColumnHelper() {
+    return {
+      accessor: (accessor, column) => {
+        return typeof accessor === 'function' ? {
+          ...column,
+          accessorFn: accessor
+        } : {
+          ...column,
+          accessorKey: accessor
+        };
+      },
+      display: column => column,
+      group: column => column
+    };
+  }
+
   // Is this type a tuple?
 
   // If this type is a tuple, what indices are allowed?
@@ -133,6 +190,32 @@
     };
   }
 
+  function createCell(table, row, column, columnId) {
+    const getRenderValue = () => {
+      var _cell$getValue;
+      return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue;
+    };
+    const cell = {
+      id: `${row.id}_${column.id}`,
+      row,
+      column,
+      getValue: () => row.getValue(columnId),
+      renderValue: getRenderValue,
+      getContext: memo(() => [table, column, row, cell], (table, column, row, cell) => ({
+        table,
+        column,
+        row,
+        cell: cell,
+        getValue: cell.getValue,
+        renderValue: cell.renderValue
+      }), getMemoOptions(table.options, 'debugCells', 'cell.getContext'))
+    };
+    table._features.forEach(feature => {
+      feature.createCell == null || feature.createCell(cell, column, row, table);
+    }, {});
+    return cell;
+  }
+
   function createColumn(table, columnDef, depth, parent) {
     var _ref, _resolvedColumnDef$id;
     const defaultColumn = table._getDefaultColumnDef();
@@ -192,7 +275,7 @@
       feature.createColumn == null || feature.createColumn(column, table);
     }
 
-    // Yes, we have to convert table to uknown, because we know more than the compiler here.
+    // Yes, we have to convert table to unknown, because we know more than the compiler here.
     return column;
   }
 
@@ -449,656 +532,1087 @@
     return headerGroups;
   }
 
-  //
+  const createRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
+    let row = {
+      id,
+      index: rowIndex,
+      original,
+      depth,
+      parentId,
+      _valuesCache: {},
+      _uniqueValuesCache: {},
+      getValue: columnId => {
+        if (row._valuesCache.hasOwnProperty(columnId)) {
+          return row._valuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.accessorFn)) {
+          return undefined;
+        }
+        row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex);
+        return row._valuesCache[columnId];
+      },
+      getUniqueValues: columnId => {
+        if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
+          return row._uniqueValuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.accessorFn)) {
+          return undefined;
+        }
+        if (!column.columnDef.getUniqueValues) {
+          row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
+          return row._uniqueValuesCache[columnId];
+        }
+        row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex);
+        return row._uniqueValuesCache[columnId];
+      },
+      renderValue: columnId => {
+        var _row$getValue;
+        return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
+      },
+      subRows: subRows != null ? subRows : [],
+      getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
+      getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : undefined,
+      getParentRows: () => {
+        let parentRows = [];
+        let currentRow = row;
+        while (true) {
+          const parentRow = currentRow.getParentRow();
+          if (!parentRow) break;
+          parentRows.push(parentRow);
+          currentRow = parentRow;
+        }
+        return parentRows.reverse();
+      },
+      getAllCells: memo(() => [table.getAllLeafColumns()], leafColumns => {
+        return leafColumns.map(column => {
+          return createCell(table, row, column, column.id);
+        });
+      }, getMemoOptions(table.options, 'debugRows', 'getAllCells')),
+      _getAllCellsByColumnId: memo(() => [row.getAllCells()], allCells => {
+        return allCells.reduce((acc, cell) => {
+          acc[cell.column.id] = cell;
+          return acc;
+        }, {});
+      }, getMemoOptions(table.options, 'debugRows', 'getAllCellsByColumnId'))
+    };
+    for (let i = 0; i < table._features.length; i++) {
+      const feature = table._features[i];
+      feature == null || feature.createRow == null || feature.createRow(row, table);
+    }
+    return row;
+  };
 
   //
 
-  const defaultColumnSizing = {
-    size: 150,
-    minSize: 20,
-    maxSize: Number.MAX_SAFE_INTEGER
-  };
-  const getDefaultColumnSizingInfoState = () => ({
-    startOffset: null,
-    startSize: null,
-    deltaOffset: null,
-    deltaPercentage: null,
-    isResizingColumn: false,
-    columnSizingStart: []
-  });
-  const ColumnSizing = {
-    getDefaultColumnDef: () => {
-      return defaultColumnSizing;
-    },
-    getInitialState: state => {
-      return {
-        columnSizing: {},
-        columnSizingInfo: getDefaultColumnSizingInfoState(),
-        ...state
-      };
-    },
-    getDefaultOptions: table => {
-      return {
-        columnResizeMode: 'onEnd',
-        columnResizeDirection: 'ltr',
-        onColumnSizingChange: makeStateUpdater('columnSizing', table),
-        onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table)
-      };
-    },
+  const ColumnFaceting = {
     createColumn: (column, table) => {
-      column.getSize = () => {
-        var _column$columnDef$min, _ref, _column$columnDef$max;
-        const columnSize = table.getState().columnSizing[column.id];
-        return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize);
-      };
-      column.getStart = memo(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(0, column.getIndex(position)).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getStart'));
-      column.getAfter = memo(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(column.getIndex(position) + 1).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getAfter'));
-      column.resetSize = () => {
-        table.setColumnSizing(_ref2 => {
-          let {
-            [column.id]: _,
-            ...rest
-          } = _ref2;
-          return rest;
-        });
-      };
-      column.getCanResize = () => {
-        var _column$columnDef$ena, _table$options$enable;
-        return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true);
-      };
-      column.getIsResizing = () => {
-        return table.getState().columnSizingInfo.isResizingColumn === column.id;
+      column._getFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id);
+      column.getFacetedRowModel = () => {
+        if (!column._getFacetedRowModel) {
+          return table.getPreFilteredRowModel();
+        }
+        return column._getFacetedRowModel();
       };
-    },
-    createHeader: (header, table) => {
-      header.getSize = () => {
-        let sum = 0;
-        const recurse = header => {
-          if (header.subHeaders.length) {
-            header.subHeaders.forEach(recurse);
-          } else {
-            var _header$column$getSiz;
-            sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
-          }
-        };
-        recurse(header);
-        return sum;
+      column._getFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id);
+      column.getFacetedUniqueValues = () => {
+        if (!column._getFacetedUniqueValues) {
+          return new Map();
+        }
+        return column._getFacetedUniqueValues();
       };
-      header.getStart = () => {
-        if (header.index > 0) {
-          const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
-          return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
+      column._getFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id);
+      column.getFacetedMinMaxValues = () => {
+        if (!column._getFacetedMinMaxValues) {
+          return undefined;
         }
-        return 0;
-      };
-      header.getResizeHandler = _contextDocument => {
-        const column = table.getColumn(header.column.id);
-        const canResize = column == null ? void 0 : column.getCanResize();
-        return e => {
-          if (!column || !canResize) {
-            return;
-          }
-          e.persist == null || e.persist();
-          if (isTouchStartEvent(e)) {
-            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
-            if (e.touches && e.touches.length > 1) {
-              return;
-            }
-          }
-          const startSize = header.getSize();
-          const columnSizingStart = header ? header.getLeafHeaders().map(d => [d.column.id, d.column.getSize()]) : [[column.id, column.getSize()]];
-          const clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
-          const newColumnSizing = {};
-          const updateOffset = (eventType, clientXPos) => {
-            if (typeof clientXPos !== 'number') {
-              return;
-            }
-            table.setColumnSizingInfo(old => {
-              var _old$startOffset, _old$startSize;
-              const deltaDirection = table.options.columnResizeDirection === 'rtl' ? -1 : 1;
-              const deltaOffset = (clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0)) * deltaDirection;
-              const deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999);
-              old.columnSizingStart.forEach(_ref3 => {
-                let [columnId, headerSize] = _ref3;
-                newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100;
-              });
-              return {
-                ...old,
-                deltaOffset,
-                deltaPercentage
-              };
-            });
-            if (table.options.columnResizeMode === 'onChange' || eventType === 'end') {
-              table.setColumnSizing(old => ({
-                ...old,
-                ...newColumnSizing
-              }));
-            }
-          };
-          const onMove = clientXPos => updateOffset('move', clientXPos);
-          const onEnd = clientXPos => {
-            updateOffset('end', clientXPos);
-            table.setColumnSizingInfo(old => ({
-              ...old,
-              isResizingColumn: false,
-              startOffset: null,
-              startSize: null,
-              deltaOffset: null,
-              deltaPercentage: null,
-              columnSizingStart: []
-            }));
-          };
-          const contextDocument = _contextDocument || typeof document !== 'undefined' ? document : null;
-          const mouseEvents = {
-            moveHandler: e => onMove(e.clientX),
-            upHandler: e => {
-              contextDocument == null || contextDocument.removeEventListener('mousemove', mouseEvents.moveHandler);
-              contextDocument == null || contextDocument.removeEventListener('mouseup', mouseEvents.upHandler);
-              onEnd(e.clientX);
-            }
-          };
-          const touchEvents = {
-            moveHandler: e => {
-              if (e.cancelable) {
-                e.preventDefault();
-                e.stopPropagation();
-              }
-              onMove(e.touches[0].clientX);
-              return false;
-            },
-            upHandler: e => {
-              var _e$touches$;
-              contextDocument == null || contextDocument.removeEventListener('touchmove', touchEvents.moveHandler);
-              contextDocument == null || contextDocument.removeEventListener('touchend', touchEvents.upHandler);
-              if (e.cancelable) {
-                e.preventDefault();
-                e.stopPropagation();
-              }
-              onEnd((_e$touches$ = e.touches[0]) == null ? void 0 : _e$touches$.clientX);
-            }
-          };
-          const passiveIfSupported = passiveEventSupported() ? {
-            passive: false
-          } : false;
-          if (isTouchStartEvent(e)) {
-            contextDocument == null || contextDocument.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported);
-            contextDocument == null || contextDocument.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported);
-          } else {
-            contextDocument == null || contextDocument.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported);
-            contextDocument == null || contextDocument.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported);
-          }
-          table.setColumnSizingInfo(old => ({
-            ...old,
-            startOffset: clientX,
-            startSize,
-            deltaOffset: 0,
-            deltaPercentage: 0,
-            columnSizingStart,
-            isResizingColumn: column.id
-          }));
-        };
-      };
-    },
-    createTable: table => {
-      table.setColumnSizing = updater => table.options.onColumnSizingChange == null ? void 0 : table.options.onColumnSizingChange(updater);
-      table.setColumnSizingInfo = updater => table.options.onColumnSizingInfoChange == null ? void 0 : table.options.onColumnSizingInfoChange(updater);
-      table.resetColumnSizing = defaultState => {
-        var _table$initialState$c;
-        table.setColumnSizing(defaultState ? {} : (_table$initialState$c = table.initialState.columnSizing) != null ? _table$initialState$c : {});
-      };
-      table.resetHeaderSizeInfo = defaultState => {
-        var _table$initialState$c2;
-        table.setColumnSizingInfo(defaultState ? getDefaultColumnSizingInfoState() : (_table$initialState$c2 = table.initialState.columnSizingInfo) != null ? _table$initialState$c2 : getDefaultColumnSizingInfoState());
-      };
-      table.getTotalSize = () => {
-        var _table$getHeaderGroup, _table$getHeaderGroup2;
-        return (_table$getHeaderGroup = (_table$getHeaderGroup2 = table.getHeaderGroups()[0]) == null ? void 0 : _table$getHeaderGroup2.headers.reduce((sum, header) => {
-          return sum + header.getSize();
-        }, 0)) != null ? _table$getHeaderGroup : 0;
-      };
-      table.getLeftTotalSize = () => {
-        var _table$getLeftHeaderG, _table$getLeftHeaderG2;
-        return (_table$getLeftHeaderG = (_table$getLeftHeaderG2 = table.getLeftHeaderGroups()[0]) == null ? void 0 : _table$getLeftHeaderG2.headers.reduce((sum, header) => {
-          return sum + header.getSize();
-        }, 0)) != null ? _table$getLeftHeaderG : 0;
-      };
-      table.getCenterTotalSize = () => {
-        var _table$getCenterHeade, _table$getCenterHeade2;
-        return (_table$getCenterHeade = (_table$getCenterHeade2 = table.getCenterHeaderGroups()[0]) == null ? void 0 : _table$getCenterHeade2.headers.reduce((sum, header) => {
-          return sum + header.getSize();
-        }, 0)) != null ? _table$getCenterHeade : 0;
-      };
-      table.getRightTotalSize = () => {
-        var _table$getRightHeader, _table$getRightHeader2;
-        return (_table$getRightHeader = (_table$getRightHeader2 = table.getRightHeaderGroups()[0]) == null ? void 0 : _table$getRightHeader2.headers.reduce((sum, header) => {
-          return sum + header.getSize();
-        }, 0)) != null ? _table$getRightHeader : 0;
+        return column._getFacetedMinMaxValues();
       };
     }
   };
-  let passiveSupported = null;
-  function passiveEventSupported() {
-    if (typeof passiveSupported === 'boolean') return passiveSupported;
-    let supported = false;
-    try {
-      const options = {
-        get passive() {
-          supported = true;
-          return false;
-        }
-      };
-      const noop = () => {};
-      window.addEventListener('test', noop, options);
-      window.removeEventListener('test', noop);
-    } catch (err) {
-      supported = false;
+
+  const includesString = (row, columnId, filterValue) => {
+    var _row$getValue;
+    const search = filterValue.toLowerCase();
+    return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search));
+  };
+  includesString.autoRemove = val => testFalsey(val);
+  const includesStringSensitive = (row, columnId, filterValue) => {
+    var _row$getValue2;
+    return Boolean((_row$getValue2 = row.getValue(columnId)) == null || (_row$getValue2 = _row$getValue2.toString()) == null ? void 0 : _row$getValue2.includes(filterValue));
+  };
+  includesStringSensitive.autoRemove = val => testFalsey(val);
+  const equalsString = (row, columnId, filterValue) => {
+    var _row$getValue3;
+    return ((_row$getValue3 = row.getValue(columnId)) == null || (_row$getValue3 = _row$getValue3.toString()) == null ? void 0 : _row$getValue3.toLowerCase()) === (filterValue == null ? void 0 : filterValue.toLowerCase());
+  };
+  equalsString.autoRemove = val => testFalsey(val);
+  const arrIncludes = (row, columnId, filterValue) => {
+    var _row$getValue4;
+    return (_row$getValue4 = row.getValue(columnId)) == null ? void 0 : _row$getValue4.includes(filterValue);
+  };
+  arrIncludes.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const arrIncludesAll = (row, columnId, filterValue) => {
+    return !filterValue.some(val => {
+      var _row$getValue5;
+      return !((_row$getValue5 = row.getValue(columnId)) != null && _row$getValue5.includes(val));
+    });
+  };
+  arrIncludesAll.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const arrIncludesSome = (row, columnId, filterValue) => {
+    return filterValue.some(val => {
+      var _row$getValue6;
+      return (_row$getValue6 = row.getValue(columnId)) == null ? void 0 : _row$getValue6.includes(val);
+    });
+  };
+  arrIncludesSome.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const equals = (row, columnId, filterValue) => {
+    return row.getValue(columnId) === filterValue;
+  };
+  equals.autoRemove = val => testFalsey(val);
+  const weakEquals = (row, columnId, filterValue) => {
+    return row.getValue(columnId) == filterValue;
+  };
+  weakEquals.autoRemove = val => testFalsey(val);
+  const inNumberRange = (row, columnId, filterValue) => {
+    let [min, max] = filterValue;
+    const rowValue = row.getValue(columnId);
+    return rowValue >= min && rowValue <= max;
+  };
+  inNumberRange.resolveFilterValue = val => {
+    let [unsafeMin, unsafeMax] = val;
+    let parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
+    let parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
+    let min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
+    let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
+    if (min > max) {
+      const temp = min;
+      min = max;
+      max = temp;
     }
-    passiveSupported = supported;
-    return passiveSupported;
-  }
-  function isTouchStartEvent(e) {
-    return e.type === 'touchstart';
+    return [min, max];
+  };
+  inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
+
+  // Export
+
+  const filterFns = {
+    includesString,
+    includesStringSensitive,
+    equalsString,
+    arrIncludes,
+    arrIncludesAll,
+    arrIncludesSome,
+    equals,
+    weakEquals,
+    inNumberRange
+  };
+  // Utils
+
+  function testFalsey(val) {
+    return val === undefined || val === null || val === '';
   }
 
   //
 
-  const Expanding = {
+  const ColumnFiltering = {
+    getDefaultColumnDef: () => {
+      return {
+        filterFn: 'auto'
+      };
+    },
     getInitialState: state => {
       return {
-        expanded: {},
+        columnFilters: [],
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onExpandedChange: makeStateUpdater('expanded', table),
-        paginateExpandedRows: true
+        onColumnFiltersChange: makeStateUpdater('columnFilters', table),
+        filterFromLeafRows: false,
+        maxLeafRowFilterDepth: 100
       };
     },
-    createTable: table => {
-      let registered = false;
-      let queued = false;
-      table._autoResetExpanded = () => {
-        var _ref, _table$options$autoRe;
-        if (!registered) {
-          table._queue(() => {
-            registered = true;
-          });
-          return;
-        }
-        if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) {
-          if (queued) return;
-          queued = true;
-          table._queue(() => {
-            table.resetExpanded();
-            queued = false;
-          });
+    createColumn: (column, table) => {
+      column.getAutoFilterFn = () => {
+        const firstRow = table.getCoreRowModel().flatRows[0];
+        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
+        if (typeof value === 'string') {
+          return filterFns.includesString;
         }
-      };
-      table.setExpanded = updater => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater);
-      table.toggleAllRowsExpanded = expanded => {
-        if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) {
-          table.setExpanded(true);
-        } else {
-          table.setExpanded({});
+        if (typeof value === 'number') {
+          return filterFns.inNumberRange;
         }
-      };
-      table.resetExpanded = defaultState => {
-        var _table$initialState$e, _table$initialState;
-        table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {});
-      };
-      table.getCanSomeRowsExpand = () => {
-        return table.getPrePaginationRowModel().flatRows.some(row => row.getCanExpand());
-      };
-      table.getToggleAllRowsExpandedHandler = () => {
-        return e => {
-          e.persist == null || e.persist();
-          table.toggleAllRowsExpanded();
-        };
-      };
-      table.getIsSomeRowsExpanded = () => {
-        const expanded = table.getState().expanded;
-        return expanded === true || Object.values(expanded).some(Boolean);
-      };
-      table.getIsAllRowsExpanded = () => {
-        const expanded = table.getState().expanded;
-
-        // If expanded is true, save some cycles and return true
-        if (typeof expanded === 'boolean') {
-          return expanded === true;
+        if (typeof value === 'boolean') {
+          return filterFns.equals;
         }
-        if (!Object.keys(expanded).length) {
-          return false;
+        if (value !== null && typeof value === 'object') {
+          return filterFns.equals;
         }
-
-        // If any row is not expanded, return false
-        if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
-          return false;
+        if (Array.isArray(value)) {
+          return filterFns.arrIncludes;
         }
-
-        // They must all be expanded :shrug:
-        return true;
+        return filterFns.weakEquals;
       };
-      table.getExpandedDepth = () => {
-        let maxDepth = 0;
-        const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded);
-        rowIds.forEach(id => {
-          const splitId = id.split('.');
-          maxDepth = Math.max(maxDepth, splitId.length);
-        });
-        return maxDepth;
+      column.getFilterFn = () => {
+        var _table$options$filter, _table$options$filter2;
+        return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : // @ts-ignore
+        (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn];
       };
-      table.getPreExpandedRowModel = () => table.getSortedRowModel();
-      table.getExpandedRowModel = () => {
-        if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
-          table._getExpandedRowModel = table.options.getExpandedRowModel(table);
-        }
-        if (table.options.manualExpanding || !table._getExpandedRowModel) {
-          return table.getPreExpandedRowModel();
-        }
-        return table._getExpandedRowModel();
+      column.getCanFilter = () => {
+        var _column$columnDef$ena, _table$options$enable, _table$options$enable2;
+        return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn;
       };
-    },
-    createRow: (row, table) => {
-      row.toggleExpanded = expanded => {
-        table.setExpanded(old => {
-          var _expanded;
-          const exists = old === true ? true : !!(old != null && old[row.id]);
-          let oldExpanded = {};
-          if (old === true) {
-            Object.keys(table.getRowModel().rowsById).forEach(rowId => {
-              oldExpanded[rowId] = true;
-            });
-          } else {
-            oldExpanded = old;
+      column.getIsFiltered = () => column.getFilterIndex() > -1;
+      column.getFilterValue = () => {
+        var _table$getState$colum;
+        return (_table$getState$colum = table.getState().columnFilters) == null || (_table$getState$colum = _table$getState$colum.find(d => d.id === column.id)) == null ? void 0 : _table$getState$colum.value;
+      };
+      column.getFilterIndex = () => {
+        var _table$getState$colum2, _table$getState$colum3;
+        return (_table$getState$colum2 = (_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex(d => d.id === column.id)) != null ? _table$getState$colum2 : -1;
+      };
+      column.setFilterValue = value => {
+        table.setColumnFilters(old => {
+          const filterFn = column.getFilterFn();
+          const previousFilter = old == null ? void 0 : old.find(d => d.id === column.id);
+          const newFilter = functionalUpdate(value, previousFilter ? previousFilter.value : undefined);
+
+          //
+          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
+            var _old$filter;
+            return (_old$filter = old == null ? void 0 : old.filter(d => d.id !== column.id)) != null ? _old$filter : [];
           }
-          expanded = (_expanded = expanded) != null ? _expanded : !exists;
-          if (!exists && expanded) {
-            return {
-              ...oldExpanded,
-              [row.id]: true
-            };
+          const newFilterObj = {
+            id: column.id,
+            value: newFilter
+          };
+          if (previousFilter) {
+            var _old$map;
+            return (_old$map = old == null ? void 0 : old.map(d => {
+              if (d.id === column.id) {
+                return newFilterObj;
+              }
+              return d;
+            })) != null ? _old$map : [];
           }
-          if (exists && !expanded) {
-            const {
-              [row.id]: _,
-              ...rest
-            } = oldExpanded;
-            return rest;
+          if (old != null && old.length) {
+            return [...old, newFilterObj];
           }
-          return old;
+          return [newFilterObj];
         });
       };
-      row.getIsExpanded = () => {
-        var _table$options$getIsR;
-        const expanded = table.getState().expanded;
-        return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id]));
+    },
+    createRow: (row, _table) => {
+      row.columnFilters = {};
+      row.columnFiltersMeta = {};
+    },
+    createTable: table => {
+      table.setColumnFilters = updater => {
+        const leafColumns = table.getAllLeafColumns();
+        const updateFn = old => {
+          var _functionalUpdate;
+          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(filter => {
+            const column = leafColumns.find(d => d.id === filter.id);
+            if (column) {
+              const filterFn = column.getFilterFn();
+              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
+                return false;
+              }
+            }
+            return true;
+          });
+        };
+        table.options.onColumnFiltersChange == null || table.options.onColumnFiltersChange(updateFn);
       };
-      row.getCanExpand = () => {
-        var _table$options$getRow, _table$options$enable, _row$subRows;
-        return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+      table.resetColumnFilters = defaultState => {
+        var _table$initialState$c, _table$initialState;
+        table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []);
       };
-      row.getIsAllParentsExpanded = () => {
-        let isFullyExpanded = true;
-        let currentRow = row;
-        while (isFullyExpanded && currentRow.parentId) {
-          currentRow = table.getRow(currentRow.parentId, true);
-          isFullyExpanded = currentRow.getIsExpanded();
+      table.getPreFilteredRowModel = () => table.getCoreRowModel();
+      table.getFilteredRowModel = () => {
+        if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
+          table._getFilteredRowModel = table.options.getFilteredRowModel(table);
         }
-        return isFullyExpanded;
-      };
-      row.getToggleExpandedHandler = () => {
-        const canExpand = row.getCanExpand();
-        return () => {
-          if (!canExpand) return;
-          row.toggleExpanded();
-        };
+        if (table.options.manualFiltering || !table._getFilteredRowModel) {
+          return table.getPreFilteredRowModel();
+        }
+        return table._getFilteredRowModel();
       };
     }
   };
+  function shouldAutoRemoveFilter(filterFn, value, column) {
+    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
+  }
 
-  const includesString = (row, columnId, filterValue) => {
-    var _row$getValue;
-    const search = filterValue.toLowerCase();
-    return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search));
-  };
-  includesString.autoRemove = val => testFalsey(val);
-  const includesStringSensitive = (row, columnId, filterValue) => {
-    var _row$getValue2;
-    return Boolean((_row$getValue2 = row.getValue(columnId)) == null || (_row$getValue2 = _row$getValue2.toString()) == null ? void 0 : _row$getValue2.includes(filterValue));
-  };
-  includesStringSensitive.autoRemove = val => testFalsey(val);
-  const equalsString = (row, columnId, filterValue) => {
-    var _row$getValue3;
-    return ((_row$getValue3 = row.getValue(columnId)) == null || (_row$getValue3 = _row$getValue3.toString()) == null ? void 0 : _row$getValue3.toLowerCase()) === (filterValue == null ? void 0 : filterValue.toLowerCase());
-  };
-  equalsString.autoRemove = val => testFalsey(val);
-  const arrIncludes = (row, columnId, filterValue) => {
-    var _row$getValue4;
-    return (_row$getValue4 = row.getValue(columnId)) == null ? void 0 : _row$getValue4.includes(filterValue);
+  const sum = (columnId, _leafRows, childRows) => {
+    // It's faster to just add the aggregations together instead of
+    // process leaf nodes individually
+    return childRows.reduce((sum, next) => {
+      const nextValue = next.getValue(columnId);
+      return sum + (typeof nextValue === 'number' ? nextValue : 0);
+    }, 0);
   };
-  arrIncludes.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const arrIncludesAll = (row, columnId, filterValue) => {
-    return !filterValue.some(val => {
-      var _row$getValue5;
-      return !((_row$getValue5 = row.getValue(columnId)) != null && _row$getValue5.includes(val));
+  const min = (columnId, _leafRows, childRows) => {
+    let min;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null && (min > value || min === undefined && value >= value)) {
+        min = value;
+      }
     });
+    return min;
   };
-  arrIncludesAll.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const arrIncludesSome = (row, columnId, filterValue) => {
-    return filterValue.some(val => {
-      var _row$getValue6;
-      return (_row$getValue6 = row.getValue(columnId)) == null ? void 0 : _row$getValue6.includes(val);
+  const max = (columnId, _leafRows, childRows) => {
+    let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null && (max < value || max === undefined && value >= value)) {
+        max = value;
+      }
     });
+    return max;
   };
-  arrIncludesSome.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const equals = (row, columnId, filterValue) => {
-    return row.getValue(columnId) === filterValue;
-  };
-  equals.autoRemove = val => testFalsey(val);
-  const weakEquals = (row, columnId, filterValue) => {
-    return row.getValue(columnId) == filterValue;
+  const extent = (columnId, _leafRows, childRows) => {
+    let min;
+    let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null) {
+        if (min === undefined) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    });
+    return [min, max];
+  };
+  const mean = (columnId, leafRows) => {
+    let count = 0;
+    let sum = 0;
+    leafRows.forEach(row => {
+      let value = row.getValue(columnId);
+      if (value != null && (value = +value) >= value) {
+        ++count, sum += value;
+      }
+    });
+    if (count) return sum / count;
+    return;
+  };
+  const median = (columnId, leafRows) => {
+    if (!leafRows.length) {
+      return;
+    }
+    const values = leafRows.map(row => row.getValue(columnId));
+    if (!isNumberArray(values)) {
+      return;
+    }
+    if (values.length === 1) {
+      return values[0];
+    }
+    const mid = Math.floor(values.length / 2);
+    const nums = values.sort((a, b) => a - b);
+    return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+  };
+  const unique = (columnId, leafRows) => {
+    return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values());
+  };
+  const uniqueCount = (columnId, leafRows) => {
+    return new Set(leafRows.map(d => d.getValue(columnId))).size;
+  };
+  const count = (_columnId, leafRows) => {
+    return leafRows.length;
+  };
+  const aggregationFns = {
+    sum,
+    min,
+    max,
+    extent,
+    mean,
+    median,
+    unique,
+    uniqueCount,
+    count
+  };
+
+  //
+
+  const ColumnGrouping = {
+    getDefaultColumnDef: () => {
+      return {
+        aggregatedCell: props => {
+          var _toString, _props$getValue;
+          return (_toString = (_props$getValue = props.getValue()) == null || _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null;
+        },
+        aggregationFn: 'auto'
+      };
+    },
+    getInitialState: state => {
+      return {
+        grouping: [],
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onGroupingChange: makeStateUpdater('grouping', table),
+        groupedColumnMode: 'reorder'
+      };
+    },
+    createColumn: (column, table) => {
+      column.toggleGrouping = () => {
+        table.setGrouping(old => {
+          // Find any existing grouping for this column
+          if (old != null && old.includes(column.id)) {
+            return old.filter(d => d !== column.id);
+          }
+          return [...(old != null ? old : []), column.id];
+        });
+      };
+      column.getCanGroup = () => {
+        var _ref, _ref2, _ref3, _column$columnDef$ena;
+        return (_ref = (_ref2 = (_ref3 = (_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) != null ? _ref3 : table.options.enableGrouping) != null ? _ref2 : true) != null ? _ref : !!column.accessorFn;
+      };
+      column.getIsGrouped = () => {
+        var _table$getState$group;
+        return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id);
+      };
+      column.getGroupedIndex = () => {
+        var _table$getState$group2;
+        return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id);
+      };
+      column.getToggleGroupingHandler = () => {
+        const canGroup = column.getCanGroup();
+        return () => {
+          if (!canGroup) return;
+          column.toggleGrouping();
+        };
+      };
+      column.getAutoAggregationFn = () => {
+        const firstRow = table.getCoreRowModel().flatRows[0];
+        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
+        if (typeof value === 'number') {
+          return aggregationFns.sum;
+        }
+        if (Object.prototype.toString.call(value) === '[object Date]') {
+          return aggregationFns.extent;
+        }
+      };
+      column.getAggregationFn = () => {
+        var _table$options$aggreg, _table$options$aggreg2;
+        if (!column) {
+          throw new Error();
+        }
+        return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn];
+      };
+    },
+    createTable: table => {
+      table.setGrouping = updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater);
+      table.resetGrouping = defaultState => {
+        var _table$initialState$g, _table$initialState;
+        table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []);
+      };
+      table.getPreGroupedRowModel = () => table.getFilteredRowModel();
+      table.getGroupedRowModel = () => {
+        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
+          table._getGroupedRowModel = table.options.getGroupedRowModel(table);
+        }
+        if (table.options.manualGrouping || !table._getGroupedRowModel) {
+          return table.getPreGroupedRowModel();
+        }
+        return table._getGroupedRowModel();
+      };
+    },
+    createRow: (row, table) => {
+      row.getIsGrouped = () => !!row.groupingColumnId;
+      row.getGroupingValue = columnId => {
+        if (row._groupingValuesCache.hasOwnProperty(columnId)) {
+          return row._groupingValuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.columnDef.getGroupingValue)) {
+          return row.getValue(columnId);
+        }
+        row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(row.original);
+        return row._groupingValuesCache[columnId];
+      };
+      row._groupingValuesCache = {};
+    },
+    createCell: (cell, column, row, table) => {
+      cell.getIsGrouped = () => column.getIsGrouped() && column.id === row.groupingColumnId;
+      cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped();
+      cell.getIsAggregated = () => {
+        var _row$subRows;
+        return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+      };
+    }
+  };
+  function orderColumns(leafColumns, grouping, groupedColumnMode) {
+    if (!(grouping != null && grouping.length) || !groupedColumnMode) {
+      return leafColumns;
+    }
+    const nonGroupingColumns = leafColumns.filter(col => !grouping.includes(col.id));
+    if (groupedColumnMode === 'remove') {
+      return nonGroupingColumns;
+    }
+    const groupingColumns = grouping.map(g => leafColumns.find(col => col.id === g)).filter(Boolean);
+    return [...groupingColumns, ...nonGroupingColumns];
+  }
+
+  //
+
+  const ColumnOrdering = {
+    getInitialState: state => {
+      return {
+        columnOrder: [],
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onColumnOrderChange: makeStateUpdater('columnOrder', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.getIndex = memo(position => [_getVisibleLeafColumns(table, position)], columns => columns.findIndex(d => d.id === column.id), getMemoOptions(table.options, 'debugColumns', 'getIndex'));
+      column.getIsFirstColumn = position => {
+        var _columns$;
+        const columns = _getVisibleLeafColumns(table, position);
+        return ((_columns$ = columns[0]) == null ? void 0 : _columns$.id) === column.id;
+      };
+      column.getIsLastColumn = position => {
+        var _columns;
+        const columns = _getVisibleLeafColumns(table, position);
+        return ((_columns = columns[columns.length - 1]) == null ? void 0 : _columns.id) === column.id;
+      };
+    },
+    createTable: table => {
+      table.setColumnOrder = updater => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater);
+      table.resetColumnOrder = defaultState => {
+        var _table$initialState$c;
+        table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []);
+      };
+      table._getOrderColumnsFn = memo(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => {
+        // Sort grouped columns to the start of the column list
+        // before the headers are built
+        let orderedColumns = [];
+
+        // If there is no order, return the normal columns
+        if (!(columnOrder != null && columnOrder.length)) {
+          orderedColumns = columns;
+        } else {
+          const columnOrderCopy = [...columnOrder];
+
+          // If there is an order, make a copy of the columns
+          const columnsCopy = [...columns];
+
+          // And make a new ordered array of the columns
+
+          // Loop over the columns and place them in order into the new array
+          while (columnsCopy.length && columnOrderCopy.length) {
+            const targetColumnId = columnOrderCopy.shift();
+            const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId);
+            if (foundIndex > -1) {
+              orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]);
+            }
+          }
+
+          // If there are any columns left, add them to the end
+          orderedColumns = [...orderedColumns, ...columnsCopy];
+        }
+        return orderColumns(orderedColumns, grouping, groupedColumnMode);
+      }, getMemoOptions(table.options, 'debugTable', '_getOrderColumnsFn'));
+    }
+  };
+
+  //
+
+  const getDefaultColumnPinningState = () => ({
+    left: [],
+    right: []
+  });
+  const ColumnPinning = {
+    getInitialState: state => {
+      return {
+        columnPinning: getDefaultColumnPinningState(),
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onColumnPinningChange: makeStateUpdater('columnPinning', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.pin = position => {
+        const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean);
+        table.setColumnPinning(old => {
+          var _old$left3, _old$right3;
+          if (position === 'right') {
+            var _old$left, _old$right;
+            return {
+              left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+              right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
+            };
+          }
+          if (position === 'left') {
+            var _old$left2, _old$right2;
+            return {
+              left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
+              right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+            };
+          }
+          return {
+            left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+            right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+          };
+        });
+      };
+      column.getCanPin = () => {
+        const leafColumns = column.getLeafColumns();
+        return leafColumns.some(d => {
+          var _d$columnDef$enablePi, _ref, _table$options$enable;
+          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true);
+        });
+      };
+      column.getIsPinned = () => {
+        const leafColumnIds = column.getLeafColumns().map(d => d.id);
+        const {
+          left,
+          right
+        } = table.getState().columnPinning;
+        const isLeft = leafColumnIds.some(d => left == null ? void 0 : left.includes(d));
+        const isRight = leafColumnIds.some(d => right == null ? void 0 : right.includes(d));
+        return isLeft ? 'left' : isRight ? 'right' : false;
+      };
+      column.getPinnedIndex = () => {
+        var _table$getState$colum, _table$getState$colum2;
+        const position = column.getIsPinned();
+        return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null || (_table$getState$colum2 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0;
+      };
+    },
+    createRow: (row, table) => {
+      row.getCenterVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
+        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+        return allCells.filter(d => !leftAndRight.includes(d.column.id));
+      }, getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells'));
+      row.getLeftVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left], (allCells, left) => {
+        const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
+          position: 'left'
+        }));
+        return cells;
+      }, getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells'));
+      row.getRightVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
+        const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
+          position: 'right'
+        }));
+        return cells;
+      }, getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells'));
+    },
+    createTable: table => {
+      table.setColumnPinning = updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater);
+      table.resetColumnPinning = defaultState => {
+        var _table$initialState$c, _table$initialState;
+        return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState());
+      };
+      table.getIsSomeColumnsPinned = position => {
+        var _pinningState$positio;
+        const pinningState = table.getState().columnPinning;
+        if (!position) {
+          var _pinningState$left, _pinningState$right;
+          return Boolean(((_pinningState$left = pinningState.left) == null ? void 0 : _pinningState$left.length) || ((_pinningState$right = pinningState.right) == null ? void 0 : _pinningState$right.length));
+        }
+        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
+      };
+      table.getLeftLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => {
+        return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+      }, getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns'));
+      table.getRightLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => {
+        return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+      }, getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns'));
+      table.getCenterLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => {
+        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+        return allColumns.filter(d => !leftAndRight.includes(d.id));
+      }, getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns'));
+    }
   };
-  weakEquals.autoRemove = val => testFalsey(val);
-  const inNumberRange = (row, columnId, filterValue) => {
-    let [min, max] = filterValue;
-    const rowValue = row.getValue(columnId);
-    return rowValue >= min && rowValue <= max;
+
+  //
+
+  //
+
+  const defaultColumnSizing = {
+    size: 150,
+    minSize: 20,
+    maxSize: Number.MAX_SAFE_INTEGER
   };
-  inNumberRange.resolveFilterValue = val => {
-    let [unsafeMin, unsafeMax] = val;
-    let parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
-    let parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
-    let min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
-    let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
-    if (min > max) {
-      const temp = min;
-      min = max;
-      max = temp;
+  const getDefaultColumnSizingInfoState = () => ({
+    startOffset: null,
+    startSize: null,
+    deltaOffset: null,
+    deltaPercentage: null,
+    isResizingColumn: false,
+    columnSizingStart: []
+  });
+  const ColumnSizing = {
+    getDefaultColumnDef: () => {
+      return defaultColumnSizing;
+    },
+    getInitialState: state => {
+      return {
+        columnSizing: {},
+        columnSizingInfo: getDefaultColumnSizingInfoState(),
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        columnResizeMode: 'onEnd',
+        columnResizeDirection: 'ltr',
+        onColumnSizingChange: makeStateUpdater('columnSizing', table),
+        onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.getSize = () => {
+        var _column$columnDef$min, _ref, _column$columnDef$max;
+        const columnSize = table.getState().columnSizing[column.id];
+        return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize);
+      };
+      column.getStart = memo(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(0, column.getIndex(position)).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getStart'));
+      column.getAfter = memo(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(column.getIndex(position) + 1).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getAfter'));
+      column.resetSize = () => {
+        table.setColumnSizing(_ref2 => {
+          let {
+            [column.id]: _,
+            ...rest
+          } = _ref2;
+          return rest;
+        });
+      };
+      column.getCanResize = () => {
+        var _column$columnDef$ena, _table$options$enable;
+        return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true);
+      };
+      column.getIsResizing = () => {
+        return table.getState().columnSizingInfo.isResizingColumn === column.id;
+      };
+    },
+    createHeader: (header, table) => {
+      header.getSize = () => {
+        let sum = 0;
+        const recurse = header => {
+          if (header.subHeaders.length) {
+            header.subHeaders.forEach(recurse);
+          } else {
+            var _header$column$getSiz;
+            sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
+          }
+        };
+        recurse(header);
+        return sum;
+      };
+      header.getStart = () => {
+        if (header.index > 0) {
+          const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
+          return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
+        }
+        return 0;
+      };
+      header.getResizeHandler = _contextDocument => {
+        const column = table.getColumn(header.column.id);
+        const canResize = column == null ? void 0 : column.getCanResize();
+        return e => {
+          if (!column || !canResize) {
+            return;
+          }
+          e.persist == null || e.persist();
+          if (isTouchStartEvent(e)) {
+            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
+            if (e.touches && e.touches.length > 1) {
+              return;
+            }
+          }
+          const startSize = header.getSize();
+          const columnSizingStart = header ? header.getLeafHeaders().map(d => [d.column.id, d.column.getSize()]) : [[column.id, column.getSize()]];
+          const clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
+          const newColumnSizing = {};
+          const updateOffset = (eventType, clientXPos) => {
+            if (typeof clientXPos !== 'number') {
+              return;
+            }
+            table.setColumnSizingInfo(old => {
+              var _old$startOffset, _old$startSize;
+              const deltaDirection = table.options.columnResizeDirection === 'rtl' ? -1 : 1;
+              const deltaOffset = (clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0)) * deltaDirection;
+              const deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999);
+              old.columnSizingStart.forEach(_ref3 => {
+                let [columnId, headerSize] = _ref3;
+                newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100;
+              });
+              return {
+                ...old,
+                deltaOffset,
+                deltaPercentage
+              };
+            });
+            if (table.options.columnResizeMode === 'onChange' || eventType === 'end') {
+              table.setColumnSizing(old => ({
+                ...old,
+                ...newColumnSizing
+              }));
+            }
+          };
+          const onMove = clientXPos => updateOffset('move', clientXPos);
+          const onEnd = clientXPos => {
+            updateOffset('end', clientXPos);
+            table.setColumnSizingInfo(old => ({
+              ...old,
+              isResizingColumn: false,
+              startOffset: null,
+              startSize: null,
+              deltaOffset: null,
+              deltaPercentage: null,
+              columnSizingStart: []
+            }));
+          };
+          const contextDocument = _contextDocument || typeof document !== 'undefined' ? document : null;
+          const mouseEvents = {
+            moveHandler: e => onMove(e.clientX),
+            upHandler: e => {
+              contextDocument == null || contextDocument.removeEventListener('mousemove', mouseEvents.moveHandler);
+              contextDocument == null || contextDocument.removeEventListener('mouseup', mouseEvents.upHandler);
+              onEnd(e.clientX);
+            }
+          };
+          const touchEvents = {
+            moveHandler: e => {
+              if (e.cancelable) {
+                e.preventDefault();
+                e.stopPropagation();
+              }
+              onMove(e.touches[0].clientX);
+              return false;
+            },
+            upHandler: e => {
+              var _e$touches$;
+              contextDocument == null || contextDocument.removeEventListener('touchmove', touchEvents.moveHandler);
+              contextDocument == null || contextDocument.removeEventListener('touchend', touchEvents.upHandler);
+              if (e.cancelable) {
+                e.preventDefault();
+                e.stopPropagation();
+              }
+              onEnd((_e$touches$ = e.touches[0]) == null ? void 0 : _e$touches$.clientX);
+            }
+          };
+          const passiveIfSupported = passiveEventSupported() ? {
+            passive: false
+          } : false;
+          if (isTouchStartEvent(e)) {
+            contextDocument == null || contextDocument.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported);
+            contextDocument == null || contextDocument.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported);
+          } else {
+            contextDocument == null || contextDocument.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported);
+            contextDocument == null || contextDocument.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported);
+          }
+          table.setColumnSizingInfo(old => ({
+            ...old,
+            startOffset: clientX,
+            startSize,
+            deltaOffset: 0,
+            deltaPercentage: 0,
+            columnSizingStart,
+            isResizingColumn: column.id
+          }));
+        };
+      };
+    },
+    createTable: table => {
+      table.setColumnSizing = updater => table.options.onColumnSizingChange == null ? void 0 : table.options.onColumnSizingChange(updater);
+      table.setColumnSizingInfo = updater => table.options.onColumnSizingInfoChange == null ? void 0 : table.options.onColumnSizingInfoChange(updater);
+      table.resetColumnSizing = defaultState => {
+        var _table$initialState$c;
+        table.setColumnSizing(defaultState ? {} : (_table$initialState$c = table.initialState.columnSizing) != null ? _table$initialState$c : {});
+      };
+      table.resetHeaderSizeInfo = defaultState => {
+        var _table$initialState$c2;
+        table.setColumnSizingInfo(defaultState ? getDefaultColumnSizingInfoState() : (_table$initialState$c2 = table.initialState.columnSizingInfo) != null ? _table$initialState$c2 : getDefaultColumnSizingInfoState());
+      };
+      table.getTotalSize = () => {
+        var _table$getHeaderGroup, _table$getHeaderGroup2;
+        return (_table$getHeaderGroup = (_table$getHeaderGroup2 = table.getHeaderGroups()[0]) == null ? void 0 : _table$getHeaderGroup2.headers.reduce((sum, header) => {
+          return sum + header.getSize();
+        }, 0)) != null ? _table$getHeaderGroup : 0;
+      };
+      table.getLeftTotalSize = () => {
+        var _table$getLeftHeaderG, _table$getLeftHeaderG2;
+        return (_table$getLeftHeaderG = (_table$getLeftHeaderG2 = table.getLeftHeaderGroups()[0]) == null ? void 0 : _table$getLeftHeaderG2.headers.reduce((sum, header) => {
+          return sum + header.getSize();
+        }, 0)) != null ? _table$getLeftHeaderG : 0;
+      };
+      table.getCenterTotalSize = () => {
+        var _table$getCenterHeade, _table$getCenterHeade2;
+        return (_table$getCenterHeade = (_table$getCenterHeade2 = table.getCenterHeaderGroups()[0]) == null ? void 0 : _table$getCenterHeade2.headers.reduce((sum, header) => {
+          return sum + header.getSize();
+        }, 0)) != null ? _table$getCenterHeade : 0;
+      };
+      table.getRightTotalSize = () => {
+        var _table$getRightHeader, _table$getRightHeader2;
+        return (_table$getRightHeader = (_table$getRightHeader2 = table.getRightHeaderGroups()[0]) == null ? void 0 : _table$getRightHeader2.headers.reduce((sum, header) => {
+          return sum + header.getSize();
+        }, 0)) != null ? _table$getRightHeader : 0;
+      };
     }
-    return [min, max];
-  };
-  inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
-
-  // Export
-
-  const filterFns = {
-    includesString,
-    includesStringSensitive,
-    equalsString,
-    arrIncludes,
-    arrIncludesAll,
-    arrIncludesSome,
-    equals,
-    weakEquals,
-    inNumberRange
   };
-  // Utils
-
-  function testFalsey(val) {
-    return val === undefined || val === null || val === '';
+  let passiveSupported = null;
+  function passiveEventSupported() {
+    if (typeof passiveSupported === 'boolean') return passiveSupported;
+    let supported = false;
+    try {
+      const options = {
+        get passive() {
+          supported = true;
+          return false;
+        }
+      };
+      const noop = () => {};
+      window.addEventListener('test', noop, options);
+      window.removeEventListener('test', noop);
+    } catch (err) {
+      supported = false;
+    }
+    passiveSupported = supported;
+    return passiveSupported;
+  }
+  function isTouchStartEvent(e) {
+    return e.type === 'touchstart';
   }
 
   //
 
-  const Filters = {
-    getDefaultColumnDef: () => {
-      return {
-        filterFn: 'auto'
-      };
-    },
+  const ColumnVisibility = {
     getInitialState: state => {
       return {
-        columnFilters: [],
-        globalFilter: undefined,
-        // filtersProgress: 1,
-        // facetProgress: {},
+        columnVisibility: {},
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onColumnFiltersChange: makeStateUpdater('columnFilters', table),
-        onGlobalFilterChange: makeStateUpdater('globalFilter', table),
-        filterFromLeafRows: false,
-        maxLeafRowFilterDepth: 100,
-        globalFilterFn: 'auto',
-        getColumnCanGlobalFilter: column => {
-          var _table$getCoreRowMode;
-          const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null || (_table$getCoreRowMode = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode.getValue();
-          return typeof value === 'string' || typeof value === 'number';
-        }
+        onColumnVisibilityChange: makeStateUpdater('columnVisibility', table)
       };
     },
     createColumn: (column, table) => {
-      column.getAutoFilterFn = () => {
-        const firstRow = table.getCoreRowModel().flatRows[0];
-        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
-        if (typeof value === 'string') {
-          return filterFns.includesString;
-        }
-        if (typeof value === 'number') {
-          return filterFns.inNumberRange;
-        }
-        if (typeof value === 'boolean') {
-          return filterFns.equals;
-        }
-        if (value !== null && typeof value === 'object') {
-          return filterFns.equals;
-        }
-        if (Array.isArray(value)) {
-          return filterFns.arrIncludes;
+      column.toggleVisibility = value => {
+        if (column.getCanHide()) {
+          table.setColumnVisibility(old => ({
+            ...old,
+            [column.id]: value != null ? value : !column.getIsVisible()
+          }));
         }
-        return filterFns.weakEquals;
       };
-      column.getFilterFn = () => {
-        var _table$options$filter, _table$options$filter2;
-        return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : // @ts-ignore
-        (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn];
+      column.getIsVisible = () => {
+        var _ref, _table$getState$colum;
+        const childColumns = column.columns;
+        return (_ref = childColumns.length ? childColumns.some(c => c.getIsVisible()) : (_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) != null ? _ref : true;
       };
-      column.getCanFilter = () => {
-        var _column$columnDef$ena, _table$options$enable, _table$options$enable2;
-        return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn;
+      column.getCanHide = () => {
+        var _column$columnDef$ena, _table$options$enable;
+        return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true);
       };
-      column.getCanGlobalFilter = () => {
-        var _column$columnDef$ena2, _table$options$enable3, _table$options$enable4, _table$options$getCol;
-        return ((_column$columnDef$ena2 = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena2 : true) && ((_table$options$enable3 = table.options.enableGlobalFilter) != null ? _table$options$enable3 : true) && ((_table$options$enable4 = table.options.enableFilters) != null ? _table$options$enable4 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn;
+      column.getToggleVisibilityHandler = () => {
+        return e => {
+          column.toggleVisibility == null || column.toggleVisibility(e.target.checked);
+        };
       };
-      column.getIsFiltered = () => column.getFilterIndex() > -1;
-      column.getFilterValue = () => {
-        var _table$getState$colum;
-        return (_table$getState$colum = table.getState().columnFilters) == null || (_table$getState$colum = _table$getState$colum.find(d => d.id === column.id)) == null ? void 0 : _table$getState$colum.value;
+    },
+    createRow: (row, table) => {
+      row._getAllVisibleCells = memo(() => [row.getAllCells(), table.getState().columnVisibility], cells => {
+        return cells.filter(cell => cell.column.getIsVisible());
+      }, getMemoOptions(table.options, 'debugRows', '_getAllVisibleCells'));
+      row.getVisibleCells = memo(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], getMemoOptions(table.options, 'debugRows', 'getVisibleCells'));
+    },
+    createTable: table => {
+      const makeVisibleColumnsMethod = (key, getColumns) => {
+        return memo(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => {
+          return columns.filter(d => d.getIsVisible == null ? void 0 : d.getIsVisible());
+        }, getMemoOptions(table.options, 'debugColumns', key));
       };
-      column.getFilterIndex = () => {
-        var _table$getState$colum2, _table$getState$colum3;
-        return (_table$getState$colum2 = (_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex(d => d.id === column.id)) != null ? _table$getState$colum2 : -1;
+      table.getVisibleFlatColumns = makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns());
+      table.getVisibleLeafColumns = makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns());
+      table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns());
+      table.getRightVisibleLeafColumns = makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns());
+      table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns());
+      table.setColumnVisibility = updater => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater);
+      table.resetColumnVisibility = defaultState => {
+        var _table$initialState$c;
+        table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {});
       };
-      column.setFilterValue = value => {
-        table.setColumnFilters(old => {
-          const filterFn = column.getFilterFn();
-          const previousfilter = old == null ? void 0 : old.find(d => d.id === column.id);
-          const newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined);
-
-          //
-          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
-            var _old$filter;
-            return (_old$filter = old == null ? void 0 : old.filter(d => d.id !== column.id)) != null ? _old$filter : [];
-          }
-          const newFilterObj = {
-            id: column.id,
-            value: newFilter
-          };
-          if (previousfilter) {
-            var _old$map;
-            return (_old$map = old == null ? void 0 : old.map(d => {
-              if (d.id === column.id) {
-                return newFilterObj;
-              }
-              return d;
-            })) != null ? _old$map : [];
-          }
-          if (old != null && old.length) {
-            return [...old, newFilterObj];
-          }
-          return [newFilterObj];
-        });
+      table.toggleAllColumnsVisible = value => {
+        var _value;
+        value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible();
+        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
+          ...obj,
+          [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
+        }), {}));
       };
-      column._getFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id);
-      column.getFacetedRowModel = () => {
-        if (!column._getFacetedRowModel) {
-          return table.getPreFilteredRowModel();
-        }
-        return column._getFacetedRowModel();
+      table.getIsAllColumnsVisible = () => !table.getAllLeafColumns().some(column => !(column.getIsVisible != null && column.getIsVisible()));
+      table.getIsSomeColumnsVisible = () => table.getAllLeafColumns().some(column => column.getIsVisible == null ? void 0 : column.getIsVisible());
+      table.getToggleAllColumnsVisibilityHandler = () => {
+        return e => {
+          var _target;
+          table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
+        };
       };
-      column._getFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id);
-      column.getFacetedUniqueValues = () => {
-        if (!column._getFacetedUniqueValues) {
-          return new Map();
-        }
-        return column._getFacetedUniqueValues();
+    }
+  };
+  function _getVisibleLeafColumns(table, position) {
+    return !position ? table.getVisibleLeafColumns() : position === 'center' ? table.getCenterVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns();
+  }
+
+  //
+
+  const GlobalFiltering = {
+    getInitialState: state => {
+      return {
+        globalFilter: undefined,
+        ...state
       };
-      column._getFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id);
-      column.getFacetedMinMaxValues = () => {
-        if (!column._getFacetedMinMaxValues) {
-          return undefined;
+    },
+    getDefaultOptions: table => {
+      return {
+        onGlobalFilterChange: makeStateUpdater('globalFilter', table),
+        globalFilterFn: 'auto',
+        getColumnCanGlobalFilter: column => {
+          var _table$getCoreRowMode;
+          const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null || (_table$getCoreRowMode = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode.getValue();
+          return typeof value === 'string' || typeof value === 'number';
         }
-        return column._getFacetedMinMaxValues();
       };
-      // () => [column.getFacetedRowModel()],
-      // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
     },
-    createRow: (row, table) => {
-      row.columnFilters = {};
-      row.columnFiltersMeta = {};
+    createColumn: (column, table) => {
+      column.getCanGlobalFilter = () => {
+        var _column$columnDef$ena, _table$options$enable, _table$options$enable2, _table$options$getCol;
+        return ((_column$columnDef$ena = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableGlobalFilter) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn;
+      };
     },
     createTable: table => {
       table.getGlobalAutoFilterFn = () => {
         return filterFns.includesString;
       };
       table.getGlobalFilterFn = () => {
-        var _table$options$filter3, _table$options$filter4;
+        var _table$options$filter, _table$options$filter2;
         const {
           globalFilterFn: globalFilterFn
         } = table.options;
         return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === 'auto' ? table.getGlobalAutoFilterFn() : // @ts-ignore
-        (_table$options$filter3 = (_table$options$filter4 = table.options.filterFns) == null ? void 0 : _table$options$filter4[globalFilterFn]) != null ? _table$options$filter3 : filterFns[globalFilterFn];
-      };
-      table.setColumnFilters = updater => {
-        const leafColumns = table.getAllLeafColumns();
-        const updateFn = old => {
-          var _functionalUpdate;
-          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(filter => {
-            const column = leafColumns.find(d => d.id === filter.id);
-            if (column) {
-              const filterFn = column.getFilterFn();
-              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
-                return false;
-              }
-            }
-            return true;
-          });
-        };
-        table.options.onColumnFiltersChange == null || table.options.onColumnFiltersChange(updateFn);
+        (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[globalFilterFn]) != null ? _table$options$filter : filterFns[globalFilterFn];
       };
       table.setGlobalFilter = updater => {
         table.options.onGlobalFilterChange == null || table.options.onGlobalFilterChange(updater);
@@ -1106,20 +1620,6 @@
       table.resetGlobalFilter = defaultState => {
         table.setGlobalFilter(defaultState ? undefined : table.initialState.globalFilter);
       };
-      table.resetColumnFilters = defaultState => {
-        var _table$initialState$c, _table$initialState;
-        table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []);
-      };
-      table.getPreFilteredRowModel = () => table.getCoreRowModel();
-      table.getFilteredRowModel = () => {
-        if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
-          table._getFilteredRowModel = table.options.getFilteredRowModel(table);
-        }
-        if (table.options.manualFiltering || !table._getFilteredRowModel) {
-          return table.getPreFilteredRowModel();
-        }
-        return table._getFilteredRowModel();
-      };
       table._getGlobalFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, '__global__');
       table.getGlobalFacetedRowModel = () => {
         if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {
@@ -1143,289 +1643,161 @@
       };
     }
   };
-  function shouldAutoRemoveFilter(filterFn, value, column) {
-    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
-  }
-
-  const sum = (columnId, _leafRows, childRows) => {
-    // It's faster to just add the aggregations together instead of
-    // process leaf nodes individually
-    return childRows.reduce((sum, next) => {
-      const nextValue = next.getValue(columnId);
-      return sum + (typeof nextValue === 'number' ? nextValue : 0);
-    }, 0);
-  };
-  const min = (columnId, _leafRows, childRows) => {
-    let min;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null && (min > value || min === undefined && value >= value)) {
-        min = value;
-      }
-    });
-    return min;
-  };
-  const max = (columnId, _leafRows, childRows) => {
-    let max;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null && (max < value || max === undefined && value >= value)) {
-        max = value;
-      }
-    });
-    return max;
-  };
-  const extent = (columnId, _leafRows, childRows) => {
-    let min;
-    let max;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null) {
-        if (min === undefined) {
-          if (value >= value) min = max = value;
-        } else {
-          if (min > value) min = value;
-          if (max < value) max = value;
-        }
-      }
-    });
-    return [min, max];
-  };
-  const mean = (columnId, leafRows) => {
-    let count = 0;
-    let sum = 0;
-    leafRows.forEach(row => {
-      let value = row.getValue(columnId);
-      if (value != null && (value = +value) >= value) {
-        ++count, sum += value;
-      }
-    });
-    if (count) return sum / count;
-    return;
-  };
-  const median = (columnId, leafRows) => {
-    if (!leafRows.length) {
-      return;
-    }
-    const values = leafRows.map(row => row.getValue(columnId));
-    if (!isNumberArray(values)) {
-      return;
-    }
-    if (values.length === 1) {
-      return values[0];
-    }
-    const mid = Math.floor(values.length / 2);
-    const nums = values.sort((a, b) => a - b);
-    return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
-  };
-  const unique = (columnId, leafRows) => {
-    return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values());
-  };
-  const uniqueCount = (columnId, leafRows) => {
-    return new Set(leafRows.map(d => d.getValue(columnId))).size;
-  };
-  const count = (_columnId, leafRows) => {
-    return leafRows.length;
-  };
-  const aggregationFns = {
-    sum,
-    min,
-    max,
-    extent,
-    mean,
-    median,
-    unique,
-    uniqueCount,
-    count
-  };
 
   //
 
-  const Grouping = {
-    getDefaultColumnDef: () => {
-      return {
-        aggregatedCell: props => {
-          var _toString, _props$getValue;
-          return (_toString = (_props$getValue = props.getValue()) == null || _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null;
-        },
-        aggregationFn: 'auto'
-      };
-    },
+  const RowExpanding = {
     getInitialState: state => {
       return {
-        grouping: [],
+        expanded: {},
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onGroupingChange: makeStateUpdater('grouping', table),
-        groupedColumnMode: 'reorder'
+        onExpandedChange: makeStateUpdater('expanded', table),
+        paginateExpandedRows: true
       };
     },
-    createColumn: (column, table) => {
-      column.toggleGrouping = () => {
-        table.setGrouping(old => {
-          // Find any existing grouping for this column
-          if (old != null && old.includes(column.id)) {
-            return old.filter(d => d !== column.id);
-          }
-          return [...(old != null ? old : []), column.id];
-        });
-      };
-      column.getCanGroup = () => {
-        var _ref, _ref2, _ref3, _column$columnDef$ena;
-        return (_ref = (_ref2 = (_ref3 = (_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) != null ? _ref3 : table.options.enableGrouping) != null ? _ref2 : true) != null ? _ref : !!column.accessorFn;
-      };
-      column.getIsGrouped = () => {
-        var _table$getState$group;
-        return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id);
-      };
-      column.getGroupedIndex = () => {
-        var _table$getState$group2;
-        return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id);
-      };
-      column.getToggleGroupingHandler = () => {
-        const canGroup = column.getCanGroup();
-        return () => {
-          if (!canGroup) return;
-          column.toggleGrouping();
-        };
-      };
-      column.getAutoAggregationFn = () => {
-        const firstRow = table.getCoreRowModel().flatRows[0];
-        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
-        if (typeof value === 'number') {
-          return aggregationFns.sum;
+    createTable: table => {
+      let registered = false;
+      let queued = false;
+      table._autoResetExpanded = () => {
+        var _ref, _table$options$autoRe;
+        if (!registered) {
+          table._queue(() => {
+            registered = true;
+          });
+          return;
         }
-        if (Object.prototype.toString.call(value) === '[object Date]') {
-          return aggregationFns.extent;
+        if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) {
+          if (queued) return;
+          queued = true;
+          table._queue(() => {
+            table.resetExpanded();
+            queued = false;
+          });
         }
       };
-      column.getAggregationFn = () => {
-        var _table$options$aggreg, _table$options$aggreg2;
-        if (!column) {
-          throw new Error();
+      table.setExpanded = updater => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater);
+      table.toggleAllRowsExpanded = expanded => {
+        if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) {
+          table.setExpanded(true);
+        } else {
+          table.setExpanded({});
         }
-        return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn];
       };
-    },
-    createTable: table => {
-      table.setGrouping = updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater);
-      table.resetGrouping = defaultState => {
-        var _table$initialState$g, _table$initialState;
-        table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []);
+      table.resetExpanded = defaultState => {
+        var _table$initialState$e, _table$initialState;
+        table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {});
       };
-      table.getPreGroupedRowModel = () => table.getFilteredRowModel();
-      table.getGroupedRowModel = () => {
-        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
-          table._getGroupedRowModel = table.options.getGroupedRowModel(table);
-        }
-        if (table.options.manualGrouping || !table._getGroupedRowModel) {
-          return table.getPreGroupedRowModel();
-        }
-        return table._getGroupedRowModel();
+      table.getCanSomeRowsExpand = () => {
+        return table.getPrePaginationRowModel().flatRows.some(row => row.getCanExpand());
       };
-    },
-    createRow: (row, table) => {
-      row.getIsGrouped = () => !!row.groupingColumnId;
-      row.getGroupingValue = columnId => {
-        if (row._groupingValuesCache.hasOwnProperty(columnId)) {
-          return row._groupingValuesCache[columnId];
+      table.getToggleAllRowsExpandedHandler = () => {
+        return e => {
+          e.persist == null || e.persist();
+          table.toggleAllRowsExpanded();
+        };
+      };
+      table.getIsSomeRowsExpanded = () => {
+        const expanded = table.getState().expanded;
+        return expanded === true || Object.values(expanded).some(Boolean);
+      };
+      table.getIsAllRowsExpanded = () => {
+        const expanded = table.getState().expanded;
+
+        // If expanded is true, save some cycles and return true
+        if (typeof expanded === 'boolean') {
+          return expanded === true;
         }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.columnDef.getGroupingValue)) {
-          return row.getValue(columnId);
+        if (!Object.keys(expanded).length) {
+          return false;
         }
-        row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(row.original);
-        return row._groupingValuesCache[columnId];
-      };
-      row._groupingValuesCache = {};
-    },
-    createCell: (cell, column, row, table) => {
-      cell.getIsGrouped = () => column.getIsGrouped() && column.id === row.groupingColumnId;
-      cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped();
-      cell.getIsAggregated = () => {
-        var _row$subRows;
-        return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
-      };
-    }
-  };
-  function orderColumns(leafColumns, grouping, groupedColumnMode) {
-    if (!(grouping != null && grouping.length) || !groupedColumnMode) {
-      return leafColumns;
-    }
-    const nonGroupingColumns = leafColumns.filter(col => !grouping.includes(col.id));
-    if (groupedColumnMode === 'remove') {
-      return nonGroupingColumns;
-    }
-    const groupingColumns = grouping.map(g => leafColumns.find(col => col.id === g)).filter(Boolean);
-    return [...groupingColumns, ...nonGroupingColumns];
-  }
 
-  //
+        // If any row is not expanded, return false
+        if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
+          return false;
+        }
 
-  const Ordering = {
-    getInitialState: state => {
-      return {
-        columnOrder: [],
-        ...state
+        // They must all be expanded :shrug:
+        return true;
       };
-    },
-    getDefaultOptions: table => {
-      return {
-        onColumnOrderChange: makeStateUpdater('columnOrder', table)
+      table.getExpandedDepth = () => {
+        let maxDepth = 0;
+        const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded);
+        rowIds.forEach(id => {
+          const splitId = id.split('.');
+          maxDepth = Math.max(maxDepth, splitId.length);
+        });
+        return maxDepth;
+      };
+      table.getPreExpandedRowModel = () => table.getSortedRowModel();
+      table.getExpandedRowModel = () => {
+        if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
+          table._getExpandedRowModel = table.options.getExpandedRowModel(table);
+        }
+        if (table.options.manualExpanding || !table._getExpandedRowModel) {
+          return table.getPreExpandedRowModel();
+        }
+        return table._getExpandedRowModel();
       };
     },
-    createColumn: (column, table) => {
-      column.getIndex = memo(position => [_getVisibleLeafColumns(table, position)], columns => columns.findIndex(d => d.id === column.id), getMemoOptions(table.options, 'debugColumns', 'getIndex'));
-      column.getIsFirstColumn = position => {
-        var _columns$;
-        const columns = _getVisibleLeafColumns(table, position);
-        return ((_columns$ = columns[0]) == null ? void 0 : _columns$.id) === column.id;
+    createRow: (row, table) => {
+      row.toggleExpanded = expanded => {
+        table.setExpanded(old => {
+          var _expanded;
+          const exists = old === true ? true : !!(old != null && old[row.id]);
+          let oldExpanded = {};
+          if (old === true) {
+            Object.keys(table.getRowModel().rowsById).forEach(rowId => {
+              oldExpanded[rowId] = true;
+            });
+          } else {
+            oldExpanded = old;
+          }
+          expanded = (_expanded = expanded) != null ? _expanded : !exists;
+          if (!exists && expanded) {
+            return {
+              ...oldExpanded,
+              [row.id]: true
+            };
+          }
+          if (exists && !expanded) {
+            const {
+              [row.id]: _,
+              ...rest
+            } = oldExpanded;
+            return rest;
+          }
+          return old;
+        });
       };
-      column.getIsLastColumn = position => {
-        var _columns;
-        const columns = _getVisibleLeafColumns(table, position);
-        return ((_columns = columns[columns.length - 1]) == null ? void 0 : _columns.id) === column.id;
+      row.getIsExpanded = () => {
+        var _table$options$getIsR;
+        const expanded = table.getState().expanded;
+        return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id]));
       };
-    },
-    createTable: table => {
-      table.setColumnOrder = updater => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater);
-      table.resetColumnOrder = defaultState => {
-        var _table$initialState$c;
-        table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []);
+      row.getCanExpand = () => {
+        var _table$options$getRow, _table$options$enable, _row$subRows;
+        return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
       };
-      table._getOrderColumnsFn = memo(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => {
-        // Sort grouped columns to the start of the column list
-        // before the headers are built
-        let orderedColumns = [];
-
-        // If there is no order, return the normal columns
-        if (!(columnOrder != null && columnOrder.length)) {
-          orderedColumns = columns;
-        } else {
-          const columnOrderCopy = [...columnOrder];
-
-          // If there is an order, make a copy of the columns
-          const columnsCopy = [...columns];
-
-          // And make a new ordered array of the columns
-
-          // Loop over the columns and place them in order into the new array
-          while (columnsCopy.length && columnOrderCopy.length) {
-            const targetColumnId = columnOrderCopy.shift();
-            const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId);
-            if (foundIndex > -1) {
-              orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]);
-            }
-          }
-
-          // If there are any columns left, add them to the end
-          orderedColumns = [...orderedColumns, ...columnsCopy];
+      row.getIsAllParentsExpanded = () => {
+        let isFullyExpanded = true;
+        let currentRow = row;
+        while (isFullyExpanded && currentRow.parentId) {
+          currentRow = table.getRow(currentRow.parentId, true);
+          isFullyExpanded = currentRow.getIsExpanded();
         }
-        return orderColumns(orderedColumns, grouping, groupedColumnMode);
-      }, getMemoOptions(table.options, 'debugTable', '_getOrderColumnsFn'));
+        return isFullyExpanded;
+      };
+      row.getToggleExpandedHandler = () => {
+        const canExpand = row.getCanExpand();
+        return () => {
+          if (!canExpand) return;
+          row.toggleExpanded();
+        };
+      };
     }
   };
 
@@ -1437,7 +1809,7 @@
     pageIndex: defaultPageIndex,
     pageSize: defaultPageSize
   });
-  const Pagination = {
+  const RowPagination = {
     getInitialState: state => {
       return {
         ...state,
@@ -1584,88 +1956,34 @@
 
   //
 
-  const getDefaultColumnPinningState = () => ({
-    left: [],
-    right: []
-  });
   const getDefaultRowPinningState = () => ({
     top: [],
     bottom: []
   });
-  const Pinning = {
+  const RowPinning = {
     getInitialState: state => {
       return {
-        columnPinning: getDefaultColumnPinningState(),
         rowPinning: getDefaultRowPinningState(),
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onColumnPinningChange: makeStateUpdater('columnPinning', table),
         onRowPinningChange: makeStateUpdater('rowPinning', table)
       };
     },
-    createColumn: (column, table) => {
-      column.pin = position => {
-        const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean);
-        table.setColumnPinning(old => {
-          var _old$left3, _old$right3;
-          if (position === 'right') {
-            var _old$left, _old$right;
-            return {
-              left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter(d => !(columnIds != null && columnIds.includes(d))),
-              right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
-            };
-          }
-          if (position === 'left') {
-            var _old$left2, _old$right2;
-            return {
-              left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
-              right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
-            };
-          }
-          return {
-            left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter(d => !(columnIds != null && columnIds.includes(d))),
-            right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
-          };
-        });
-      };
-      column.getCanPin = () => {
-        const leafColumns = column.getLeafColumns();
-        return leafColumns.some(d => {
-          var _d$columnDef$enablePi, _ref, _table$options$enable;
-          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true);
-        });
-      };
-      column.getIsPinned = () => {
-        const leafColumnIds = column.getLeafColumns().map(d => d.id);
-        const {
-          left,
-          right
-        } = table.getState().columnPinning;
-        const isLeft = leafColumnIds.some(d => left == null ? void 0 : left.includes(d));
-        const isRight = leafColumnIds.some(d => right == null ? void 0 : right.includes(d));
-        return isLeft ? 'left' : isRight ? 'right' : false;
-      };
-      column.getPinnedIndex = () => {
-        var _table$getState$colum, _table$getState$colum2;
-        const position = column.getIsPinned();
-        return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null || (_table$getState$colum2 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0;
-      };
-    },
     createRow: (row, table) => {
       row.pin = (position, includeLeafRows, includeParentRows) => {
-        const leafRowIds = includeLeafRows ? row.getLeafRows().map(_ref2 => {
+        const leafRowIds = includeLeafRows ? row.getLeafRows().map(_ref => {
           let {
             id
-          } = _ref2;
+          } = _ref;
           return id;
         }) : [];
-        const parentRowIds = includeParentRows ? row.getParentRows().map(_ref3 => {
+        const parentRowIds = includeParentRows ? row.getParentRows().map(_ref2 => {
           let {
             id
-          } = _ref3;
+          } = _ref2;
           return id;
         }) : [];
         const rowIds = new Set([...parentRowIds, row.id, ...leafRowIds]);
@@ -1692,7 +2010,7 @@
         });
       };
       row.getCanPin = () => {
-        var _ref4;
+        var _ref3;
         const {
           enableRowPinning,
           enablePinning
@@ -1700,7 +2018,7 @@
         if (typeof enableRowPinning === 'function') {
           return enableRowPinning(row);
         }
-        return (_ref4 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref4 : true;
+        return (_ref3 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref3 : true;
       };
       row.getIsPinned = () => {
         const rowIds = [row.id];
@@ -1715,72 +2033,30 @@
       row.getPinnedIndex = () => {
         var _table$_getPinnedRows, _visiblePinnedRowIds$;
         const position = row.getIsPinned();
-        if (!position) return -1;
-        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref5 => {
-          let {
-            id
-          } = _ref5;
-          return id;
-        });
-        return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1;
-      };
-      row.getCenterVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
-        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
-        return allCells.filter(d => !leftAndRight.includes(d.column.id));
-      }, getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells'));
-      row.getLeftVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left], (allCells, left) => {
-        const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
-          ...d,
-          position: 'left'
-        }));
-        return cells;
-      }, getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells'));
-      row.getRightVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
-        const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
-          ...d,
-          position: 'right'
-        }));
-        return cells;
-      }, getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells'));
-    },
-    createTable: table => {
-      table.setColumnPinning = updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater);
-      table.resetColumnPinning = defaultState => {
-        var _table$initialState$c, _table$initialState;
-        return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState());
-      };
-      table.getIsSomeColumnsPinned = position => {
-        var _pinningState$positio;
-        const pinningState = table.getState().columnPinning;
-        if (!position) {
-          var _pinningState$left, _pinningState$right;
-          return Boolean(((_pinningState$left = pinningState.left) == null ? void 0 : _pinningState$left.length) || ((_pinningState$right = pinningState.right) == null ? void 0 : _pinningState$right.length));
-        }
-        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
+        if (!position) return -1;
+        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref4 => {
+          let {
+            id
+          } = _ref4;
+          return id;
+        });
+        return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1;
       };
-      table.getLeftLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => {
-        return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
-      }, getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns'));
-      table.getRightLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => {
-        return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
-      }, getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns'));
-      table.getCenterLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => {
-        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
-        return allColumns.filter(d => !leftAndRight.includes(d.id));
-      }, getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns'));
+    },
+    createTable: table => {
       table.setRowPinning = updater => table.options.onRowPinningChange == null ? void 0 : table.options.onRowPinningChange(updater);
       table.resetRowPinning = defaultState => {
-        var _table$initialState$r, _table$initialState2;
-        return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState2 = table.initialState) == null ? void 0 : _table$initialState2.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState());
+        var _table$initialState$r, _table$initialState;
+        return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState());
       };
       table.getIsSomeRowsPinned = position => {
-        var _pinningState$positio2;
+        var _pinningState$positio;
         const pinningState = table.getState().rowPinning;
         if (!position) {
           var _pinningState$top, _pinningState$bottom;
           return Boolean(((_pinningState$top = pinningState.top) == null ? void 0 : _pinningState$top.length) || ((_pinningState$bottom = pinningState.bottom) == null ? void 0 : _pinningState$bottom.length));
         }
-        return Boolean((_pinningState$positio2 = pinningState[position]) == null ? void 0 : _pinningState$positio2.length);
+        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
       };
       table._getPinnedRows = memo(position => [table.getRowModel().rows, table.getState().rowPinning[position], position], (visibleRows, pinnedRowIds, position) => {
         var _table$options$keepPi;
@@ -2286,7 +2562,7 @@
 
   //
 
-  const Sorting = {
+  const RowSorting = {
     getInitialState: state => {
       return {
         sorting: [],
@@ -2493,99 +2769,22 @@
     }
   };
 
-  //
-
-  const Visibility = {
-    getInitialState: state => {
-      return {
-        columnVisibility: {},
-        ...state
-      };
-    },
-    getDefaultOptions: table => {
-      return {
-        onColumnVisibilityChange: makeStateUpdater('columnVisibility', table)
-      };
-    },
-    createColumn: (column, table) => {
-      column.toggleVisibility = value => {
-        if (column.getCanHide()) {
-          table.setColumnVisibility(old => ({
-            ...old,
-            [column.id]: value != null ? value : !column.getIsVisible()
-          }));
-        }
-      };
-      column.getIsVisible = () => {
-        var _ref, _table$getState$colum;
-        const childColumns = column.columns;
-        return (_ref = childColumns.length ? childColumns.some(c => c.getIsVisible()) : (_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) != null ? _ref : true;
-      };
-      column.getCanHide = () => {
-        var _column$columnDef$ena, _table$options$enable;
-        return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true);
-      };
-      column.getToggleVisibilityHandler = () => {
-        return e => {
-          column.toggleVisibility == null || column.toggleVisibility(e.target.checked);
-        };
-      };
-    },
-    createRow: (row, table) => {
-      row._getAllVisibleCells = memo(() => [row.getAllCells(), table.getState().columnVisibility], cells => {
-        return cells.filter(cell => cell.column.getIsVisible());
-      }, getMemoOptions(table.options, 'debugRows', '_getAllVisibleCells'));
-      row.getVisibleCells = memo(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], getMemoOptions(table.options, 'debugRows', 'getVisibleCells'));
-    },
-    createTable: table => {
-      const makeVisibleColumnsMethod = (key, getColumns) => {
-        return memo(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => {
-          return columns.filter(d => d.getIsVisible == null ? void 0 : d.getIsVisible());
-        }, getMemoOptions(table.options, 'debugColumns', key));
-      };
-      table.getVisibleFlatColumns = makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns());
-      table.getVisibleLeafColumns = makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns());
-      table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns());
-      table.getRightVisibleLeafColumns = makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns());
-      table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns());
-      table.setColumnVisibility = updater => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater);
-      table.resetColumnVisibility = defaultState => {
-        var _table$initialState$c;
-        table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {});
-      };
-      table.toggleAllColumnsVisible = value => {
-        var _value;
-        value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible();
-        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
-          ...obj,
-          [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
-        }), {}));
-      };
-      table.getIsAllColumnsVisible = () => !table.getAllLeafColumns().some(column => !(column.getIsVisible != null && column.getIsVisible()));
-      table.getIsSomeColumnsVisible = () => table.getAllLeafColumns().some(column => column.getIsVisible == null ? void 0 : column.getIsVisible());
-      table.getToggleAllColumnsVisibilityHandler = () => {
-        return e => {
-          var _target;
-          table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
-        };
-      };
-    }
-  };
-  function _getVisibleLeafColumns(table, position) {
-    return !position ? table.getVisibleLeafColumns() : position === 'center' ? table.getCenterVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns();
-  }
-
-  const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing];
+  const builtInFeatures = [Headers, ColumnVisibility, ColumnOrdering, ColumnPinning, ColumnFaceting, ColumnFiltering, GlobalFiltering,
+  //depends on ColumnFiltering and ColumnFaceting
+  RowSorting, ColumnGrouping,
+  //depends on RowSorting
+  RowExpanding, RowPagination, RowPinning, RowSelection, ColumnSizing];
 
   //
 
   function createTable(options) {
-    var _options$initialState;
-    if (options.debugAll || options.debugTable) {
+    var _options$_features, _options$initialState;
+    if ((options.debugAll || options.debugTable)) {
       console.info('Creating Table Instance...');
     }
+    const _features = [...builtInFeatures, ...((_options$_features = options._features) != null ? _options$_features : [])];
     let table = {
-      _features: features
+      _features
     };
     const defaultOptions = table._features.reduce((obj, feature) => {
       return Object.assign(obj, feature.getDefaultOptions == null ? void 0 : feature.getDefaultOptions(table));
@@ -2611,7 +2810,7 @@
     const queued = [];
     let queuedTimeout = false;
     const coreInstance = {
-      _features: features,
+      _features,
       options: {
         ...defaultOptions,
         ...options
@@ -2674,232 +2873,77 @@
             }
           }
         }
-        return row;
-      },
-      _getDefaultColumnDef: memo(() => [table.options.defaultColumn], defaultColumn => {
-        var _defaultColumn;
-        defaultColumn = (_defaultColumn = defaultColumn) != null ? _defaultColumn : {};
-        return {
-          header: props => {
-            const resolvedColumnDef = props.header.column.columnDef;
-            if (resolvedColumnDef.accessorKey) {
-              return resolvedColumnDef.accessorKey;
-            }
-            if (resolvedColumnDef.accessorFn) {
-              return resolvedColumnDef.id;
-            }
-            return null;
-          },
-          // footer: props => props.header.column.id,
-          cell: props => {
-            var _props$renderValue$to, _props$renderValue;
-            return (_props$renderValue$to = (_props$renderValue = props.renderValue()) == null || _props$renderValue.toString == null ? void 0 : _props$renderValue.toString()) != null ? _props$renderValue$to : null;
-          },
-          ...table._features.reduce((obj, feature) => {
-            return Object.assign(obj, feature.getDefaultColumnDef == null ? void 0 : feature.getDefaultColumnDef());
-          }, {}),
-          ...defaultColumn
-        };
-      }, getMemoOptions(options, 'debugColumns', '_getDefaultColumnDef')),
-      _getColumnDefs: () => table.options.columns,
-      getAllColumns: memo(() => [table._getColumnDefs()], columnDefs => {
-        const recurseColumns = function (columnDefs, parent, depth) {
-          if (depth === void 0) {
-            depth = 0;
-          }
-          return columnDefs.map(columnDef => {
-            const column = createColumn(table, columnDef, depth, parent);
-            const groupingColumnDef = columnDef;
-            column.columns = groupingColumnDef.columns ? recurseColumns(groupingColumnDef.columns, column, depth + 1) : [];
-            return column;
-          });
-        };
-        return recurseColumns(columnDefs);
-      }, getMemoOptions(options, 'debugColumns', 'getAllColumns')),
-      getAllFlatColumns: memo(() => [table.getAllColumns()], allColumns => {
-        return allColumns.flatMap(column => {
-          return column.getFlatColumns();
-        });
-      }, getMemoOptions(options, 'debugColumns', 'getAllFlatColumns')),
-      _getAllFlatColumnsById: memo(() => [table.getAllFlatColumns()], flatColumns => {
-        return flatColumns.reduce((acc, column) => {
-          acc[column.id] = column;
-          return acc;
-        }, {});
-      }, getMemoOptions(options, 'debugColumns', 'getAllFlatColumnsById')),
-      getAllLeafColumns: memo(() => [table.getAllColumns(), table._getOrderColumnsFn()], (allColumns, orderColumns) => {
-        let leafColumns = allColumns.flatMap(column => column.getLeafColumns());
-        return orderColumns(leafColumns);
-      }, getMemoOptions(options, 'debugColumns', 'getAllLeafColumns')),
-      getColumn: columnId => {
-        const column = table._getAllFlatColumnsById()[columnId];
-        if (!column) {
-          console.error(`[Table] Column with id '${columnId}' does not exist.`);
-        }
-        return column;
-      }
-    };
-    Object.assign(table, coreInstance);
-    for (let index = 0; index < table._features.length; index++) {
-      const feature = table._features[index];
-      feature == null || feature.createTable == null || feature.createTable(table);
-    }
-    return table;
-  }
-
-  function createCell(table, row, column, columnId) {
-    const getRenderValue = () => {
-      var _cell$getValue;
-      return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue;
-    };
-    const cell = {
-      id: `${row.id}_${column.id}`,
-      row,
-      column,
-      getValue: () => row.getValue(columnId),
-      renderValue: getRenderValue,
-      getContext: memo(() => [table, column, row, cell], (table, column, row, cell) => ({
-        table,
-        column,
-        row,
-        cell: cell,
-        getValue: cell.getValue,
-        renderValue: cell.renderValue
-      }), getMemoOptions(table.options, 'debugCells', 'cell.getContext'))
-    };
-    table._features.forEach(feature => {
-      feature.createCell == null || feature.createCell(cell, column, row, table);
-    }, {});
-    return cell;
-  }
-
-  const createRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
-    let row = {
-      id,
-      index: rowIndex,
-      original,
-      depth,
-      parentId,
-      _valuesCache: {},
-      _uniqueValuesCache: {},
-      getValue: columnId => {
-        if (row._valuesCache.hasOwnProperty(columnId)) {
-          return row._valuesCache[columnId];
-        }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.accessorFn)) {
-          return undefined;
-        }
-        row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex);
-        return row._valuesCache[columnId];
-      },
-      getUniqueValues: columnId => {
-        if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
-          return row._uniqueValuesCache[columnId];
-        }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.accessorFn)) {
-          return undefined;
-        }
-        if (!column.columnDef.getUniqueValues) {
-          row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
-          return row._uniqueValuesCache[columnId];
-        }
-        row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex);
-        return row._uniqueValuesCache[columnId];
-      },
-      renderValue: columnId => {
-        var _row$getValue;
-        return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
-      },
-      subRows: subRows != null ? subRows : [],
-      getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
-      getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : undefined,
-      getParentRows: () => {
-        let parentRows = [];
-        let currentRow = row;
-        while (true) {
-          const parentRow = currentRow.getParentRow();
-          if (!parentRow) break;
-          parentRows.push(parentRow);
-          currentRow = parentRow;
-        }
-        return parentRows.reverse();
-      },
-      getAllCells: memo(() => [table.getAllLeafColumns()], leafColumns => {
-        return leafColumns.map(column => {
-          return createCell(table, row, column, column.id);
+        return row;
+      },
+      _getDefaultColumnDef: memo(() => [table.options.defaultColumn], defaultColumn => {
+        var _defaultColumn;
+        defaultColumn = (_defaultColumn = defaultColumn) != null ? _defaultColumn : {};
+        return {
+          header: props => {
+            const resolvedColumnDef = props.header.column.columnDef;
+            if (resolvedColumnDef.accessorKey) {
+              return resolvedColumnDef.accessorKey;
+            }
+            if (resolvedColumnDef.accessorFn) {
+              return resolvedColumnDef.id;
+            }
+            return null;
+          },
+          // footer: props => props.header.column.id,
+          cell: props => {
+            var _props$renderValue$to, _props$renderValue;
+            return (_props$renderValue$to = (_props$renderValue = props.renderValue()) == null || _props$renderValue.toString == null ? void 0 : _props$renderValue.toString()) != null ? _props$renderValue$to : null;
+          },
+          ...table._features.reduce((obj, feature) => {
+            return Object.assign(obj, feature.getDefaultColumnDef == null ? void 0 : feature.getDefaultColumnDef());
+          }, {}),
+          ...defaultColumn
+        };
+      }, getMemoOptions(options, 'debugColumns', '_getDefaultColumnDef')),
+      _getColumnDefs: () => table.options.columns,
+      getAllColumns: memo(() => [table._getColumnDefs()], columnDefs => {
+        const recurseColumns = function (columnDefs, parent, depth) {
+          if (depth === void 0) {
+            depth = 0;
+          }
+          return columnDefs.map(columnDef => {
+            const column = createColumn(table, columnDef, depth, parent);
+            const groupingColumnDef = columnDef;
+            column.columns = groupingColumnDef.columns ? recurseColumns(groupingColumnDef.columns, column, depth + 1) : [];
+            return column;
+          });
+        };
+        return recurseColumns(columnDefs);
+      }, getMemoOptions(options, 'debugColumns', 'getAllColumns')),
+      getAllFlatColumns: memo(() => [table.getAllColumns()], allColumns => {
+        return allColumns.flatMap(column => {
+          return column.getFlatColumns();
         });
-      }, getMemoOptions(table.options, 'debugRows', 'getAllCells')),
-      _getAllCellsByColumnId: memo(() => [row.getAllCells()], allCells => {
-        return allCells.reduce((acc, cell) => {
-          acc[cell.column.id] = cell;
+      }, getMemoOptions(options, 'debugColumns', 'getAllFlatColumns')),
+      _getAllFlatColumnsById: memo(() => [table.getAllFlatColumns()], flatColumns => {
+        return flatColumns.reduce((acc, column) => {
+          acc[column.id] = column;
           return acc;
         }, {});
-      }, getMemoOptions(table.options, 'debugRows', 'getAllCellsByColumnId'))
+      }, getMemoOptions(options, 'debugColumns', 'getAllFlatColumnsById')),
+      getAllLeafColumns: memo(() => [table.getAllColumns(), table._getOrderColumnsFn()], (allColumns, orderColumns) => {
+        let leafColumns = allColumns.flatMap(column => column.getLeafColumns());
+        return orderColumns(leafColumns);
+      }, getMemoOptions(options, 'debugColumns', 'getAllLeafColumns')),
+      getColumn: columnId => {
+        const column = table._getAllFlatColumnsById()[columnId];
+        if (!column) {
+          console.error(`[Table] Column with id '${columnId}' does not exist.`);
+        }
+        return column;
+      }
     };
-    for (let i = 0; i < table._features.length; i++) {
-      const feature = table._features[i];
-      feature == null || feature.createRow == null || feature.createRow(row, table);
+    Object.assign(table, coreInstance);
+    for (let index = 0; index < table._features.length; index++) {
+      const feature = table._features[index];
+      feature == null || feature.createTable == null || feature.createTable(table);
     }
-    return row;
-  };
-
-  // type Person = {
-  //   firstName: string
-  //   lastName: string
-  //   age: number
-  //   visits: number
-  //   status: string
-  //   progress: number
-  //   createdAt: Date
-  //   nested: {
-  //     foo: [
-  //       {
-  //         bar: 'bar'
-  //       }
-  //     ]
-  //     bar: { subBar: boolean }[]
-  //     baz: {
-  //       foo: 'foo'
-  //       bar: {
-  //         baz: 'baz'
-  //       }
-  //     }
-  //   }
-  // }
-
-  // const test: DeepKeys<Person> = 'nested.foo.0.bar'
-  // const test2: DeepKeys<Person> = 'nested.bar'
-
-  // const helper = createColumnHelper<Person>()
-
-  // helper.accessor('nested.foo', {
-  //   cell: info => info.getValue(),
-  // })
-
-  // helper.accessor('nested.foo.0.bar', {
-  //   cell: info => info.getValue(),
-  // })
-
-  // helper.accessor('nested.bar', {
-  //   cell: info => info.getValue(),
-  // })
-
-  function createColumnHelper() {
-    return {
-      accessor: (accessor, column) => {
-        return typeof accessor === 'function' ? {
-          ...column,
-          accessorFn: accessor
-        } : {
-          ...column,
-          accessorKey: accessor
-        };
-      },
-      display: column => column,
-      group: column => column
-    };
+    return table;
   }
 
   function getCoreRowModel() {
@@ -2950,6 +2994,62 @@
     }, getMemoOptions(table.options, 'debugTable', 'getRowModel', () => table._autoResetPageIndex()));
   }
 
+  function getExpandedRowModel() {
+    return table => memo(() => [table.getState().expanded, table.getPreExpandedRowModel(), table.options.paginateExpandedRows], (expanded, rowModel, paginateExpandedRows) => {
+      if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
+        return rowModel;
+      }
+      if (!paginateExpandedRows) {
+        // Only expand rows at this point if they are being paginated
+        return rowModel;
+      }
+      return expandRows(rowModel);
+    }, getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel'));
+  }
+  function expandRows(rowModel) {
+    const expandedRows = [];
+    const handleRow = row => {
+      var _row$subRows;
+      expandedRows.push(row);
+      if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
+        row.subRows.forEach(handleRow);
+      }
+    };
+    rowModel.rows.forEach(handleRow);
+    return {
+      rows: expandedRows,
+      flatRows: rowModel.flatRows,
+      rowsById: rowModel.rowsById
+    };
+  }
+
+  function getFacetedMinMaxValues() {
+    return (table, columnId) => memo(() => {
+      var _table$getColumn;
+      return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
+    }, facetedRowModel => {
+      var _facetedRowModel$flat;
+      if (!facetedRowModel) return undefined;
+      const firstValue = (_facetedRowModel$flat = facetedRowModel.flatRows[0]) == null ? void 0 : _facetedRowModel$flat.getUniqueValues(columnId);
+      if (typeof firstValue === 'undefined') {
+        return undefined;
+      }
+      let facetedMinMaxValues = [firstValue, firstValue];
+      for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
+        const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
+        for (let j = 0; j < values.length; j++) {
+          const value = values[j];
+          if (value < facetedMinMaxValues[0]) {
+            facetedMinMaxValues[0] = value;
+          } else if (value > facetedMinMaxValues[1]) {
+            facetedMinMaxValues[1] = value;
+          }
+        }
+      }
+      return facetedMinMaxValues;
+    }, getMemoOptions(table.options, 'debugTable', 'getFacetedMinMaxValues'));
+  }
+
   function filterRows(rows, filterRowImpl, table) {
     if (table.options.filterFromLeafRows) {
       return filterRowModelFromLeafs(rows, filterRowImpl, table);
@@ -3045,6 +3145,48 @@
     };
   }
 
+  function getFacetedRowModel() {
+    return (table, columnId) => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter, table.getFilteredRowModel()], (preRowModel, columnFilters, globalFilter) => {
+      if (!preRowModel.rows.length || !(columnFilters != null && columnFilters.length) && !globalFilter) {
+        return preRowModel;
+      }
+      const filterableIds = [...columnFilters.map(d => d.id).filter(d => d !== columnId), globalFilter ? '__global__' : undefined].filter(Boolean);
+      const filterRowsImpl = row => {
+        // Horizontally filter rows through each column
+        for (let i = 0; i < filterableIds.length; i++) {
+          if (row.columnFilters[filterableIds[i]] === false) {
+            return false;
+          }
+        }
+        return true;
+      };
+      return filterRows(preRowModel.rows, filterRowsImpl, table);
+    }, getMemoOptions(table.options, 'debugTable', 'getFacetedRowModel'));
+  }
+
+  function getFacetedUniqueValues() {
+    return (table, columnId) => memo(() => {
+      var _table$getColumn;
+      return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
+    }, facetedRowModel => {
+      if (!facetedRowModel) return new Map();
+      let facetedUniqueValues = new Map();
+      for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
+        const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
+        for (let j = 0; j < values.length; j++) {
+          const value = values[j];
+          if (facetedUniqueValues.has(value)) {
+            var _facetedUniqueValues$;
+            facetedUniqueValues.set(value, ((_facetedUniqueValues$ = facetedUniqueValues.get(value)) != null ? _facetedUniqueValues$ : 0) + 1);
+          } else {
+            facetedUniqueValues.set(value, 1);
+          }
+        }
+      }
+      return facetedUniqueValues;
+    }, getMemoOptions(table.options, 'debugTable', `getFacetedUniqueValues_${columnId}`));
+  }
+
   function getFilteredRowModel() {
     return table => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter], (rowModel, columnFilters, globalFilter) => {
       if (!rowModel.rows.length || !(columnFilters != null && columnFilters.length) && !globalFilter) {
@@ -3117,34 +3259,13 @@
             })) {
               row.columnFilters.__global__ = true;
               break;
-            }
-          }
-          if (row.columnFilters.__global__ !== true) {
-            row.columnFilters.__global__ = false;
-          }
-        }
-      }
-      const filterRowsImpl = row => {
-        // Horizontally filter rows through each column
-        for (let i = 0; i < filterableIds.length; i++) {
-          if (row.columnFilters[filterableIds[i]] === false) {
-            return false;
-          }
-        }
-        return true;
-      };
-
-      // Filter final rows using all of the active filters
-      return filterRows(rowModel.rows, filterRowsImpl, table);
-    }, getMemoOptions(table.options, 'debugTable', 'getFilteredRowModel', () => table._autoResetPageIndex()));
-  }
-
-  function getFacetedRowModel() {
-    return (table, columnId) => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter, table.getFilteredRowModel()], (preRowModel, columnFilters, globalFilter) => {
-      if (!preRowModel.rows.length || !(columnFilters != null && columnFilters.length) && !globalFilter) {
-        return preRowModel;
+            }
+          }
+          if (row.columnFilters.__global__ !== true) {
+            row.columnFilters.__global__ = false;
+          }
+        }
       }
-      const filterableIds = [...columnFilters.map(d => d.id).filter(d => d !== columnId), globalFilter ? '__global__' : undefined].filter(Boolean);
       const filterRowsImpl = row => {
         // Horizontally filter rows through each column
         for (let i = 0; i < filterableIds.length; i++) {
@@ -3154,141 +3275,10 @@
         }
         return true;
       };
-      return filterRows(preRowModel.rows, filterRowsImpl, table);
-    }, getMemoOptions(table.options, 'debugTable', 'getFacetedRowModel'));
-  }
-
-  function getFacetedUniqueValues() {
-    return (table, columnId) => memo(() => {
-      var _table$getColumn;
-      return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
-    }, facetedRowModel => {
-      if (!facetedRowModel) return new Map();
-      let facetedUniqueValues = new Map();
-      for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
-        const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
-        for (let j = 0; j < values.length; j++) {
-          const value = values[j];
-          if (facetedUniqueValues.has(value)) {
-            var _facetedUniqueValues$;
-            facetedUniqueValues.set(value, ((_facetedUniqueValues$ = facetedUniqueValues.get(value)) != null ? _facetedUniqueValues$ : 0) + 1);
-          } else {
-            facetedUniqueValues.set(value, 1);
-          }
-        }
-      }
-      return facetedUniqueValues;
-    }, getMemoOptions(table.options, 'debugTable', `getFacetedUniqueValues_${columnId}`));
-  }
-
-  function getFacetedMinMaxValues() {
-    return (table, columnId) => memo(() => {
-      var _table$getColumn;
-      return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
-    }, facetedRowModel => {
-      var _facetedRowModel$flat;
-      if (!facetedRowModel) return undefined;
-      const firstValue = (_facetedRowModel$flat = facetedRowModel.flatRows[0]) == null ? void 0 : _facetedRowModel$flat.getUniqueValues(columnId);
-      if (typeof firstValue === 'undefined') {
-        return undefined;
-      }
-      let facetedMinMaxValues = [firstValue, firstValue];
-      for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
-        const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
-        for (let j = 0; j < values.length; j++) {
-          const value = values[j];
-          if (value < facetedMinMaxValues[0]) {
-            facetedMinMaxValues[0] = value;
-          } else if (value > facetedMinMaxValues[1]) {
-            facetedMinMaxValues[1] = value;
-          }
-        }
-      }
-      return facetedMinMaxValues;
-    }, getMemoOptions(table.options, 'debugTable', 'getFacetedMinMaxValues'));
-  }
-
-  function getSortedRowModel() {
-    return table => memo(() => [table.getState().sorting, table.getPreSortedRowModel()], (sorting, rowModel) => {
-      if (!rowModel.rows.length || !(sorting != null && sorting.length)) {
-        return rowModel;
-      }
-      const sortingState = table.getState().sorting;
-      const sortedFlatRows = [];
-
-      // Filter out sortings that correspond to non existing columns
-      const availableSorting = sortingState.filter(sort => {
-        var _table$getColumn;
-        return (_table$getColumn = table.getColumn(sort.id)) == null ? void 0 : _table$getColumn.getCanSort();
-      });
-      const columnInfoById = {};
-      availableSorting.forEach(sortEntry => {
-        const column = table.getColumn(sortEntry.id);
-        if (!column) return;
-        columnInfoById[sortEntry.id] = {
-          sortUndefined: column.columnDef.sortUndefined,
-          invertSorting: column.columnDef.invertSorting,
-          sortingFn: column.getSortingFn()
-        };
-      });
-      const sortData = rows => {
-        // This will also perform a stable sorting using the row index
-        // if needed.
-        const sortedData = rows.map(row => ({
-          ...row
-        }));
-        sortedData.sort((rowA, rowB) => {
-          for (let i = 0; i < availableSorting.length; i += 1) {
-            var _sortEntry$desc;
-            const sortEntry = availableSorting[i];
-            const columnInfo = columnInfoById[sortEntry.id];
-            const isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
-            let sortInt = 0;
-
-            // All sorting ints should always return in ascending order
-            if (columnInfo.sortUndefined) {
-              const aValue = rowA.getValue(sortEntry.id);
-              const bValue = rowB.getValue(sortEntry.id);
-              const aUndefined = aValue === undefined;
-              const bUndefined = bValue === undefined;
-              if (aUndefined || bUndefined) {
-                sortInt = aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
-              }
-            }
-            if (sortInt === 0) {
-              sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
-            }
-
-            // If sorting is non-zero, take care of desc and inversion
-            if (sortInt !== 0) {
-              if (isDesc) {
-                sortInt *= -1;
-              }
-              if (columnInfo.invertSorting) {
-                sortInt *= -1;
-              }
-              return sortInt;
-            }
-          }
-          return rowA.index - rowB.index;
-        });
 
-        // If there are sub-rows, sort them
-        sortedData.forEach(row => {
-          var _row$subRows;
-          sortedFlatRows.push(row);
-          if ((_row$subRows = row.subRows) != null && _row$subRows.length) {
-            row.subRows = sortData(row.subRows);
-          }
-        });
-        return sortedData;
-      };
-      return {
-        rows: sortData(rowModel.rows),
-        flatRows: sortedFlatRows,
-        rowsById: rowModel.rowsById
-      };
-    }, getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () => table._autoResetPageIndex()));
+      // Filter final rows using all of the active filters
+      return filterRows(rowModel.rows, filterRowsImpl, table);
+    }, getMemoOptions(table.options, 'debugTable', 'getFilteredRowModel', () => table._autoResetPageIndex()));
   }
 
   function getGroupedRowModel() {
@@ -3424,35 +3414,6 @@
     }, groupMap);
   }
 
-  function getExpandedRowModel() {
-    return table => memo(() => [table.getState().expanded, table.getPreExpandedRowModel(), table.options.paginateExpandedRows], (expanded, rowModel, paginateExpandedRows) => {
-      if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
-        return rowModel;
-      }
-      if (!paginateExpandedRows) {
-        // Only expand rows at this point if they are being paginated
-        return rowModel;
-      }
-      return expandRows(rowModel);
-    }, getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel'));
-  }
-  function expandRows(rowModel) {
-    const expandedRows = [];
-    const handleRow = row => {
-      var _row$subRows;
-      expandedRows.push(row);
-      if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
-        row.subRows.forEach(handleRow);
-      }
-    };
-    rowModel.rows.forEach(handleRow);
-    return {
-      rows: expandedRows,
-      flatRows: rowModel.flatRows,
-      rowsById: rowModel.rowsById
-    };
-  }
-
   function getPaginationRowModel(opts) {
     return table => memo(() => [table.getState().pagination, table.getPrePaginationRowModel(), table.options.paginateExpandedRows ? undefined : table.getState().expanded], (pagination, rowModel) => {
       if (!rowModel.rows.length) {
@@ -3496,6 +3457,89 @@
     }, getMemoOptions(table.options, 'debugTable', 'getPaginationRowModel'));
   }
 
+  function getSortedRowModel() {
+    return table => memo(() => [table.getState().sorting, table.getPreSortedRowModel()], (sorting, rowModel) => {
+      if (!rowModel.rows.length || !(sorting != null && sorting.length)) {
+        return rowModel;
+      }
+      const sortingState = table.getState().sorting;
+      const sortedFlatRows = [];
+
+      // Filter out sortings that correspond to non existing columns
+      const availableSorting = sortingState.filter(sort => {
+        var _table$getColumn;
+        return (_table$getColumn = table.getColumn(sort.id)) == null ? void 0 : _table$getColumn.getCanSort();
+      });
+      const columnInfoById = {};
+      availableSorting.forEach(sortEntry => {
+        const column = table.getColumn(sortEntry.id);
+        if (!column) return;
+        columnInfoById[sortEntry.id] = {
+          sortUndefined: column.columnDef.sortUndefined,
+          invertSorting: column.columnDef.invertSorting,
+          sortingFn: column.getSortingFn()
+        };
+      });
+      const sortData = rows => {
+        // This will also perform a stable sorting using the row index
+        // if needed.
+        const sortedData = rows.map(row => ({
+          ...row
+        }));
+        sortedData.sort((rowA, rowB) => {
+          for (let i = 0; i < availableSorting.length; i += 1) {
+            var _sortEntry$desc;
+            const sortEntry = availableSorting[i];
+            const columnInfo = columnInfoById[sortEntry.id];
+            const isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
+            let sortInt = 0;
+
+            // All sorting ints should always return in ascending order
+            if (columnInfo.sortUndefined) {
+              const aValue = rowA.getValue(sortEntry.id);
+              const bValue = rowB.getValue(sortEntry.id);
+              const aUndefined = aValue === undefined;
+              const bUndefined = bValue === undefined;
+              if (aUndefined || bUndefined) {
+                sortInt = aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
+              }
+            }
+            if (sortInt === 0) {
+              sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
+            }
+
+            // If sorting is non-zero, take care of desc and inversion
+            if (sortInt !== 0) {
+              if (isDesc) {
+                sortInt *= -1;
+              }
+              if (columnInfo.invertSorting) {
+                sortInt *= -1;
+              }
+              return sortInt;
+            }
+          }
+          return rowA.index - rowB.index;
+        });
+
+        // If there are sub-rows, sort them
+        sortedData.forEach(row => {
+          var _row$subRows;
+          sortedFlatRows.push(row);
+          if ((_row$subRows = row.subRows) != null && _row$subRows.length) {
+            row.subRows = sortData(row.subRows);
+          }
+        });
+        return sortedData;
+      };
+      return {
+        rows: sortData(rowModel.rows),
+        flatRows: sortedFlatRows,
+        rowsById: rowModel.rowsById
+      };
+    }, getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () => table._autoResetPageIndex()));
+  }
+
   //
 
   /**
@@ -3554,17 +3598,20 @@
     return tableRef.current;
   }
 
+  exports.ColumnFaceting = ColumnFaceting;
+  exports.ColumnFiltering = ColumnFiltering;
+  exports.ColumnGrouping = ColumnGrouping;
+  exports.ColumnOrdering = ColumnOrdering;
+  exports.ColumnPinning = ColumnPinning;
   exports.ColumnSizing = ColumnSizing;
-  exports.Expanding = Expanding;
-  exports.Filters = Filters;
-  exports.Grouping = Grouping;
+  exports.ColumnVisibility = ColumnVisibility;
+  exports.GlobalFiltering = GlobalFiltering;
   exports.Headers = Headers;
-  exports.Ordering = Ordering;
-  exports.Pagination = Pagination;
-  exports.Pinning = Pinning;
+  exports.RowExpanding = RowExpanding;
+  exports.RowPagination = RowPagination;
+  exports.RowPinning = RowPinning;
   exports.RowSelection = RowSelection;
-  exports.Sorting = Sorting;
-  exports.Visibility = Visibility;
+  exports.RowSorting = RowSorting;
   exports._getVisibleLeafColumns = _getVisibleLeafColumns;
   exports.aggregationFns = aggregationFns;
   exports.buildHeaderGroups = buildHeaderGroups;