@tanstack/react-table 8.5.15 → 8.5.16

package/build/esm/index.js

@@ -21,17 +21,22 @@ import * as React from 'react';
  * @license MIT
  */
 // Is this type a tuple?
+
 // If this type is a tuple, what indices are allowed?
+
 ///
+
 function functionalUpdate(updater, input) {
   return typeof updater === 'function' ? updater(input) : updater;
 }
-function noop() {//
+function noop() {
+  //
 }
 function makeStateUpdater(key, instance) {
   return updater => {
     instance.setState(old => {
-      return { ...old,
+      return {
+        ...old,
         [key]: functionalUpdate(updater, old[key])
       };
     });
@@ -42,18 +47,15 @@ function isFunction(d) {
 }
 function flattenBy(arr, getChildren) {
   const flat = [];
-
   const recurse = subArr => {
     subArr.forEach(item => {
       flat.push(item);
       const children = getChildren(item);
-
       if (children != null && children.length) {
         recurse(children);
       }
     });
   };
-
   recurse(arr);
   return flat;
 }
@@ -65,54 +67,45 @@ function memo(getDeps, fn, opts) {
     if (opts.key && opts.debug) depTime = Date.now();
     const newDeps = getDeps();
     const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep);
-
     if (!depsChanged) {
       return result;
     }
-
     deps = newDeps;
     let resultTime;
     if (opts.key && opts.debug) resultTime = Date.now();
     result = fn(...newDeps);
     opts == null ? void 0 : opts.onChange == null ? void 0 : opts.onChange(result);
-
     if (opts.key && opts.debug) {
       if (opts != null && opts.debug()) {
         const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
         const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
         const resultFpsPercentage = resultEndTime / 16;
-
         const pad = (str, num) => {
           str = String(str);
-
           while (str.length < num) {
             str = ' ' + str;
           }
-
           return str;
         };
-
         console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
             font-size: .6rem;
             font-weight: bold;
             color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? void 0 : opts.key);
       }
     }
-
     return result;
   };
 }
 
 function createColumn(table, columnDef, depth, parent) {
   const defaultColumn = table._getDefaultColumnDef();
-
-  const resolvedColumnDef = { ...defaultColumn,
+  const resolvedColumnDef = {
+    ...defaultColumn,
     ...columnDef
   };
   const accessorKey = resolvedColumnDef.accessorKey;
   let id = resolvedColumnDef.id ?? (accessorKey ? accessorKey.replace('.', '_') : undefined) ?? (typeof resolvedColumnDef.header === 'string' ? resolvedColumnDef.header : undefined);
   let accessorFn;
-
   if (resolvedColumnDef.accessorFn) {
     accessorFn = resolvedColumnDef.accessorFn;
   } else if (accessorKey) {
@@ -120,26 +113,21 @@ function createColumn(table, columnDef, depth, parent) {
     if (accessorKey.includes('.')) {
       accessorFn = originalRow => {
         let result = originalRow;
-
         for (const key of accessorKey.split('.')) {
           result = result[key];
         }
-
         return result;
       };
     } else {
       accessorFn = originalRow => originalRow[resolvedColumnDef.accessorKey];
     }
   }
-
   if (!id) {
     if (process.env.NODE_ENV !== 'production') {
       throw new Error(resolvedColumnDef.accessorFn ? `Columns require an id when using an accessorFn` : `Columns require an id when using a non-string header`);
     }
-
     throw new Error();
   }
-
   let column = {
     id: `${String(id)}`,
     accessorFn,
@@ -149,7 +137,6 @@ function createColumn(table, columnDef, depth, parent) {
     columns: [],
     getFlatColumns: memo(() => [true], () => {
       var _column$columns;
-
       return [column, ...((_column$columns = column.columns) == null ? void 0 : _column$columns.flatMap(d => d.getFlatColumns()))];
     }, {
       key: process.env.NODE_ENV === 'production' && 'column.getFlatColumns',
@@ -157,12 +144,10 @@ function createColumn(table, columnDef, depth, parent) {
     }),
     getLeafColumns: memo(() => [table._getOrderColumnsFn()], orderColumns => {
       var _column$columns2;
-
       if ((_column$columns2 = column.columns) != null && _column$columns2.length) {
         let leafColumns = column.columns.flatMap(column => column.getLeafColumns());
         return orderColumns(leafColumns);
       }
-
       return [column];
     }, {
       key: process.env.NODE_ENV === 'production' && 'column.getLeafColumns',
@@ -171,12 +156,14 @@ function createColumn(table, columnDef, depth, parent) {
   };
   column = table._features.reduce((obj, feature) => {
     return Object.assign(obj, feature.createColumn == null ? void 0 : feature.createColumn(column, table));
-  }, column); // Yes, we have to convert table to uknown, because we know more than the compiler here.
+  }, column);
 
+  // Yes, we have to convert table to uknown, because we know more than the compiler here.
   return column;
 }
 
 //
+
 function createHeader(table, column, options) {
   const id = options.id ?? column.id;
   let header = {
@@ -192,15 +179,12 @@ function createHeader(table, column, options) {
     headerGroup: null,
     getLeafHeaders: () => {
       const leafHeaders = [];
-
       const recurseHeader = h => {
         if (h.subHeaders && h.subHeaders.length) {
           h.subHeaders.map(recurseHeader);
         }
-
         leafHeaders.push(h);
       };
-
       recurseHeader(header);
       return leafHeaders;
     },
@@ -210,18 +194,16 @@ function createHeader(table, column, options) {
       column
     })
   };
-
   table._features.forEach(feature => {
     Object.assign(header, feature.createHeader == null ? void 0 : feature.createHeader(header, table));
   });
-
   return header;
 }
-
 const Headers = {
   createTable: table => {
     return {
       // Header Groups
+
       getHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => {
         const leftColumns = (left == null ? void 0 : left.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) ?? [];
         const rightColumns = (right == null ? void 0 : right.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) ?? [];
@@ -254,6 +236,7 @@ const Headers = {
         debug: () => table.options.debugAll ?? table.options.debugHeaders
       }),
       // Footer Groups
+
       getFooterGroups: memo(() => [table.getHeaderGroups()], headerGroups => {
         return [...headerGroups].reverse();
       }, {
@@ -279,6 +262,7 @@ const Headers = {
         debug: () => table.options.debugAll ?? table.options.debugHeaders
       }),
       // Flat Headers
+
       getFlatHeaders: memo(() => [table.getHeaderGroups()], headerGroups => {
         return headerGroups.map(headerGroup => {
           return headerGroup.headers;
@@ -312,10 +296,10 @@ const Headers = {
         debug: () => table.options.debugAll ?? table.options.debugHeaders
       }),
       // Leaf Headers
+
       getCenterLeafHeaders: memo(() => [table.getCenterFlatHeaders()], flatHeaders => {
         return flatHeaders.filter(header => {
           var _header$subHeaders;
-
           return !((_header$subHeaders = header.subHeaders) != null && _header$subHeaders.length);
         });
       }, {
@@ -325,7 +309,6 @@ const Headers = {
       getLeftLeafHeaders: memo(() => [table.getLeftFlatHeaders()], flatHeaders => {
         return flatHeaders.filter(header => {
           var _header$subHeaders2;
-
           return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length);
         });
       }, {
@@ -335,7 +318,6 @@ const Headers = {
       getRightLeafHeaders: memo(() => [table.getRightFlatHeaders()], flatHeaders => {
         return flatHeaders.filter(header => {
           var _header$subHeaders3;
-
           return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length);
         });
       }, {
@@ -344,7 +326,6 @@ const Headers = {
       }),
       getLeafHeaders: memo(() => [table.getLeftHeaderGroups(), table.getCenterHeaderGroups(), table.getRightHeaderGroups()], (left, center, right) => {
         var _left$, _center$, _right$;
-
         return [...(((_left$ = left[0]) == null ? void 0 : _left$.headers) ?? []), ...(((_center$ = center[0]) == null ? void 0 : _center$.headers) ?? []), ...(((_right$ = right[0]) == null ? void 0 : _right$.headers) ?? [])].map(header => {
           return header.getLeafHeaders();
         }).flat();
@@ -357,49 +338,46 @@ const Headers = {
 };
 function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
   var _headerGroups$;
-
   // Find the max depth of the columns:
   // build the leaf column row
   // build each buffer row going up
   //    placeholder for non-existent level
   //    real column for existing level
-  let maxDepth = 0;
 
+  let maxDepth = 0;
   const findMaxDepth = function (columns, depth) {
     if (depth === void 0) {
       depth = 1;
     }
-
     maxDepth = Math.max(maxDepth, depth);
     columns.filter(column => column.getIsVisible()).forEach(column => {
       var _column$columns;
-
       if ((_column$columns = column.columns) != null && _column$columns.length) {
         findMaxDepth(column.columns, depth + 1);
       }
     }, 0);
   };
-
   findMaxDepth(allColumns);
   let headerGroups = [];
-
   const createHeaderGroup = (headersToGroup, depth) => {
     // The header group we are creating
     const headerGroup = {
       depth,
       id: [headerFamily, `${depth}`].filter(Boolean).join('_'),
       headers: []
-    }; // The parent columns we're going to scan next
+    };
 
-    const pendingParentHeaders = []; // Scan each column for parents
+    // The parent columns we're going to scan next
+    const pendingParentHeaders = [];
 
+    // Scan each column for parents
     headersToGroup.forEach(headerToGroup => {
       // What is the latest (last) parent column?
+
       const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0];
       const isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
       let column;
       let isPlaceholder = false;
-
       if (isLeafHeader && headerToGroup.column.parent) {
         // The parent header is new
         column = headerToGroup.column.parent;
@@ -408,7 +386,6 @@ function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
         column = headerToGroup.column;
         isPlaceholder = true;
       }
-
       if (latestPendingParentHeader && (latestPendingParentHeader == null ? void 0 : latestPendingParentHeader.column) === column) {
         // This column is repeated. Add it as a sub header to the next batch
         latestPendingParentHeader.subHeaders.push(headerToGroup);
@@ -420,30 +397,30 @@ function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
           placeholderId: isPlaceholder ? `${pendingParentHeaders.filter(d => d.column === column).length}` : undefined,
           depth,
           index: pendingParentHeaders.length
-        }); // Add the headerToGroup as a subHeader of the new header
+        });
 
-        header.subHeaders.push(headerToGroup); // Add the new header to the pendingParentHeaders to get grouped
+        // Add the headerToGroup as a subHeader of the new header
+        header.subHeaders.push(headerToGroup);
+        // Add the new header to the pendingParentHeaders to get grouped
         // in the next batch
-
         pendingParentHeaders.push(header);
       }
-
       headerGroup.headers.push(headerToGroup);
       headerToGroup.headerGroup = headerGroup;
     });
     headerGroups.push(headerGroup);
-
     if (depth > 0) {
       createHeaderGroup(pendingParentHeaders, depth - 1);
     }
   };
-
   const bottomHeaders = columnsToGroup.map((column, index) => createHeader(table, column, {
     depth: maxDepth,
     index
   }));
   createHeaderGroup(bottomHeaders, maxDepth - 1);
-  headerGroups.reverse(); // headerGroups = headerGroups.filter(headerGroup => {
+  headerGroups.reverse();
+
+  // headerGroups = headerGroups.filter(headerGroup => {
   //   return !headerGroup.headers.every(header => header.isPlaceholder)
   // })
 
@@ -453,7 +430,6 @@ function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
       let colSpan = 0;
       let rowSpan = 0;
       let childRowSpans = [0];
-
       if (header.subHeaders && header.subHeaders.length) {
         childRowSpans = [];
         recurseHeadersForSpans(header.subHeaders).forEach(_ref => {
@@ -467,7 +443,6 @@ function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
       } else {
         colSpan = 1;
       }
-
       const minChildRowSpan = Math.min(...childRowSpans);
       rowSpan = rowSpan + minChildRowSpan;
       header.colSpan = colSpan;
@@ -478,18 +453,17 @@ function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
       };
     });
   };
-
   recurseHeadersForSpans(((_headerGroups$ = headerGroups[0]) == null ? void 0 : _headerGroups$.headers) ?? []);
   return headerGroups;
 }
 
 //
+
 const defaultColumnSizing = {
   size: 150,
   minSize: 20,
   maxSize: Number.MAX_SAFE_INTEGER
 };
-
 const getDefaultColumnSizingInfoState = () => ({
   startOffset: null,
   startSize: null,
@@ -498,7 +472,6 @@ const getDefaultColumnSizingInfoState = () => ({
   isResizingColumn: false,
   columnSizingStart: []
 });
-
 const ColumnSizing = {
   getDefaultColumnDef: () => {
     return defaultColumnSizing;
@@ -526,12 +499,10 @@ const ColumnSizing = {
       getStart: position => {
         const columns = !position ? table.getVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns();
         const index = columns.findIndex(d => d.id === column.id);
-
         if (index > 0) {
           const prevSiblingColumn = columns[index - 1];
           return prevSiblingColumn.getStart(position) + prevSiblingColumn.getSize();
         }
-
         return 0;
       },
       resetSize: () => {
@@ -555,7 +526,6 @@ const ColumnSizing = {
     return {
       getSize: () => {
         let sum = 0;
-
         const recurse = header => {
           if (header.subHeaders.length) {
             header.subHeaders.forEach(recurse);
@@ -563,7 +533,6 @@ const ColumnSizing = {
             sum += header.column.getSize() ?? 0;
           }
         };
-
         recurse(header);
         return sum;
       },
@@ -572,7 +541,6 @@ const ColumnSizing = {
           const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
           return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
         }
-
         return 0;
       },
       getResizeHandler: () => {
@@ -583,23 +551,19 @@ const ColumnSizing = {
             return;
           }
           e.persist == null ? void 0 : 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 updateOffset = (eventType, clientXPos) => {
             if (typeof clientXPos !== 'number') {
               return;
             }
-
             let newColumnSizing = {};
             table.setColumnSizingInfo(old => {
               const deltaOffset = clientXPos - ((old == null ? void 0 : old.startOffset) ?? 0);
@@ -608,24 +572,24 @@ const ColumnSizing = {
                 let [columnId, headerSize] = _ref2;
                 newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100;
               });
-              return { ...old,
+              return {
+                ...old,
                 deltaOffset,
                 deltaPercentage
               };
             });
-
             if (table.options.columnResizeMode === 'onChange' || eventType === 'end') {
-              table.setColumnSizing(old => ({ ...old,
+              table.setColumnSizing(old => ({
+                ...old,
                 ...newColumnSizing
               }));
             }
           };
-
           const onMove = clientXPos => updateOffset('move', clientXPos);
-
           const onEnd = clientXPos => {
             updateOffset('end', clientXPos);
-            table.setColumnSizingInfo(old => ({ ...old,
+            table.setColumnSizingInfo(old => ({
+              ...old,
               isResizingColumn: false,
               startOffset: null,
               startSize: null,
@@ -634,7 +598,6 @@ const ColumnSizing = {
               columnSizingStart: []
             }));
           };
-
           const mouseEvents = {
             moveHandler: e => onMove(e.clientX),
             upHandler: e => {
@@ -643,16 +606,38 @@ const ColumnSizing = {
               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$;
+              document.removeEventListener('touchmove', touchEvents.moveHandler);
+              document.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)) ; else {
+          if (isTouchStartEvent(e)) {
+            document.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported);
+            document.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported);
+          } else {
             document.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported);
             document.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported);
           }
-
-          table.setColumnSizingInfo(old => ({ ...old,
+          table.setColumnSizingInfo(old => ({
+            ...old,
             startOffset: clientX,
             startSize,
             deltaOffset: 0,
@@ -676,28 +661,24 @@ const ColumnSizing = {
       },
       getTotalSize: () => {
         var _table$getHeaderGroup;
-
         return ((_table$getHeaderGroup = table.getHeaderGroups()[0]) == null ? void 0 : _table$getHeaderGroup.headers.reduce((sum, header) => {
           return sum + header.getSize();
         }, 0)) ?? 0;
       },
       getLeftTotalSize: () => {
         var _table$getLeftHeaderG;
-
         return ((_table$getLeftHeaderG = table.getLeftHeaderGroups()[0]) == null ? void 0 : _table$getLeftHeaderG.headers.reduce((sum, header) => {
           return sum + header.getSize();
         }, 0)) ?? 0;
       },
       getCenterTotalSize: () => {
         var _table$getCenterHeade;
-
         return ((_table$getCenterHeade = table.getCenterHeaderGroups()[0]) == null ? void 0 : _table$getCenterHeade.headers.reduce((sum, header) => {
           return sum + header.getSize();
         }, 0)) ?? 0;
       },
       getRightTotalSize: () => {
         var _table$getRightHeader;
-
         return ((_table$getRightHeader = table.getRightHeaderGroups()[0]) == null ? void 0 : _table$getRightHeader.headers.reduce((sum, header) => {
           return sum + header.getSize();
         }, 0)) ?? 0;
@@ -709,33 +690,28 @@ 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 Expanding = {
   getInitialState: state => {
     return {
@@ -758,14 +734,11 @@ const Expanding = {
           table._queue(() => {
             registered = true;
           });
-
           return;
         }
-
         if (table.options.autoResetAll ?? table.options.autoResetExpanded ?? !table.options.manualExpanding) {
           if (queued) return;
           queued = true;
-
           table._queue(() => {
             table.resetExpanded();
             queued = false;
@@ -782,7 +755,6 @@ const Expanding = {
       },
       resetExpanded: defaultState => {
         var _table$initialState;
-
         table.setExpanded(defaultState ? {} : ((_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) ?? {});
       },
       getCanSomeRowsExpand: () => {
@@ -799,22 +771,22 @@ const Expanding = {
         return expanded === true || Object.values(expanded).some(Boolean);
       },
       getIsAllRowsExpanded: () => {
-        const expanded = table.getState().expanded; // If expanded is true, save some cycles and return true
+        const expanded = table.getState().expanded;
 
+        // If expanded is true, save some cycles and return true
         if (typeof expanded === 'boolean') {
           return expanded === true;
         }
-
         if (!Object.keys(expanded).length) {
           return false;
-        } // If any row is not expanded, return false
-
+        }
 
+        // If any row is not expanded, return false
         if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
           return false;
-        } // They must all be expanded :shrug:
-
+        }
 
+        // They must all be expanded :shrug:
         return true;
       },
       getExpandedDepth: () => {
@@ -831,11 +803,9 @@ const Expanding = {
         if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
           table._getExpandedRowModel = table.options.getExpandedRowModel(table);
         }
-
         if (table.options.manualExpanding || !table._getExpandedRowModel) {
           return table.getPreExpandedRowModel();
         }
-
         return table._getExpandedRowModel();
       }
     };
@@ -846,7 +816,6 @@ const Expanding = {
         table.setExpanded(old => {
           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;
@@ -854,15 +823,13 @@ const Expanding = {
           } else {
             oldExpanded = old;
           }
-
           expanded = expanded ?? !exists;
-
           if (!exists && expanded) {
-            return { ...oldExpanded,
+            return {
+              ...oldExpanded,
               [row.id]: true
             };
           }
-
           if (exists && !expanded) {
             const {
               [row.id]: _,
@@ -870,7 +837,6 @@ const Expanding = {
             } = oldExpanded;
             return rest;
           }
-
           return old;
         });
       },
@@ -880,7 +846,6 @@ const Expanding = {
       },
       getCanExpand: () => {
         var _row$subRows;
-
         return (table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) ?? ((table.options.enableExpanding ?? true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length));
       },
       getToggleExpandedHandler: () => {
@@ -896,93 +861,68 @@ const Expanding = {
 
 const includesString = (row, columnId, filterValue) => {
   var _row$getValue;
-
   const search = filterValue.toLowerCase();
   return (_row$getValue = row.getValue(columnId)) == null ? void 0 : _row$getValue.toLowerCase().includes(search);
 };
-
 includesString.autoRemove = val => testFalsey(val);
-
 const includesStringSensitive = (row, columnId, filterValue) => {
   var _row$getValue2;
-
   return (_row$getValue2 = row.getValue(columnId)) == 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 ? void 0 : _row$getValue3.toLowerCase()) === 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;
   }
-
   return [min, max];
 };
+inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
 
-inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]); // Export
-
+// Export
 
 const filterFns = {
   includesString,
@@ -995,13 +935,14 @@ const filterFns = {
   weakEquals,
   inNumberRange
 };
-
 // Utils
+
 function testFalsey(val) {
   return val === undefined || val === null || val === '';
 }
 
 //
+
 const Filters = {
   getDefaultColumnDef: () => {
     return {
@@ -1025,7 +966,6 @@ const Filters = {
       globalFilterFn: 'auto',
       getColumnCanGlobalFilter: column => {
         var _table$getCoreRowMode, _table$getCoreRowMode2;
-
         const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null ? void 0 : (_table$getCoreRowMode2 = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode2.getValue();
         return typeof value === 'string' || typeof value === 'number';
       }
@@ -1036,32 +976,25 @@ const Filters = {
       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;
         }
-
         return filterFns.weakEquals;
       },
       getFilterFn: () => {
         var _table$options$filter;
-
         return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : ((_table$options$filter = table.options.filterFns) == null ? void 0 : _table$options$filter[column.columnDef.filterFn]) ?? filterFns[column.columnDef.filterFn];
       },
       getCanFilter: () => {
@@ -1073,43 +1006,37 @@ const Filters = {
       getIsFiltered: () => column.getFilterIndex() > -1,
       getFilterValue: () => {
         var _table$getState$colum, _table$getState$colum2;
-
         return (_table$getState$colum = table.getState().columnFilters) == null ? void 0 : (_table$getState$colum2 = _table$getState$colum.find(d => d.id === column.id)) == null ? void 0 : _table$getState$colum2.value;
       },
       getFilterIndex: () => {
         var _table$getState$colum3;
-
         return ((_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex(d => d.id === column.id)) ?? -1;
       },
       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); //
+          const newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined);
 
+          //
           if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
             return (old == null ? void 0 : old.filter(d => d.id !== column.id)) ?? [];
           }
-
           const newFilterObj = {
             id: column.id,
             value: newFilter
           };
-
           if (previousfilter) {
             return (old == null ? void 0 : old.map(d => {
               if (d.id === column.id) {
                 return newFilterObj;
               }
-
               return d;
             })) ?? [];
           }
-
           if (old != null && old.length) {
             return [...old, newFilterObj];
           }
-
           return [newFilterObj];
         });
       },
@@ -1118,7 +1045,6 @@ const Filters = {
         if (!column._getFacetedRowModel) {
           return table.getPreFilteredRowModel();
         }
-
         return column._getFacetedRowModel();
       },
       _getFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id),
@@ -1126,7 +1052,6 @@ const Filters = {
         if (!column._getFacetedUniqueValues) {
           return new Map();
         }
-
         return column._getFacetedUniqueValues();
       },
       _getFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id),
@@ -1134,13 +1059,13 @@ const Filters = {
         if (!column._getFacetedMinMaxValues) {
           return undefined;
         }
-
         return column._getFacetedMinMaxValues();
-      } // () => [column.getFacetedRowModel()],
+      }
+      // () => [column.getFacetedRowModel()],
       // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
-
     };
   },
+
   createRow: (row, table) => {
     return {
       columnFilters: {},
@@ -1154,7 +1079,6 @@ const Filters = {
       },
       getGlobalFilterFn: () => {
         var _table$options$filter2;
-
         const {
           globalFilterFn: globalFilterFn
         } = table.options;
@@ -1162,25 +1086,19 @@ const Filters = {
       },
       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 ? void 0 : table.options.onColumnFiltersChange(updateFn);
       },
       setGlobalFilter: updater => {
@@ -1191,7 +1109,6 @@ const Filters = {
       },
       resetColumnFilters: defaultState => {
         var _table$initialState;
-
         table.setColumnFilters(defaultState ? [] : ((_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) ?? []);
       },
       getPreFilteredRowModel: () => table.getCoreRowModel(),
@@ -1199,11 +1116,9 @@ const Filters = {
         if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
           table._getFilteredRowModel = table.options.getFilteredRowModel(table);
         }
-
         if (table.options.manualFiltering || !table._getFilteredRowModel) {
           return table.getPreFilteredRowModel();
         }
-
         return table._getFilteredRowModel();
       },
       _getGlobalFacetedRowModel: table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, '__global__'),
@@ -1211,7 +1126,6 @@ const Filters = {
         if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {
           return table.getPreFilteredRowModel();
         }
-
         return table._getGlobalFacetedRowModel();
       },
       _getGlobalFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, '__global__'),
@@ -1219,7 +1133,6 @@ const Filters = {
         if (!table._getGlobalFacetedUniqueValues) {
           return new Map();
         }
-
         return table._getGlobalFacetedUniqueValues();
       },
       _getGlobalFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, '__global__'),
@@ -1227,7 +1140,6 @@ const Filters = {
         if (!table._getGlobalFacetedMinMaxValues) {
           return;
         }
-
         return table._getGlobalFacetedMinMaxValues();
       }
     };
@@ -1245,37 +1157,31 @@ const sum = (columnId, _leafRows, childRows) => {
     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;
@@ -1287,13 +1193,11 @@ const extent = (columnId, _leafRows, childRows) => {
   });
   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;
     }
@@ -1301,17 +1205,14 @@ const mean = (columnId, leafRows) => {
   if (count) return sum / count;
   return;
 };
-
 const median = (columnId, leafRows) => {
   if (!leafRows.length) {
     return;
   }
-
   let min = 0;
   let max = 0;
   leafRows.forEach(row => {
     let value = row.getValue(columnId);
-
     if (typeof value === 'number') {
       min = Math.min(min, value);
       max = Math.max(max, value);
@@ -1319,19 +1220,15 @@ const median = (columnId, leafRows) => {
   });
   return (min + max) / 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,
@@ -1345,12 +1242,12 @@ const aggregationFns = {
 };
 
 //
+
 const Grouping = {
   getDefaultColumnDef: () => {
     return {
       aggregatedCell: props => {
         var _props$getValue;
-
         return ((_props$getValue = props.getValue()) == null ? void 0 : _props$getValue.toString == null ? void 0 : _props$getValue.toString()) ?? null;
       },
       aggregationFn: 'auto'
@@ -1376,7 +1273,6 @@ const Grouping = {
           if (old != null && old.includes(column.id)) {
             return old.filter(d => d !== column.id);
           }
-
           return [...(old ?? []), column.id];
         });
       },
@@ -1385,12 +1281,10 @@ const Grouping = {
       },
       getIsGrouped: () => {
         var _table$getState$group;
-
         return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id);
       },
       getGroupedIndex: () => {
         var _table$getState$group2;
-
         return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id);
       },
       getToggleGroupingHandler: () => {
@@ -1403,22 +1297,18 @@ const Grouping = {
       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;
         }
       },
       getAggregationFn: () => {
         var _table$options$aggreg;
-
         if (!column) {
           throw new Error();
         }
-
         return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : ((_table$options$aggreg = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg[column.columnDef.aggregationFn]) ?? aggregationFns[column.columnDef.aggregationFn];
       }
     };
@@ -1428,7 +1318,6 @@ const Grouping = {
       setGrouping: updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater),
       resetGrouping: defaultState => {
         var _table$initialState;
-
         table.setGrouping(defaultState ? [] : ((_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) ?? []);
       },
       getPreGroupedRowModel: () => table.getFilteredRowModel(),
@@ -1436,11 +1325,9 @@ const Grouping = {
         if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
           table._getGroupedRowModel = table.options.getGroupedRowModel(table);
         }
-
         if (table.options.manualGrouping || !table._getGroupedRowModel) {
           return table.getPreGroupedRowModel();
         }
-
         return table._getGroupedRowModel();
       }
     };
@@ -1452,13 +1339,11 @@ const Grouping = {
     };
   },
   createCell: (cell, column, row, table) => {
-
     return {
       getIsGrouped: () => column.getIsGrouped() && column.id === row.groupingColumnId,
       getIsPlaceholder: () => !cell.getIsGrouped() && column.getIsGrouped(),
       getIsAggregated: () => {
         var _row$subRows;
-
         return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
       }
     };
@@ -1468,18 +1353,16 @@ 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 Ordering = {
   getInitialState: state => {
     return {
@@ -1501,51 +1384,54 @@ const Ordering = {
       _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
+        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 columnOrderCopy = [...columnOrder];
 
-          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
+          // 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
-
+          }
 
+          // If there are any columns left, add them to the end
           orderedColumns = [...orderedColumns, ...columnsCopy];
         }
-
         return orderColumns(orderedColumns, grouping, groupedColumnMode);
       }, {
-        key: process.env.NODE_ENV === 'development' && 'getOrderColumnsFn' // debug: () => table.options.debugAll ?? table.options.debugTable,
-
+        key: process.env.NODE_ENV === 'development' && 'getOrderColumnsFn'
+        // debug: () => table.options.debugAll ?? table.options.debugTable,
       })
     };
   }
 };
 
 //
+
 const defaultPageIndex = 0;
 const defaultPageSize = 10;
-
 const getDefaultPaginationState = () => ({
   pageIndex: defaultPageIndex,
   pageSize: defaultPageSize
 });
-
 const Pagination = {
   getInitialState: state => {
-    return { ...state,
-      pagination: { ...getDefaultPaginationState(),
+    return {
+      ...state,
+      pagination: {
+        ...getDefaultPaginationState(),
         ...(state == null ? void 0 : state.pagination)
       }
     };
@@ -1564,14 +1450,11 @@ const Pagination = {
           table._queue(() => {
             registered = true;
           });
-
           return;
         }
-
         if (table.options.autoResetAll ?? table.options.autoResetPageIndex ?? !table.options.manualPagination) {
           if (queued) return;
           queued = true;
-
           table._queue(() => {
             table.resetPageIndex();
             queued = false;
@@ -1583,7 +1466,6 @@ const Pagination = {
           let newState = functionalUpdate(updater, old);
           return newState;
         };
-
         return table.options.onPaginationChange == null ? void 0 : table.options.onPaginationChange(safeUpdater);
       },
       resetPagination: defaultState => {
@@ -1594,19 +1476,18 @@ const Pagination = {
           let pageIndex = functionalUpdate(updater, old.pageIndex);
           const maxPageIndex = typeof table.options.pageCount === 'undefined' || table.options.pageCount === -1 ? Number.MAX_SAFE_INTEGER : table.options.pageCount - 1;
           pageIndex = Math.min(Math.max(0, pageIndex), maxPageIndex);
-          return { ...old,
+          return {
+            ...old,
             pageIndex
           };
         });
       },
       resetPageIndex: defaultState => {
         var _table$initialState, _table$initialState$p;
-
         table.setPageIndex(defaultState ? defaultPageIndex : ((_table$initialState = table.initialState) == null ? void 0 : (_table$initialState$p = _table$initialState.pagination) == null ? void 0 : _table$initialState$p.pageIndex) ?? defaultPageIndex);
       },
       resetPageSize: defaultState => {
         var _table$initialState2, _table$initialState2$;
-
         table.setPageSize(defaultState ? defaultPageSize : ((_table$initialState2 = table.initialState) == null ? void 0 : (_table$initialState2$ = _table$initialState2.pagination) == null ? void 0 : _table$initialState2$.pageSize) ?? defaultPageSize);
       },
       setPageSize: updater => {
@@ -1614,7 +1495,8 @@ const Pagination = {
           const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize));
           const topRowIndex = old.pageSize * old.pageIndex;
           const pageIndex = Math.floor(topRowIndex / pageSize);
-          return { ...old,
+          return {
+            ...old,
             pageIndex,
             pageSize
           };
@@ -1622,22 +1504,19 @@ const Pagination = {
       },
       setPageCount: updater => table.setPagination(old => {
         let newPageCount = functionalUpdate(updater, table.options.pageCount ?? -1);
-
         if (typeof newPageCount === 'number') {
           newPageCount = Math.max(-1, newPageCount);
         }
-
-        return { ...old,
+        return {
+          ...old,
           pageCount: newPageCount
         };
       }),
       getPageOptions: memo(() => [table.getPageCount()], pageCount => {
         let pageOptions = [];
-
         if (pageCount && pageCount > 0) {
           pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i);
         }
-
         return pageOptions;
       }, {
         key: process.env.NODE_ENV === 'development' && 'getPageOptions',
@@ -1649,15 +1528,12 @@ const Pagination = {
           pageIndex
         } = table.getState().pagination;
         const pageCount = table.getPageCount();
-
         if (pageCount === -1) {
           return true;
         }
-
         if (pageCount === 0) {
           return false;
         }
-
         return pageIndex < pageCount - 1;
       },
       previousPage: () => {
@@ -1673,11 +1549,9 @@ const Pagination = {
         if (!table._getPaginationRowModel && table.options.getPaginationRowModel) {
           table._getPaginationRowModel = table.options.getPaginationRowModel(table);
         }
-
         if (table.options.manualPagination || !table._getPaginationRowModel) {
           return table.getPrePaginationRowModel();
         }
-
         return table._getPaginationRowModel();
       },
       getPageCount: () => {
@@ -1688,11 +1562,11 @@ const Pagination = {
 };
 
 //
+
 const getDefaultPinningState = () => ({
   left: [],
   right: []
 });
-
 const Pinning = {
   getInitialState: state => {
     return {
@@ -1716,14 +1590,12 @@ const Pinning = {
               right: [...((old == null ? void 0 : old.right) ?? []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
             };
           }
-
           if (position === 'left') {
             return {
               left: [...((old == null ? void 0 : old.left) ?? []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
               right: ((old == null ? void 0 : old.right) ?? []).filter(d => !(columnIds != null && columnIds.includes(d)))
             };
           }
-
           return {
             left: ((old == null ? void 0 : old.left) ?? []).filter(d => !(columnIds != null && columnIds.includes(d))),
             right: ((old == null ? void 0 : old.right) ?? []).filter(d => !(columnIds != null && columnIds.includes(d)))
@@ -1746,7 +1618,6 @@ const Pinning = {
       },
       getPinnedIndex: () => {
         var _table$getState$colum, _table$getState$colum2;
-
         const position = column.getIsPinned();
         return position ? ((_table$getState$colum = table.getState().columnPinning) == null ? void 0 : (_table$getState$colum2 = _table$getState$colum[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) ?? -1 : 0;
       }
@@ -1762,7 +1633,8 @@ const Pinning = {
         debug: () => table.options.debugAll ?? table.options.debugRows
       }),
       getLeftVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left,,], (allCells, left) => {
-        const cells = (left ?? []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({ ...d,
+        const cells = (left ?? []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
           position: 'left'
         }));
         return cells;
@@ -1771,7 +1643,8 @@ const Pinning = {
         debug: () => table.options.debugAll ?? table.options.debugRows
       }),
       getRightVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
-        const cells = (right ?? []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({ ...d,
+        const cells = (right ?? []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
           position: 'right'
         }));
         return cells;
@@ -1786,20 +1659,15 @@ const Pinning = {
       setColumnPinning: updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater),
       resetColumnPinning: defaultState => {
         var _table$initialState;
-
         return table.setColumnPinning(defaultState ? getDefaultPinningState() : ((_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) ?? getDefaultPinningState());
       },
       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);
       },
       getLeftLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => {
@@ -1826,6 +1694,7 @@ const Pinning = {
 };
 
 //
+
 const RowSelection = {
   getInitialState: state => {
     return {
@@ -1838,12 +1707,13 @@ const RowSelection = {
       onRowSelectionChange: makeStateUpdater('rowSelection', table),
       enableRowSelection: true,
       enableMultiRowSelection: true,
-      enableSubRowSelection: true // enableGroupingRowSelection: false,
+      enableSubRowSelection: true
+      // enableGroupingRowSelection: false,
       // isAdditiveSelectEvent: (e: unknown) => !!e.metaKey,
       // isInclusiveSelectEvent: (e: unknown) => !!e.shiftKey,
-
     };
   },
+
   createTable: table => {
     return {
       setRowSelection: updater => table.options.onRowSelectionChange == null ? void 0 : table.options.onRowSelectionChange(updater),
@@ -1851,17 +1721,18 @@ const RowSelection = {
       toggleAllRowsSelected: value => {
         table.setRowSelection(old => {
           value = typeof value !== 'undefined' ? value : !table.getIsAllRowsSelected();
-          const rowSelection = { ...old
+          const rowSelection = {
+            ...old
           };
-          const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows; // We don't use `mutateRowIsSelected` here for performance reasons.
-          // All of the rows are flat already, so it wouldn't be worth it
+          const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows;
 
+          // We don't use `mutateRowIsSelected` here for performance reasons.
+          // All of the rows are flat already, so it wouldn't be worth it
           if (value) {
             preGroupedFlatRows.forEach(row => {
               if (!row.getCanSelect()) {
                 return;
               }
-
               rowSelection[row.id] = true;
             });
           } else {
@@ -1869,13 +1740,13 @@ const RowSelection = {
               delete rowSelection[row.id];
             });
           }
-
           return rowSelection;
         });
       },
       toggleAllPageRowsSelected: value => table.setRowSelection(old => {
         const resolvedValue = typeof value !== 'undefined' ? value : !table.getIsAllPageRowsSelected();
-        const rowSelection = { ...old
+        const rowSelection = {
+          ...old
         };
         table.getRowModel().rows.forEach(row => {
           mutateRowIsSelected(rowSelection, row.id, resolvedValue, table);
@@ -1888,6 +1759,7 @@ const RowSelection = {
       //     rowsById,
       //     options: { selectGroupingRows, selectSubRows },
       //   } = table
+
       //   const findSelectedRow = (rows: Row[]) => {
       //     let found
       //     rows.find(d => {
@@ -1904,10 +1776,13 @@ const RowSelection = {
       //     })
       //     return found
       //   }
+
       //   const firstRow = findSelectedRow(rows) || rows[0]
       //   const lastRow = rowsById[rowId]
+
       //   let include = false
       //   const selectedRowIds = {}
+
       //   const addRow = (row: Row) => {
       //     mutateRowIsSelected(selectedRowIds, row.id, true, {
       //       rowsById,
@@ -1915,9 +1790,11 @@ const RowSelection = {
       //       selectSubRows: selectSubRows!,
       //     })
       //   }
+
       //   table.rows.forEach(row => {
       //     const isFirstRow = row.id === firstRow.id
       //     const isLastRow = row.id === lastRow.id
+
       //     if (isFirstRow || isLastRow) {
       //       if (!include) {
       //         include = true
@@ -1926,10 +1803,12 @@ const RowSelection = {
       //         include = false
       //       }
       //     }
+
       //     if (include) {
       //       addRow(row)
       //     }
       //   })
+
       //   table.setRowSelection(selectedRowIds)
       // },
       getPreSelectedRowModel: () => table.getCoreRowModel(),
@@ -1941,7 +1820,6 @@ const RowSelection = {
             rowsById: {}
           };
         }
-
         return selectRowsFn(table, rowModel);
       }, {
         key: process.env.NODE_ENV === 'development' && 'getSelectedRowModel',
@@ -1955,7 +1833,6 @@ const RowSelection = {
             rowsById: {}
           };
         }
-
         return selectRowsFn(table, rowModel);
       }, {
         key: process.env.NODE_ENV === 'production' && 'getFilteredSelectedRowModel',
@@ -1969,36 +1846,38 @@ const RowSelection = {
             rowsById: {}
           };
         }
-
         return selectRowsFn(table, rowModel);
       }, {
         key: process.env.NODE_ENV === 'production' && 'getGroupedSelectedRowModel',
         debug: () => table.options.debugAll ?? table.options.debugTable
       }),
       ///
+
       // getGroupingRowCanSelect: rowId => {
       //   const row = table.getRow(rowId)
+
       //   if (!row) {
       //     throw new Error()
       //   }
+
       //   if (typeof table.options.enableGroupingRowSelection === 'function') {
       //     return table.options.enableGroupingRowSelection(row)
       //   }
+
       //   return table.options.enableGroupingRowSelection ?? false
       // },
+
       getIsAllRowsSelected: () => {
         const preGroupedFlatRows = table.getFilteredRowModel().flatRows;
         const {
           rowSelection
         } = table.getState();
         let isAllRowsSelected = Boolean(preGroupedFlatRows.length && Object.keys(rowSelection).length);
-
         if (isAllRowsSelected) {
           if (preGroupedFlatRows.some(row => row.getCanSelect() && !rowSelection[row.id])) {
             isAllRowsSelected = false;
           }
         }
-
         return isAllRowsSelected;
       },
       getIsAllPageRowsSelected: () => {
@@ -2007,11 +1886,9 @@ const RowSelection = {
           rowSelection
         } = table.getState();
         let isAllPageRowsSelected = !!paginationFlatRows.length;
-
         if (isAllPageRowsSelected && paginationFlatRows.some(row => !rowSelection[row.id])) {
           isAllPageRowsSelected = false;
         }
-
         return isAllPageRowsSelected;
       },
       getIsSomeRowsSelected: () => {
@@ -2040,12 +1917,11 @@ const RowSelection = {
         const isSelected = row.getIsSelected();
         table.setRowSelection(old => {
           value = typeof value !== 'undefined' ? value : !isSelected;
-
           if (isSelected === value) {
             return old;
           }
-
-          const selectedRowIds = { ...old
+          const selectedRowIds = {
+            ...old
           };
           mutateRowIsSelected(selectedRowIds, row.id, value, table);
           return selectedRowIds;
@@ -2073,28 +1949,24 @@ const RowSelection = {
         if (typeof table.options.enableRowSelection === 'function') {
           return table.options.enableRowSelection(row);
         }
-
         return table.options.enableRowSelection ?? true;
       },
       getCanSelectSubRows: () => {
         if (typeof table.options.enableSubRowSelection === 'function') {
           return table.options.enableSubRowSelection(row);
         }
-
         return table.options.enableSubRowSelection ?? true;
       },
       getCanMultiSelect: () => {
         if (typeof table.options.enableMultiRowSelection === 'function') {
           return table.options.enableMultiRowSelection(row);
         }
-
         return table.options.enableMultiRowSelection ?? true;
       },
       getToggleSelectedHandler: () => {
         const canSelect = row.getCanSelect();
         return e => {
           var _target;
-
           if (!canSelect) return;
           row.toggleSelected((_target = e.target) == null ? void 0 : _target.checked);
         };
@@ -2102,63 +1974,57 @@ const RowSelection = {
     };
   }
 };
-
 const mutateRowIsSelected = (selectedRowIds, id, value, table) => {
   var _row$subRows;
+  const row = table.getRow(id);
+
+  // const isGrouped = row.getIsGrouped()
 
-  const row = table.getRow(id); // const isGrouped = row.getIsGrouped()
   // if ( // TODO: enforce grouping row selection rules
   //   !isGrouped ||
   //   (isGrouped && table.options.enableGroupingRowSelection)
   // ) {
-
   if (value) {
     if (!row.getCanMultiSelect()) {
       Object.keys(selectedRowIds).forEach(key => delete selectedRowIds[key]);
     }
-
     if (row.getCanSelect()) {
       selectedRowIds[id] = true;
     }
   } else {
     delete selectedRowIds[id];
-  } // }
-
+  }
+  // }
 
   if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getCanSelectSubRows()) {
     row.subRows.forEach(row => mutateRowIsSelected(selectedRowIds, row.id, value, table));
   }
 };
-
 function selectRowsFn(table, rowModel) {
   const rowSelection = table.getState().rowSelection;
   const newSelectedFlatRows = [];
-  const newSelectedRowsById = {}; // Filters top level and nested rows
+  const newSelectedRowsById = {};
 
+  // Filters top level and nested rows
   const recurseRows = function (rows, depth) {
-
     return rows.map(row => {
       var _row$subRows2;
-
       const isSelected = isRowSelected(row, rowSelection);
-
       if (isSelected) {
         newSelectedFlatRows.push(row);
         newSelectedRowsById[row.id] = row;
       }
-
       if ((_row$subRows2 = row.subRows) != null && _row$subRows2.length) {
-        row = { ...row,
+        row = {
+          ...row,
           subRows: recurseRows(row.subRows)
         };
       }
-
       if (isSelected) {
         return row;
       }
     }).filter(Boolean);
   };
-
   return {
     rows: recurseRows(rowModel.rows),
     flatRows: newSelectedFlatRows,
@@ -2177,7 +2043,6 @@ function isSubRowSelected(row, selection, table) {
       if (someSelected && !allChildrenSelected) {
         return;
       }
-
       if (isRowSelected(subRow, selection)) {
         someSelected = true;
       } else {
@@ -2186,112 +2051,104 @@ function isSubRowSelected(row, selection, table) {
     });
     return allChildrenSelected ? 'all' : someSelected ? 'some' : false;
   }
-
   return false;
 }
 
 const reSplitAlphaNumeric = /([0-9]+)/gm;
-
 const alphanumeric = (rowA, rowB, columnId) => {
   return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
 };
-
 const alphanumericCaseSensitive = (rowA, rowB, columnId) => {
   return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-}; // The text filter is more basic (less numeric support)
-// but is much faster
-
+};
 
+// The text filter is more basic (less numeric support)
+// but is much faster
 const text = (rowA, rowB, columnId) => {
   return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-}; // The text filter is more basic (less numeric support)
-// but is much faster
-
+};
 
+// The text filter is more basic (less numeric support)
+// but is much faster
 const textCaseSensitive = (rowA, rowB, columnId) => {
   return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
 };
-
 const datetime = (rowA, rowB, columnId) => {
   const a = rowA.getValue(columnId);
-  const b = rowB.getValue(columnId); // Can handle nullish values
+  const b = rowB.getValue(columnId);
+
+  // Can handle nullish values
   // Use > and < because == (and ===) doesn't work with
   // Date objects (would require calling getTime()).
-
   return a > b ? 1 : a < b ? -1 : 0;
 };
-
 const basic = (rowA, rowB, columnId) => {
   return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
-}; // Utils
+};
 
+// Utils
 
 function compareBasic(a, b) {
   return a === b ? 0 : a > b ? 1 : -1;
 }
-
 function toString(a) {
   if (typeof a === 'number') {
     if (isNaN(a) || a === Infinity || a === -Infinity) {
       return '';
     }
-
     return String(a);
   }
-
   if (typeof a === 'string') {
     return a;
   }
-
   return '';
-} // Mixed sorting is slow, but very inclusive of many edge cases.
+}
+
+// Mixed sorting is slow, but very inclusive of many edge cases.
 // It handles numbers, mixed alphanumeric combinations, and even
 // null, undefined, and Infinity
-
-
 function compareAlphanumeric(aStr, bStr) {
   // Split on number groups, but keep the delimiter
   // Then remove falsey split values
   const a = aStr.split(reSplitAlphaNumeric).filter(Boolean);
-  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean); // While
+  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean);
 
+  // While
   while (a.length && b.length) {
     const aa = a.shift();
     const bb = b.shift();
     const an = parseInt(aa, 10);
     const bn = parseInt(bb, 10);
-    const combo = [an, bn].sort(); // Both are string
+    const combo = [an, bn].sort();
 
+    // Both are string
     if (isNaN(combo[0])) {
       if (aa > bb) {
         return 1;
       }
-
       if (bb > aa) {
         return -1;
       }
-
       continue;
-    } // One is a string, one is a number
-
+    }
 
+    // One is a string, one is a number
     if (isNaN(combo[1])) {
       return isNaN(an) ? -1 : 1;
-    } // Both are numbers
-
+    }
 
+    // Both are numbers
     if (an > bn) {
       return 1;
     }
-
     if (bn > an) {
       return -1;
     }
   }
-
   return a.length - b.length;
-} // Exports
+}
 
+// Exports
 
 const sortingFns = {
   alphanumeric,
@@ -2303,6 +2160,7 @@ const sortingFns = {
 };
 
 //
+
 const Sorting = {
   getInitialState: state => {
     return {
@@ -2328,46 +2186,36 @@ const Sorting = {
       getAutoSortingFn: () => {
         const firstRows = table.getFilteredRowModel().flatRows.slice(10);
         let isString = false;
-
         for (const row of firstRows) {
           const value = row == null ? void 0 : row.getValue(column.id);
-
           if (Object.prototype.toString.call(value) === '[object Date]') {
             return sortingFns.datetime;
           }
-
           if (typeof value === 'string') {
             isString = true;
-
             if (value.split(reSplitAlphaNumeric).length > 1) {
               return sortingFns.alphanumeric;
             }
           }
         }
-
         if (isString) {
           return sortingFns.text;
         }
-
         return sortingFns.basic;
       },
       getAutoSortDir: () => {
         const firstRow = table.getFilteredRowModel().flatRows[0];
         const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
-
         if (typeof value === 'string') {
           return 'asc';
         }
-
         return 'desc';
       },
       getSortingFn: () => {
         var _table$options$sortin;
-
         if (!column) {
           throw new Error();
         }
-
         return isFunction(column.columnDef.sortingFn) ? column.columnDef.sortingFn : column.columnDef.sortingFn === 'auto' ? column.getAutoSortingFn() : ((_table$options$sortin = table.options.sortingFns) == null ? void 0 : _table$options$sortin[column.columnDef.sortingFn]) ?? sortingFns[column.columnDef.sortingFn];
       },
       toggleSorting: (desc, multi) => {
@@ -2379,6 +2227,7 @@ const Sorting = {
         //   })
         //   return
         // }
+
         // this needs to be outside of table.setSorting to be in sync with rerender
         const nextSortingOrder = column.getNextSortingOrder();
         const hasManualValue = typeof desc !== 'undefined' && desc !== null;
@@ -2386,11 +2235,13 @@ const Sorting = {
           // Find any existing sorting for this column
           const existingSorting = old == null ? void 0 : old.find(d => d.id === column.id);
           const existingIndex = old == null ? void 0 : old.findIndex(d => d.id === column.id);
-          let newSorting = []; // What should we do with this sort action?
+          let newSorting = [];
 
+          // What should we do with this sort action?
           let sortAction;
-          let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc'; // Multi-mode
+          let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc';
 
+          // Multi-mode
           if (old != null && old.length && column.getCanMultiSort() && multi) {
             if (existingSorting) {
               sortAction = 'toggle';
@@ -2406,9 +2257,9 @@ const Sorting = {
             } else {
               sortAction = 'replace';
             }
-          } // Handle toggle states that will remove the sorting
-
+          }
 
+          // Handle toggle states that will remove the sorting
           if (sortAction === 'toggle') {
             // If we are "actually" toggling (not a manual set value), should we remove the sorting?
             if (!hasManualValue) {
@@ -2418,23 +2269,22 @@ const Sorting = {
               }
             }
           }
-
           if (sortAction === 'add') {
             newSorting = [...old, {
               id: column.id,
               desc: nextDesc
-            }]; // Take latest n columns
-
+            }];
+            // Take latest n columns
             newSorting.splice(0, newSorting.length - (table.options.maxMultiSortColCount ?? Number.MAX_SAFE_INTEGER));
           } else if (sortAction === 'toggle') {
             // This flips (or sets) the
             newSorting = old.map(d => {
               if (d.id === column.id) {
-                return { ...d,
+                return {
+                  ...d,
                   desc: nextDesc
                 };
               }
-
               return d;
             });
           } else if (sortAction === 'remove') {
@@ -2445,7 +2295,6 @@ const Sorting = {
               desc: nextDesc
             }];
           }
-
           return newSorting;
         });
       },
@@ -2456,17 +2305,15 @@ const Sorting = {
       getNextSortingOrder: multi => {
         const firstSortDirection = column.getFirstSortDir();
         const isSorted = column.getIsSorted();
-
         if (!isSorted) {
           return firstSortDirection;
         }
-
-        if (isSorted !== firstSortDirection && (table.options.enableSortingRemoval ?? true) && ( // If enableSortRemove, enable in general
+        if (isSorted !== firstSortDirection && (table.options.enableSortingRemoval ?? true) && (
+        // If enableSortRemove, enable in general
         multi ? table.options.enableMultiRemove ?? true : true) // If multi, don't allow if enableMultiRemove))
         ) {
           return false;
         }
-
         return isSorted === 'desc' ? 'asc' : 'desc';
       },
       getCanSort: () => {
@@ -2477,13 +2324,11 @@ const Sorting = {
       },
       getIsSorted: () => {
         var _table$getState$sorti;
-
         const columnSort = (_table$getState$sorti = table.getState().sorting) == null ? void 0 : _table$getState$sorti.find(d => d.id === column.id);
         return !columnSort ? false : columnSort.desc ? 'desc' : 'asc';
       },
       getSortIndex: () => {
         var _table$getState$sorti2;
-
         return ((_table$getState$sorti2 = table.getState().sorting) == null ? void 0 : _table$getState$sorti2.findIndex(d => d.id === column.id)) ?? -1;
       },
       clearSorting: () => {
@@ -2505,7 +2350,6 @@ const Sorting = {
       setSorting: updater => table.options.onSortingChange == null ? void 0 : table.options.onSortingChange(updater),
       resetSorting: defaultState => {
         var _table$initialState;
-
         table.setSorting(defaultState ? [] : ((_table$initialState = table.initialState) == null ? void 0 : _table$initialState.sorting) ?? []);
       },
       getPreSortedRowModel: () => table.getGroupedRowModel(),
@@ -2513,11 +2357,9 @@ const Sorting = {
         if (!table._getSortedRowModel && table.options.getSortedRowModel) {
           table._getSortedRowModel = table.options.getSortedRowModel(table);
         }
-
         if (table.options.manualSorting || !table._getSortedRowModel) {
           return table.getPreSortedRowModel();
         }
-
         return table._getSortedRowModel();
       }
     };
@@ -2525,6 +2367,7 @@ const Sorting = {
 };
 
 //
+
 const Visibility = {
   getInitialState: state => {
     return {
@@ -2541,14 +2384,14 @@ const Visibility = {
     return {
       toggleVisibility: value => {
         if (column.getCanHide()) {
-          table.setColumnVisibility(old => ({ ...old,
+          table.setColumnVisibility(old => ({
+            ...old,
             [column.id]: value ?? !column.getIsVisible()
           }));
         }
       },
       getIsVisible: () => {
         var _table$getState$colum;
-
         return ((_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) ?? true;
       },
       getCanHide: () => {
@@ -2584,7 +2427,6 @@ const Visibility = {
         debug: () => table.options.debugAll ?? table.options.debugColumns
       });
     };
-
     return {
       getVisibleFlatColumns: makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns()),
       getVisibleLeafColumns: makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns()),
@@ -2597,7 +2439,8 @@ const Visibility = {
       },
       toggleAllColumnsVisible: value => {
         value = value ?? !table.getIsAllColumnsVisible();
-        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({ ...obj,
+        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
+          ...obj,
           [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
         }), {}));
       },
@@ -2606,7 +2449,6 @@ const Visibility = {
       getToggleAllColumnsVisibilityHandler: () => {
         return e => {
           var _target;
-
           table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
         };
       }
@@ -2614,60 +2456,57 @@ const Visibility = {
   }
 };
 
-const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing]; //
+const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing];
+
+//
 
 function createTable(options) {
   if (options.debugAll || options.debugTable) {
     console.info('Creating Table Instance...');
   }
-
   let table = {
     _features: features
   };
-
   const defaultOptions = table._features.reduce((obj, feature) => {
     return Object.assign(obj, feature.getDefaultOptions == null ? void 0 : feature.getDefaultOptions(table));
   }, {});
-
   const mergeOptions = options => {
     if (table.options.mergeOptions) {
       return table.options.mergeOptions(defaultOptions, options);
     }
-
-    return { ...defaultOptions,
+    return {
+      ...defaultOptions,
       ...options
     };
   };
-
   const coreInitialState = {};
-  let initialState = { ...coreInitialState,
+  let initialState = {
+    ...coreInitialState,
     ...(options.initialState ?? {})
   };
-
   table._features.forEach(feature => {
     initialState = (feature.getInitialState == null ? void 0 : feature.getInitialState(initialState)) ?? initialState;
   });
-
   const queued = [];
   let queuedTimeout = false;
   const coreInstance = {
     _features: features,
-    options: { ...defaultOptions,
+    options: {
+      ...defaultOptions,
       ...options
     },
     initialState,
     _queue: cb => {
       queued.push(cb);
-
       if (!queuedTimeout) {
-        queuedTimeout = true; // Schedule a microtask to run the queued callbacks after
-        // the current call stack (render, etc) has finished.
+        queuedTimeout = true;
 
+        // Schedule a microtask to run the queued callbacks after
+        // the current call stack (render, etc) has finished.
         Promise.resolve().then(() => {
           while (queued.length) {
             queued.shift()();
           }
-
           queuedTimeout = false;
         }).catch(error => setTimeout(() => {
           throw error;
@@ -2692,25 +2531,22 @@ function createTable(options) {
       if (!table._getCoreRowModel) {
         table._getCoreRowModel = table.options.getCoreRowModel(table);
       }
-
       return table._getCoreRowModel();
     },
     // The final calls start at the bottom of the model,
     // expanded rows, which then work their way up
+
     getRowModel: () => {
       return table.getPaginationRowModel();
     },
     getRow: id => {
       const row = table.getRowModel().rowsById[id];
-
       if (!row) {
         if (process.env.NODE_ENV !== 'production') {
           throw new Error(`getRow expected an ID, but got ${id}`);
         }
-
         throw new Error();
       }
-
       return row;
     },
     _getDefaultColumnDef: memo(() => [table.options.defaultColumn], defaultColumn => {
@@ -2718,21 +2554,17 @@ function createTable(options) {
       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;
-
           return ((_props$renderValue = props.renderValue()) == null ? void 0 : _props$renderValue.toString == null ? void 0 : _props$renderValue.toString()) ?? null;
         },
         ...table._features.reduce((obj, feature) => {
@@ -2750,7 +2582,6 @@ function createTable(options) {
         if (depth === void 0) {
           depth = 0;
         }
-
         return columnDefs.map(columnDef => {
           const column = createColumn(table, columnDef, depth, parent);
           const groupingColumnDef = columnDef;
@@ -2758,7 +2589,6 @@ function createTable(options) {
           return column;
         });
       };
-
       return recurseColumns(columnDefs);
     }, {
       key: process.env.NODE_ENV === 'development' && 'getAllColumns',
@@ -2790,30 +2620,24 @@ function createTable(options) {
     }),
     getColumn: columnId => {
       const column = table._getAllFlatColumnsById()[columnId];
-
       if (!column) {
         if (process.env.NODE_ENV !== 'production') {
           console.warn(`[Table] Column with id ${columnId} does not exist.`);
         }
-
         throw new Error();
       }
-
       return column;
     }
   };
   Object.assign(table, coreInstance);
-
   table._features.forEach(feature => {
     return Object.assign(table, feature.createTable == null ? void 0 : feature.createTable(table));
   });
-
   return table;
 }
 
 function createCell(table, row, column, columnId) {
   const getRenderValue = () => cell.getValue() ?? table.options.renderFallbackValue;
-
   const cell = {
     id: `${row.id}_${column.id}`,
     row,
@@ -2832,11 +2656,9 @@ function createCell(table, row, column, columnId) {
       debug: () => table.options.debugAll
     })
   };
-
   table._features.forEach(feature => {
     Object.assign(cell, feature.createCell == null ? void 0 : feature.createCell(cell, column, row, table));
   }, {});
-
   return cell;
 }
 
@@ -2851,13 +2673,10 @@ const createRow = (table, id, original, rowIndex, depth, subRows) => {
       if (row._valuesCache.hasOwnProperty(columnId)) {
         return row._valuesCache[columnId];
       }
-
       const column = table.getColumn(columnId);
-
       if (!column.accessorFn) {
         return undefined;
       }
-
       row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex);
       return row._valuesCache[columnId];
     },
@@ -2882,12 +2701,10 @@ const createRow = (table, id, original, rowIndex, depth, subRows) => {
       debug: () => table.options.debugAll ?? table.options.debugRows
     })
   };
-
   for (let i = 0; i < table._features.length; i++) {
     const feature = table._features[i];
     Object.assign(row, feature == null ? void 0 : feature.createRow == null ? void 0 : feature.createRow(row, table));
   }
-
   return row;
 };
 
@@ -2914,24 +2731,32 @@ const createRow = (table, id, original, rowIndex, depth, subRows) => {
 //     }
 //   }
 // }
+
 // 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,
+      return typeof accessor === 'function' ? {
+        ...column,
         accessorFn: accessor
-      } : { ...column,
+      } : {
+        ...column,
         accessorKey: accessor
       };
     },
@@ -2947,14 +2772,11 @@ function getCoreRowModel() {
       flatRows: [],
       rowsById: {}
     };
-
     const accessRows = function (originalRows, depth, parent) {
       if (depth === void 0) {
         depth = 0;
       }
-
       const rows = [];
-
       for (let i = 0; i < originalRows.length; i++) {
         // This could be an expensive check at scale, so we should move it somewhere else, but where?
         // if (!id) {
@@ -2962,29 +2784,30 @@ function getCoreRowModel() {
         //     throw new Error(`getRowId expected an ID, but got ${id}`)
         //   }
         // }
-        // Make the row
-        const row = createRow(table, table._getRowId(originalRows[i], i, parent), originalRows[i], i, depth); // Keep track of every row in a flat array
 
-        rowModel.flatRows.push(row); // Also keep track of every row by its ID
-
-        rowModel.rowsById[row.id] = row; // Push table row into parent
+        // Make the row
+        const row = createRow(table, table._getRowId(originalRows[i], i, parent), originalRows[i], i, depth);
 
-        rows.push(row); // Get the original subrows
+        // Keep track of every row in a flat array
+        rowModel.flatRows.push(row);
+        // Also keep track of every row by its ID
+        rowModel.rowsById[row.id] = row;
+        // Push table row into parent
+        rows.push(row);
 
+        // Get the original subrows
         if (table.options.getSubRows) {
           var _row$originalSubRows;
+          row.originalSubRows = table.options.getSubRows(originalRows[i], i);
 
-          row.originalSubRows = table.options.getSubRows(originalRows[i], i); // Then recursively access them
-
+          // Then recursively access them
           if ((_row$originalSubRows = row.originalSubRows) != null && _row$originalSubRows.length) {
             row.subRows = accessRows(row.originalSubRows, depth + 1, row);
           }
         }
       }
-
       return rows;
     };
-
     rowModel.rows = accessRows(data);
     return rowModel;
   }, {
@@ -3000,44 +2823,35 @@ function filterRows(rows, filterRowImpl, table) {
   if (table.options.filterFromLeafRows) {
     return filterRowModelFromLeafs(rows, filterRowImpl, table);
   }
-
   return filterRowModelFromRoot(rows, filterRowImpl, table);
 }
 function filterRowModelFromLeafs(rowsToFilter, filterRow, table) {
   const newFilteredFlatRows = [];
   const newFilteredRowsById = {};
-
   const recurseFilterRows = function (rowsToFilter, depth) {
+    const rows = [];
 
-    const rows = []; // Filter from children up first
-
+    // Filter from children up first
     for (let i = 0; i < rowsToFilter.length; i++) {
       var _row$subRows;
-
       let row = rowsToFilter[i];
-
       if ((_row$subRows = row.subRows) != null && _row$subRows.length) {
         const newRow = createRow(table, row.id, row.original, row.index, row.depth);
         newRow.columnFilters = row.columnFilters;
         newRow.subRows = recurseFilterRows(row.subRows);
-
         if (!newRow.subRows.length) {
           continue;
         }
-
         row = newRow;
       }
-
       if (filterRow(row)) {
         rows.push(row);
         newFilteredRowsById[row.id] = row;
         newFilteredRowsById[i] = row;
       }
     }
-
     return rows;
   };
-
   return {
     rows: recurseFilterRows(rowsToFilter),
     flatRows: newFilteredFlatRows,
@@ -3046,35 +2860,32 @@ function filterRowModelFromLeafs(rowsToFilter, filterRow, table) {
 }
 function filterRowModelFromRoot(rowsToFilter, filterRow, table) {
   const newFilteredFlatRows = [];
-  const newFilteredRowsById = {}; // Filters top level and nested rows
+  const newFilteredRowsById = {};
 
+  // Filters top level and nested rows
   const recurseFilterRows = function (rowsToFilter, depth) {
-
     // Filter from parents downward first
-    const rows = []; // Apply the filter to any subRows
 
+    const rows = [];
+
+    // Apply the filter to any subRows
     for (let i = 0; i < rowsToFilter.length; i++) {
       let row = rowsToFilter[i];
       const pass = filterRow(row);
-
       if (pass) {
         var _row$subRows2;
-
         if ((_row$subRows2 = row.subRows) != null && _row$subRows2.length) {
           const newRow = createRow(table, row.id, row.original, row.index, row.depth);
           newRow.subRows = recurseFilterRows(row.subRows);
           row = newRow;
         }
-
         rows.push(row);
         newFilteredFlatRows.push(row);
         newFilteredRowsById[row.id] = row;
       }
     }
-
     return rows;
   };
-
   return {
     rows: recurseFilterRows(rowsToFilter),
     flatRows: newFilteredFlatRows,
@@ -3089,31 +2900,24 @@ function getFilteredRowModel() {
         rowModel.flatRows[i].columnFilters = {};
         rowModel.flatRows[i].columnFiltersMeta = {};
       }
-
       return rowModel;
     }
-
     const resolvedColumnFilters = [];
     const resolvedGlobalFilters = [];
     (columnFilters ?? []).forEach(d => {
       const column = table.getColumn(d.id);
-
       if (!column) {
         if (process.env.NODE_ENV !== 'production') {
           console.warn(`Table: Could not find a column to filter with columnId: ${d.id}`);
         }
       }
-
       const filterFn = column.getFilterFn();
-
       if (!filterFn) {
         if (process.env.NODE_ENV !== 'production') {
           console.warn(`Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`);
         }
-
         return;
       }
-
       resolvedColumnFilters.push({
         id: d.id,
         filterFn,
@@ -3123,7 +2927,6 @@ function getFilteredRowModel() {
     const filterableIds = columnFilters.map(d => d.id);
     const globalFilterFn = table.getGlobalFilterFn();
     const globallyFilterableColumns = table.getAllLeafColumns().filter(column => column.getCanGlobalFilter());
-
     if (globalFilter && globalFilterFn && globallyFilterableColumns.length) {
       filterableIds.push('__global__');
       globallyFilterableColumns.forEach(column => {
@@ -3134,30 +2937,29 @@ function getFilteredRowModel() {
         });
       });
     }
-
     let currentColumnFilter;
-    let currentGlobalFilter; // Flag the prefiltered row model with each filter state
+    let currentGlobalFilter;
 
+    // Flag the prefiltered row model with each filter state
     for (let j = 0; j < rowModel.flatRows.length; j++) {
       const row = rowModel.flatRows[j];
       row.columnFilters = {};
-
       if (resolvedColumnFilters.length) {
         for (let i = 0; i < resolvedColumnFilters.length; i++) {
           currentColumnFilter = resolvedColumnFilters[i];
-          const id = currentColumnFilter.id; // Tag the row with the column filter state
+          const id = currentColumnFilter.id;
 
+          // Tag the row with the column filter state
           row.columnFilters[id] = currentColumnFilter.filterFn(row, id, currentColumnFilter.resolvedValue, filterMeta => {
             row.columnFiltersMeta[id] = filterMeta;
           });
         }
       }
-
       if (resolvedGlobalFilters.length) {
         for (let i = 0; i < resolvedGlobalFilters.length; i++) {
           currentGlobalFilter = resolvedGlobalFilters[i];
-          const id = currentGlobalFilter.id; // Tag the row with the first truthy global filter state
-
+          const id = currentGlobalFilter.id;
+          // Tag the row with the first truthy global filter state
           if (currentGlobalFilter.filterFn(row, id, currentGlobalFilter.resolvedValue, filterMeta => {
             row.columnFiltersMeta[id] = filterMeta;
           })) {
@@ -3165,13 +2967,11 @@ function getFilteredRowModel() {
             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++) {
@@ -3179,11 +2979,10 @@ function getFilteredRowModel() {
           return false;
         }
       }
-
       return true;
-    }; // Filter final rows using all of the active filters
-
+    };
 
+    // Filter final rows using all of the active filters
     return filterRows(rowModel.rows, filterRowsImpl, table);
   }, {
     key: process.env.NODE_ENV === 'development' && 'getFilteredRowModel',
@@ -3199,9 +2998,7 @@ function getFacetedRowModel() {
     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++) {
@@ -3209,10 +3006,8 @@ function getFacetedRowModel() {
           return false;
         }
       }
-
       return true;
     };
-
     return filterRows(preRowModel.rows, filterRowsImpl, table);
   }, {
     key: process.env.NODE_ENV === 'development' && 'getFacetedRowModel_' + columnId,
@@ -3224,19 +3019,15 @@ function getFacetedRowModel() {
 function getFacetedUniqueValues() {
   return (table, columnId) => memo(() => [table.getColumn(columnId).getFacetedRowModel()], facetedRowModel => {
     let facetedUniqueValues = new Map();
-
     for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
       var _facetedRowModel$flat;
-
       const value = (_facetedRowModel$flat = facetedRowModel.flatRows[i]) == null ? void 0 : _facetedRowModel$flat.getValue(columnId);
-
       if (facetedUniqueValues.has(value)) {
         facetedUniqueValues.set(value, (facetedUniqueValues.get(value) ?? 0) + 1);
       } else {
         facetedUniqueValues.set(value, 1);
       }
     }
-
     return facetedUniqueValues;
   }, {
     key: process.env.NODE_ENV === 'development' && 'getFacetedUniqueValues_' + columnId,
@@ -3248,25 +3039,19 @@ function getFacetedUniqueValues() {
 function getFacetedMinMaxValues() {
   return (table, columnId) => memo(() => [table.getColumn(columnId).getFacetedRowModel()], facetedRowModel => {
     var _facetedRowModel$flat;
-
     const firstValue = (_facetedRowModel$flat = facetedRowModel.flatRows[0]) == null ? void 0 : _facetedRowModel$flat.getValue(columnId);
-
     if (typeof firstValue === 'undefined') {
       return undefined;
     }
-
     let facetedMinMaxValues = [firstValue, firstValue];
-
     for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
       const value = facetedRowModel.flatRows[i].getValue(columnId);
-
       if (value < facetedMinMaxValues[0]) {
         facetedMinMaxValues[0] = value;
       } else if (value > facetedMinMaxValues[1]) {
         facetedMinMaxValues[1] = value;
       }
     }
-
     return facetedMinMaxValues;
   }, {
     key: process.env.NODE_ENV === 'development' && 'getFacetedMinMaxValues_' + columnId,
@@ -3280,10 +3065,10 @@ function getSortedRowModel() {
     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 sortedFlatRows = [];
 
+    // Filter out sortings that correspond to non existing columns
     const availableSorting = sortingState.filter(sort => table.getColumn(sort.id).getCanSort());
     const columnInfoById = {};
     availableSorting.forEach(sortEntry => {
@@ -3294,7 +3079,6 @@ function getSortedRowModel() {
         sortingFn: column.getSortingFn()
       };
     });
-
     const sortData = rows => {
       // This will also perform a stable sorting using the row index
       // if needed.
@@ -3304,49 +3088,41 @@ function getSortedRowModel() {
           const sortEntry = availableSorting[i];
           const columnInfo = columnInfoById[sortEntry.id];
           const isDesc = (sortEntry == null ? void 0 : sortEntry.desc) ?? false;
-
           if (columnInfo.sortUndefined) {
             const aValue = rowA.getValue(sortEntry.id);
             const bValue = rowB.getValue(sortEntry.id);
             const aUndefined = typeof aValue === 'undefined';
             const bUndefined = typeof bValue === 'undefined';
-
             if (aUndefined || bUndefined) {
               return aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
             }
-          } // This function should always return in ascending order
-
+          }
 
+          // This function should always return in ascending order
           let sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
-
           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
+      });
 
+      // If there are sub-rows, sort them
       sortedData.forEach(row => {
         sortedFlatRows.push(row);
-
         if (!row.subRows || row.subRows.length <= 1) {
           return;
         }
-
         row.subRows = sortData(row.subRows);
       });
       return sortedData;
     };
-
     return {
       rows: sortData(rowModel.rows),
       flatRows: sortedFlatRows,
@@ -3365,22 +3141,22 @@ function getGroupedRowModel() {
   return table => memo(() => [table.getState().grouping, table.getPreGroupedRowModel()], (grouping, rowModel) => {
     if (!rowModel.rows.length || !grouping.length) {
       return rowModel;
-    } // Filter the grouping list down to columns that exist
-
+    }
 
+    // Filter the grouping list down to columns that exist
     const existingGrouping = grouping.filter(columnId => table.getColumn(columnId));
     const groupedFlatRows = [];
-    const groupedRowsById = {}; // const onlyGroupedFlatRows: Row[] = [];
+    const groupedRowsById = {};
+    // const onlyGroupedFlatRows: Row[] = [];
     // const onlyGroupedRowsById: Record<RowId, Row> = {};
     // const nonGroupedFlatRows: Row[] = [];
     // const nonGroupedRowsById: Record<RowId, Row> = {};
-    // Recursively group the data
 
+    // Recursively group the data
     const groupUpRecursively = function (rows, depth, parentId) {
       if (depth === void 0) {
         depth = 0;
       }
-
       // Grouping depth has been been met
       // Stop grouping and simply rewrite thd depth and row relationships
       if (depth >= existingGrouping.length) {
@@ -3388,26 +3164,27 @@ function getGroupedRowModel() {
           row.depth = depth;
           groupedFlatRows.push(row);
           groupedRowsById[row.id] = row;
-
           if (row.subRows) {
             row.subRows = groupUpRecursively(row.subRows, depth + 1);
           }
-
           return row;
         });
       }
+      const columnId = existingGrouping[depth];
 
-      const columnId = existingGrouping[depth]; // Group the rows together for this level
-
-      const rowGroupsMap = groupBy(rows, columnId); // Peform aggregations for each group
+      // Group the rows together for this level
+      const rowGroupsMap = groupBy(rows, columnId);
 
+      // Peform aggregations for each group
       const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map((_ref, index) => {
         let [groupingValue, groupedRows] = _ref;
         let id = `${columnId}:${groupingValue}`;
-        id = parentId ? `${parentId}>${id}` : id; // First, Recurse to group sub rows before aggregation
+        id = parentId ? `${parentId}>${id}` : id;
 
-        const subRows = groupUpRecursively(groupedRows, depth + 1, id); // Flatten the leaf rows of the rows in this group
+        // First, Recurse to group sub rows before aggregation
+        const subRows = groupUpRecursively(groupedRows, depth + 1, id);
 
+        // Flatten the leaf rows of the rows in this group
         const leafRows = depth ? flattenBy(groupedRows, row => row.subRows) : groupedRows;
         const row = createRow(table, id, leafRows[0].original, index, depth);
         Object.assign(row, {
@@ -3421,22 +3198,18 @@ function getGroupedRowModel() {
               if (row._valuesCache.hasOwnProperty(columnId)) {
                 return row._valuesCache[columnId];
               }
-
               if (groupedRows[0]) {
                 row._valuesCache[columnId] = groupedRows[0].getValue(columnId) ?? undefined;
               }
-
               return row._valuesCache[columnId];
             }
-
             if (row._groupingValuesCache.hasOwnProperty(columnId)) {
               return row._groupingValuesCache[columnId];
-            } // Aggregate the values
-
+            }
 
+            // Aggregate the values
             const column = table.getColumn(columnId);
             const aggregateFn = column.getAggregationFn();
-
             if (aggregateFn) {
               row._groupingValuesCache[columnId] = aggregateFn(columnId, leafRows, groupedRows);
               return row._groupingValuesCache[columnId];
@@ -3445,7 +3218,8 @@ function getGroupedRowModel() {
         });
         subRows.forEach(subRow => {
           groupedFlatRows.push(subRow);
-          groupedRowsById[subRow.id] = subRow; // if (subRow.getIsGrouped?.()) {
+          groupedRowsById[subRow.id] = subRow;
+          // if (subRow.getIsGrouped?.()) {
           //   onlyGroupedFlatRows.push(subRow);
           //   onlyGroupedRowsById[subRow.id] = subRow;
           // } else {
@@ -3453,15 +3227,16 @@ function getGroupedRowModel() {
           //   nonGroupedRowsById[subRow.id] = subRow;
           // }
         });
+
         return row;
       });
       return aggregatedGroupedRows;
     };
-
     const groupedRows = groupUpRecursively(rowModel.rows, 0, '');
     groupedRows.forEach(subRow => {
       groupedFlatRows.push(subRow);
-      groupedRowsById[subRow.id] = subRow; // if (subRow.getIsGrouped?.()) {
+      groupedRowsById[subRow.id] = subRow;
+      // if (subRow.getIsGrouped?.()) {
       //   onlyGroupedFlatRows.push(subRow);
       //   onlyGroupedRowsById[subRow.id] = subRow;
       // } else {
@@ -3469,6 +3244,7 @@ function getGroupedRowModel() {
       //   nonGroupedRowsById[subRow.id] = subRow;
       // }
     });
+
     return {
       rows: groupedRows,
       flatRows: groupedFlatRows,
@@ -3480,25 +3256,21 @@ function getGroupedRowModel() {
     onChange: () => {
       table._queue(() => {
         table._autoResetExpanded();
-
         table._autoResetPageIndex();
       });
     }
   });
 }
-
 function groupBy(rows, columnId) {
   const groupMap = new Map();
   return rows.reduce((map, row) => {
     const resKey = `${row.getValue(columnId)}`;
     const previous = map.get(resKey);
-
     if (!previous) {
       map.set(resKey, [row]);
     } else {
       map.set(resKey, [...previous, row]);
     }
-
     return map;
   }, groupMap);
 }
@@ -3508,12 +3280,10 @@ function getExpandedRowModel() {
     if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded ?? {}).length) {
       return rowModel;
     }
-
     if (!paginateExpandedRows) {
       // Only expand rows at this point if they are being paginated
       return rowModel;
     }
-
     return expandRows(rowModel);
   }, {
     key: process.env.NODE_ENV === 'development' && 'getExpandedRowModel',
@@ -3522,17 +3292,13 @@ function 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,
@@ -3546,7 +3312,6 @@ function getPaginationRowModel(opts) {
     if (!rowModel.rows.length) {
       return rowModel;
     }
-
     const {
       pageSize,
       pageIndex
@@ -3560,7 +3325,6 @@ function getPaginationRowModel(opts) {
     const pageEnd = pageStart + pageSize;
     rows = rows.slice(pageStart, pageEnd);
     let paginatedRowModel;
-
     if (!table.options.paginateExpandedRows) {
       paginatedRowModel = expandRows({
         rows,
@@ -3574,17 +3338,13 @@ function getPaginationRowModel(opts) {
         rowsById
       };
     }
-
     paginatedRowModel.flatRows = [];
-
     const handleRow = row => {
       paginatedRowModel.flatRows.push(row);
-
       if (row.subRows.length) {
         row.subRows.forEach(handleRow);
       }
     };
-
     paginatedRowModel.rows.forEach(handleRow);
     return paginatedRowModel;
   }, {
@@ -3594,25 +3354,22 @@ function getPaginationRowModel(opts) {
 }
 
 //
+
 function flexRender(Comp, props) {
   return !Comp ? null : isReactComponent(Comp) ? /*#__PURE__*/React.createElement(Comp, props) : Comp;
 }
-
 function isReactComponent(component) {
   return isClassComponent(component) || typeof component === 'function' || isExoticComponent(component);
 }
-
 function isClassComponent(component) {
   return typeof component === 'function' && (() => {
     const proto = Object.getPrototypeOf(component);
     return proto.prototype && proto.prototype.isReactComponent;
   })();
 }
-
 function isExoticComponent(component) {
   return typeof component === 'object' && typeof component.$$typeof === 'symbol' && ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description);
 }
-
 function useReactTable(options) {
   // Compose in the generic options to the user options
   const resolvedOptions = {
@@ -3622,18 +3379,23 @@ function useReactTable(options) {
     // noop
     renderFallbackValue: null,
     ...options
-  }; // Create a new table and store it in state
+  };
 
+  // Create a new table and store it in state
   const [tableRef] = React.useState(() => ({
     current: createTable(resolvedOptions)
-  })); // By default, manage table state here using the table's initial state
+  }));
 
-  const [state, setState] = React.useState(() => tableRef.current.initialState); // Compose the default state above with any user state. This will allow the user
-  // to only control a subset of the state if desired.
+  // By default, manage table state here using the table's initial state
+  const [state, setState] = React.useState(() => tableRef.current.initialState);
 
-  tableRef.current.setOptions(prev => ({ ...prev,
+  // Compose the default state above with any user state. This will allow the user
+  // to only control a subset of the state if desired.
+  tableRef.current.setOptions(prev => ({
+    ...prev,
     ...options,
-    state: { ...state,
+    state: {
+      ...state,
       ...options.state
     },
     // Similarly, we'll maintain both our internal state and any user-provided