@ni/nimble-components 15.5.3 → 15.5.5

package/dist/all-components-bundle.js

@@ -21674,17 +21674,3097 @@
     });
     DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleTabPanel());
 
+    /**
+     * table-core
+     *
+     * Copyright (c) TanStack
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE.md file in the root directory of this source tree.
+     *
+     * @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 makeStateUpdater(key, instance) {
+      return updater => {
+        instance.setState(old => {
+          return {
+            ...old,
+            [key]: functionalUpdate(updater, old[key])
+          };
+        });
+      };
+    }
+    function isFunction(d) {
+      return d instanceof Function;
+    }
+    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;
+    }
+    function memo(getDeps, fn, opts) {
+      let deps = [];
+      let result;
+      return () => {
+        let depTime;
+        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) {
+      var _ref, _resolvedColumnDef$id;
+      const defaultColumn = table._getDefaultColumnDef();
+      const resolvedColumnDef = {
+        ...defaultColumn,
+        ...columnDef
+      };
+      const accessorKey = resolvedColumnDef.accessorKey;
+      let id = (_ref = (_resolvedColumnDef$id = resolvedColumnDef.id) != null ? _resolvedColumnDef$id : accessorKey ? accessorKey.replace('.', '_') : undefined) != null ? _ref : typeof resolvedColumnDef.header === 'string' ? resolvedColumnDef.header : undefined;
+      let accessorFn;
+      if (resolvedColumnDef.accessorFn) {
+        accessorFn = resolvedColumnDef.accessorFn;
+      } else if (accessorKey) {
+        // Support deep accessor keys
+        if (accessorKey.includes('.')) {
+          accessorFn = originalRow => {
+            let result = originalRow;
+            for (const key of accessorKey.split('.')) {
+              result = result[key];
+              if (process.env.NODE_ENV !== 'production' && result === undefined) {
+                throw new Error(`"${key}" in deeply nested key "${accessorKey}" returned undefined.`);
+              }
+            }
+            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,
+        parent: parent,
+        depth,
+        columnDef: resolvedColumnDef,
+        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',
+          debug: () => {
+            var _table$options$debugA;
+            return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugColumns;
+          }
+        }),
+        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',
+          debug: () => {
+            var _table$options$debugA2;
+            return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugColumns;
+          }
+        })
+      };
+      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.
+      return column;
+    }
+
+    //
+
+    function createHeader(table, column, options) {
+      var _options$id;
+      const id = (_options$id = options.id) != null ? _options$id : column.id;
+      let header = {
+        id,
+        column,
+        index: options.index,
+        isPlaceholder: !!options.isPlaceholder,
+        placeholderId: options.placeholderId,
+        depth: options.depth,
+        subHeaders: [],
+        colSpan: 0,
+        rowSpan: 0,
+        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;
+        },
+        getContext: () => ({
+          table,
+          header: header,
+          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) => {
+            var _left$map$filter, _right$map$filter;
+            const leftColumns = (_left$map$filter = left == null ? void 0 : left.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter : [];
+            const rightColumns = (_right$map$filter = right == null ? void 0 : right.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter : [];
+            const centerColumns = leafColumns.filter(column => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id)));
+            const headerGroups = buildHeaderGroups(allColumns, [...leftColumns, ...centerColumns, ...rightColumns], table);
+            return headerGroups;
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getHeaderGroups',
+            debug: () => {
+              var _table$options$debugA;
+              return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugHeaders;
+            }
+          }),
+          getCenterHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => {
+            leafColumns = leafColumns.filter(column => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id)));
+            return buildHeaderGroups(allColumns, leafColumns, table, 'center');
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getCenterHeaderGroups',
+            debug: () => {
+              var _table$options$debugA2;
+              return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugHeaders;
+            }
+          }),
+          getLeftHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left], (allColumns, leafColumns, left) => {
+            var _left$map$filter2;
+            const orderedLeafColumns = (_left$map$filter2 = left == null ? void 0 : left.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter2 : [];
+            return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'left');
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeftHeaderGroups',
+            debug: () => {
+              var _table$options$debugA3;
+              return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugHeaders;
+            }
+          }),
+          getRightHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.right], (allColumns, leafColumns, right) => {
+            var _right$map$filter2;
+            const orderedLeafColumns = (_right$map$filter2 = right == null ? void 0 : right.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter2 : [];
+            return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'right');
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getRightHeaderGroups',
+            debug: () => {
+              var _table$options$debugA4;
+              return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugHeaders;
+            }
+          }),
+          // Footer Groups
+
+          getFooterGroups: memo(() => [table.getHeaderGroups()], headerGroups => {
+            return [...headerGroups].reverse();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getFooterGroups',
+            debug: () => {
+              var _table$options$debugA5;
+              return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugHeaders;
+            }
+          }),
+          getLeftFooterGroups: memo(() => [table.getLeftHeaderGroups()], headerGroups => {
+            return [...headerGroups].reverse();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeftFooterGroups',
+            debug: () => {
+              var _table$options$debugA6;
+              return (_table$options$debugA6 = table.options.debugAll) != null ? _table$options$debugA6 : table.options.debugHeaders;
+            }
+          }),
+          getCenterFooterGroups: memo(() => [table.getCenterHeaderGroups()], headerGroups => {
+            return [...headerGroups].reverse();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getCenterFooterGroups',
+            debug: () => {
+              var _table$options$debugA7;
+              return (_table$options$debugA7 = table.options.debugAll) != null ? _table$options$debugA7 : table.options.debugHeaders;
+            }
+          }),
+          getRightFooterGroups: memo(() => [table.getRightHeaderGroups()], headerGroups => {
+            return [...headerGroups].reverse();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getRightFooterGroups',
+            debug: () => {
+              var _table$options$debugA8;
+              return (_table$options$debugA8 = table.options.debugAll) != null ? _table$options$debugA8 : table.options.debugHeaders;
+            }
+          }),
+          // Flat Headers
+
+          getFlatHeaders: memo(() => [table.getHeaderGroups()], headerGroups => {
+            return headerGroups.map(headerGroup => {
+              return headerGroup.headers;
+            }).flat();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getFlatHeaders',
+            debug: () => {
+              var _table$options$debugA9;
+              return (_table$options$debugA9 = table.options.debugAll) != null ? _table$options$debugA9 : table.options.debugHeaders;
+            }
+          }),
+          getLeftFlatHeaders: memo(() => [table.getLeftHeaderGroups()], left => {
+            return left.map(headerGroup => {
+              return headerGroup.headers;
+            }).flat();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeftFlatHeaders',
+            debug: () => {
+              var _table$options$debugA10;
+              return (_table$options$debugA10 = table.options.debugAll) != null ? _table$options$debugA10 : table.options.debugHeaders;
+            }
+          }),
+          getCenterFlatHeaders: memo(() => [table.getCenterHeaderGroups()], left => {
+            return left.map(headerGroup => {
+              return headerGroup.headers;
+            }).flat();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getCenterFlatHeaders',
+            debug: () => {
+              var _table$options$debugA11;
+              return (_table$options$debugA11 = table.options.debugAll) != null ? _table$options$debugA11 : table.options.debugHeaders;
+            }
+          }),
+          getRightFlatHeaders: memo(() => [table.getRightHeaderGroups()], left => {
+            return left.map(headerGroup => {
+              return headerGroup.headers;
+            }).flat();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getRightFlatHeaders',
+            debug: () => {
+              var _table$options$debugA12;
+              return (_table$options$debugA12 = table.options.debugAll) != null ? _table$options$debugA12 : 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);
+            });
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getCenterLeafHeaders',
+            debug: () => {
+              var _table$options$debugA13;
+              return (_table$options$debugA13 = table.options.debugAll) != null ? _table$options$debugA13 : table.options.debugHeaders;
+            }
+          }),
+          getLeftLeafHeaders: memo(() => [table.getLeftFlatHeaders()], flatHeaders => {
+            return flatHeaders.filter(header => {
+              var _header$subHeaders2;
+              return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length);
+            });
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeftLeafHeaders',
+            debug: () => {
+              var _table$options$debugA14;
+              return (_table$options$debugA14 = table.options.debugAll) != null ? _table$options$debugA14 : table.options.debugHeaders;
+            }
+          }),
+          getRightLeafHeaders: memo(() => [table.getRightFlatHeaders()], flatHeaders => {
+            return flatHeaders.filter(header => {
+              var _header$subHeaders3;
+              return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length);
+            });
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getRightLeafHeaders',
+            debug: () => {
+              var _table$options$debugA15;
+              return (_table$options$debugA15 = table.options.debugAll) != null ? _table$options$debugA15 : table.options.debugHeaders;
+            }
+          }),
+          getLeafHeaders: memo(() => [table.getLeftHeaderGroups(), table.getCenterHeaderGroups(), table.getRightHeaderGroups()], (left, center, right) => {
+            var _left$0$headers, _left$, _center$0$headers, _center$, _right$0$headers, _right$;
+            return [...((_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : []), ...((_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : []), ...((_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : [])].map(header => {
+              return header.getLeafHeaders();
+            }).flat();
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeafHeaders',
+            debug: () => {
+              var _table$options$debugA16;
+              return (_table$options$debugA16 = table.options.debugAll) != null ? _table$options$debugA16 : table.options.debugHeaders;
+            }
+          })
+        };
+      }
+    };
+    function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
+      var _headerGroups$0$heade, _headerGroups$;
+      // Find the max depth of the columns:
+      // build the leaf column row
+      // build each buffer row going up
+      //    placeholder for non-existent level
+      //    real column for existing level
+
+      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
+        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;
+          } else {
+            // The parent header is repeated
+            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);
+          } else {
+            // This is a new header. Let's create it
+            const header = createHeader(table, column, {
+              id: [headerFamily, depth, column.id, headerToGroup == null ? void 0 : headerToGroup.id].filter(Boolean).join('_'),
+              isPlaceholder,
+              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
+            // 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 => {
+      //   return !headerGroup.headers.every(header => header.isPlaceholder)
+      // })
+
+      const recurseHeadersForSpans = headers => {
+        const filteredHeaders = headers.filter(header => header.column.getIsVisible());
+        return filteredHeaders.map(header => {
+          let colSpan = 0;
+          let rowSpan = 0;
+          let childRowSpans = [0];
+          if (header.subHeaders && header.subHeaders.length) {
+            childRowSpans = [];
+            recurseHeadersForSpans(header.subHeaders).forEach(_ref => {
+              let {
+                colSpan: childColSpan,
+                rowSpan: childRowSpan
+              } = _ref;
+              colSpan += childColSpan;
+              childRowSpans.push(childRowSpan);
+            });
+          } else {
+            colSpan = 1;
+          }
+          const minChildRowSpan = Math.min(...childRowSpans);
+          rowSpan = rowSpan + minChildRowSpan;
+          header.colSpan = colSpan;
+          header.rowSpan = rowSpan;
+          return {
+            colSpan,
+            rowSpan
+          };
+        });
+      };
+      recurseHeadersForSpans((_headerGroups$0$heade = (_headerGroups$ = headerGroups[0]) == null ? void 0 : _headerGroups$.headers) != null ? _headerGroups$0$heade : []);
+      return headerGroups;
+    }
+
+    //
+
+    const defaultColumnSizing = {
+      size: 150,
+      minSize: 20,
+      maxSize: Number.MAX_SAFE_INTEGER
+    };
+    const getDefaultColumnSizingInfoState = () => ({
+      startOffset: null,
+      startSize: null,
+      deltaOffset: null,
+      deltaPercentage: null,
+      isResizingColumn: false,
+      columnSizingStart: []
+    });
+    const ColumnSizing = {
+      getDefaultColumnDef: () => {
+        return defaultColumnSizing;
+      },
+      getInitialState: state => {
+        return {
+          columnSizing: {},
+          columnSizingInfo: getDefaultColumnSizingInfoState(),
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          columnResizeMode: 'onEnd',
+          onColumnSizingChange: makeStateUpdater('columnSizing', table),
+          onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table)
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          getSize: () => {
+            var _column$columnDef$min, _ref, _column$columnDef$max;
+            const columnSize = table.getState().columnSizing[column.id];
+            return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize);
+          },
+          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: () => {
+            table.setColumnSizing(_ref2 => {
+              let {
+                [column.id]: _,
+                ...rest
+              } = _ref2;
+              return rest;
+            });
+          },
+          getCanResize: () => {
+            var _column$columnDef$ena, _table$options$enable;
+            return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true);
+          },
+          getIsResizing: () => {
+            return table.getState().columnSizingInfo.isResizingColumn === column.id;
+          }
+        };
+      },
+      createHeader: (header, table) => {
+        return {
+          getSize: () => {
+            let sum = 0;
+            const recurse = header => {
+              if (header.subHeaders.length) {
+                header.subHeaders.forEach(recurse);
+              } else {
+                var _header$column$getSiz;
+                sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
+              }
+            };
+            recurse(header);
+            return sum;
+          },
+          getStart: () => {
+            if (header.index > 0) {
+              const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
+              return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
+            }
+            return 0;
+          },
+          getResizeHandler: () => {
+            const column = table.getColumn(header.column.id);
+            const canResize = column.getCanResize();
+            return e => {
+              if (!canResize) {
+                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 => {
+                  var _old$startOffset, _old$startSize;
+                  const deltaOffset = clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0);
+                  const deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999);
+                  old.columnSizingStart.forEach(_ref3 => {
+                    let [columnId, headerSize] = _ref3;
+                    newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100;
+                  });
+                  return {
+                    ...old,
+                    deltaOffset,
+                    deltaPercentage
+                  };
+                });
+                if (table.options.columnResizeMode === 'onChange' || eventType === 'end') {
+                  table.setColumnSizing(old => ({
+                    ...old,
+                    ...newColumnSizing
+                  }));
+                }
+              };
+              const onMove = clientXPos => updateOffset('move', clientXPos);
+              const onEnd = clientXPos => {
+                updateOffset('end', clientXPos);
+                table.setColumnSizingInfo(old => ({
+                  ...old,
+                  isResizingColumn: false,
+                  startOffset: null,
+                  startSize: null,
+                  deltaOffset: null,
+                  deltaPercentage: null,
+                  columnSizingStart: []
+                }));
+              };
+              const mouseEvents = {
+                moveHandler: e => onMove(e.clientX),
+                upHandler: e => {
+                  document.removeEventListener('mousemove', mouseEvents.moveHandler);
+                  document.removeEventListener('mouseup', mouseEvents.upHandler);
+                  onEnd(e.clientX);
+                }
+              };
+              const touchEvents = {
+                moveHandler: e => {
+                  if (e.cancelable) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                  }
+                  onMove(e.touches[0].clientX);
+                  return false;
+                },
+                upHandler: e => {
+                  var _e$touches$;
+                  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)) {
+                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,
+                startOffset: clientX,
+                startSize,
+                deltaOffset: 0,
+                deltaPercentage: 0,
+                columnSizingStart,
+                isResizingColumn: column.id
+              }));
+            };
+          }
+        };
+      },
+      createTable: table => {
+        return {
+          setColumnSizing: updater => table.options.onColumnSizingChange == null ? void 0 : table.options.onColumnSizingChange(updater),
+          setColumnSizingInfo: updater => table.options.onColumnSizingInfoChange == null ? void 0 : table.options.onColumnSizingInfoChange(updater),
+          resetColumnSizing: defaultState => {
+            var _table$initialState$c;
+            table.setColumnSizing(defaultState ? {} : (_table$initialState$c = table.initialState.columnSizing) != null ? _table$initialState$c : {});
+          },
+          resetHeaderSizeInfo: defaultState => {
+            var _table$initialState$c2;
+            table.setColumnSizingInfo(defaultState ? getDefaultColumnSizingInfoState() : (_table$initialState$c2 = table.initialState.columnSizingInfo) != null ? _table$initialState$c2 : getDefaultColumnSizingInfoState());
+          },
+          getTotalSize: () => {
+            var _table$getHeaderGroup, _table$getHeaderGroup2;
+            return (_table$getHeaderGroup = (_table$getHeaderGroup2 = table.getHeaderGroups()[0]) == null ? void 0 : _table$getHeaderGroup2.headers.reduce((sum, header) => {
+              return sum + header.getSize();
+            }, 0)) != null ? _table$getHeaderGroup : 0;
+          },
+          getLeftTotalSize: () => {
+            var _table$getLeftHeaderG, _table$getLeftHeaderG2;
+            return (_table$getLeftHeaderG = (_table$getLeftHeaderG2 = table.getLeftHeaderGroups()[0]) == null ? void 0 : _table$getLeftHeaderG2.headers.reduce((sum, header) => {
+              return sum + header.getSize();
+            }, 0)) != null ? _table$getLeftHeaderG : 0;
+          },
+          getCenterTotalSize: () => {
+            var _table$getCenterHeade, _table$getCenterHeade2;
+            return (_table$getCenterHeade = (_table$getCenterHeade2 = table.getCenterHeaderGroups()[0]) == null ? void 0 : _table$getCenterHeade2.headers.reduce((sum, header) => {
+              return sum + header.getSize();
+            }, 0)) != null ? _table$getCenterHeade : 0;
+          },
+          getRightTotalSize: () => {
+            var _table$getRightHeader, _table$getRightHeader2;
+            return (_table$getRightHeader = (_table$getRightHeader2 = table.getRightHeaderGroups()[0]) == null ? void 0 : _table$getRightHeader2.headers.reduce((sum, header) => {
+              return sum + header.getSize();
+            }, 0)) != null ? _table$getRightHeader : 0;
+          }
+        };
+      }
+    };
+    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 {
+          expanded: {},
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onExpandedChange: makeStateUpdater('expanded', table),
+          paginateExpandedRows: true
+        };
+      },
+      createTable: table => {
+        let registered = false;
+        let queued = false;
+        return {
+          _autoResetExpanded: () => {
+            var _ref, _table$options$autoRe;
+            if (!registered) {
+              table._queue(() => {
+                registered = true;
+              });
+              return;
+            }
+            if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) {
+              if (queued) return;
+              queued = true;
+              table._queue(() => {
+                table.resetExpanded();
+                queued = false;
+              });
+            }
+          },
+          setExpanded: updater => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater),
+          toggleAllRowsExpanded: expanded => {
+            if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) {
+              table.setExpanded(true);
+            } else {
+              table.setExpanded({});
+            }
+          },
+          resetExpanded: defaultState => {
+            var _table$initialState$e, _table$initialState;
+            table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {});
+          },
+          getCanSomeRowsExpand: () => {
+            return table.getRowModel().flatRows.some(row => row.getCanExpand());
+          },
+          getToggleAllRowsExpandedHandler: () => {
+            return e => {
+              e.persist == null ? void 0 : e.persist();
+              table.toggleAllRowsExpanded();
+            };
+          },
+          getIsSomeRowsExpanded: () => {
+            const expanded = table.getState().expanded;
+            return expanded === true || Object.values(expanded).some(Boolean);
+          },
+          getIsAllRowsExpanded: () => {
+            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 (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
+              return false;
+            }
+
+            // They must all be expanded :shrug:
+            return true;
+          },
+          getExpandedDepth: () => {
+            let maxDepth = 0;
+            const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded);
+            rowIds.forEach(id => {
+              const splitId = id.split('.');
+              maxDepth = Math.max(maxDepth, splitId.length);
+            });
+            return maxDepth;
+          },
+          getPreExpandedRowModel: () => table.getSortedRowModel(),
+          getExpandedRowModel: () => {
+            if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
+              table._getExpandedRowModel = table.options.getExpandedRowModel(table);
+            }
+            if (table.options.manualExpanding || !table._getExpandedRowModel) {
+              return table.getPreExpandedRowModel();
+            }
+            return table._getExpandedRowModel();
+          }
+        };
+      },
+      createRow: (row, table) => {
+        return {
+          toggleExpanded: expanded => {
+            table.setExpanded(old => {
+              var _expanded;
+              const exists = old === true ? true : !!(old != null && old[row.id]);
+              let oldExpanded = {};
+              if (old === true) {
+                Object.keys(table.getRowModel().rowsById).forEach(rowId => {
+                  oldExpanded[rowId] = true;
+                });
+              } else {
+                oldExpanded = old;
+              }
+              expanded = (_expanded = expanded) != null ? _expanded : !exists;
+              if (!exists && expanded) {
+                return {
+                  ...oldExpanded,
+                  [row.id]: true
+                };
+              }
+              if (exists && !expanded) {
+                const {
+                  [row.id]: _,
+                  ...rest
+                } = oldExpanded;
+                return rest;
+              }
+              return old;
+            });
+          },
+          getIsExpanded: () => {
+            var _table$options$getIsR;
+            const expanded = table.getState().expanded;
+            return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id]));
+          },
+          getCanExpand: () => {
+            var _table$options$getRow, _table$options$enable, _row$subRows;
+            return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+          },
+          getToggleExpandedHandler: () => {
+            const canExpand = row.getCanExpand();
+            return () => {
+              if (!canExpand) return;
+              row.toggleExpanded();
+            };
+          }
+        };
+      }
+    };
+
+    const includesString = (row, columnId, filterValue) => {
+      var _row$getValue;
+      const search = filterValue.toLowerCase();
+      return Boolean((_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 Boolean((_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]);
+
+    // Export
+
+    const filterFns = {
+      includesString,
+      includesStringSensitive,
+      equalsString,
+      arrIncludes,
+      arrIncludesAll,
+      arrIncludesSome,
+      equals,
+      weakEquals,
+      inNumberRange
+    };
+    // Utils
+
+    function testFalsey(val) {
+      return val === undefined || val === null || val === '';
+    }
+
+    //
+
+    const Filters = {
+      getDefaultColumnDef: () => {
+        return {
+          filterFn: 'auto'
+        };
+      },
+      getInitialState: state => {
+        return {
+          columnFilters: [],
+          globalFilter: undefined,
+          // filtersProgress: 1,
+          // facetProgress: {},
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onColumnFiltersChange: makeStateUpdater('columnFilters', table),
+          onGlobalFilterChange: makeStateUpdater('globalFilter', table),
+          filterFromLeafRows: false,
+          maxLeafRowFilterDepth: 100,
+          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';
+          }
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          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, _table$options$filter2;
+            return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn()
+            // @ts-ignore
+            : (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn];
+          },
+          getCanFilter: () => {
+            var _column$columnDef$ena, _table$options$enable, _table$options$enable2;
+            return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn;
+          },
+          getCanGlobalFilter: () => {
+            var _column$columnDef$ena2, _table$options$enable3, _table$options$enable4, _table$options$getCol;
+            return ((_column$columnDef$ena2 = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena2 : true) && ((_table$options$enable3 = table.options.enableGlobalFilter) != null ? _table$options$enable3 : true) && ((_table$options$enable4 = table.options.enableFilters) != null ? _table$options$enable4 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn;
+          },
+          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, _table$getState$colum4;
+            return (_table$getState$colum3 = (_table$getState$colum4 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum4.findIndex(d => d.id === column.id)) != null ? _table$getState$colum3 : -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);
+
+              //
+              if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
+                var _old$filter;
+                return (_old$filter = old == null ? void 0 : old.filter(d => d.id !== column.id)) != null ? _old$filter : [];
+              }
+              const newFilterObj = {
+                id: column.id,
+                value: newFilter
+              };
+              if (previousfilter) {
+                var _old$map;
+                return (_old$map = old == null ? void 0 : old.map(d => {
+                  if (d.id === column.id) {
+                    return newFilterObj;
+                  }
+                  return d;
+                })) != null ? _old$map : [];
+              }
+              if (old != null && old.length) {
+                return [...old, newFilterObj];
+              }
+              return [newFilterObj];
+            });
+          },
+          _getFacetedRowModel: table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id),
+          getFacetedRowModel: () => {
+            if (!column._getFacetedRowModel) {
+              return table.getPreFilteredRowModel();
+            }
+            return column._getFacetedRowModel();
+          },
+          _getFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id),
+          getFacetedUniqueValues: () => {
+            if (!column._getFacetedUniqueValues) {
+              return new Map();
+            }
+            return column._getFacetedUniqueValues();
+          },
+          _getFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id),
+          getFacetedMinMaxValues: () => {
+            if (!column._getFacetedMinMaxValues) {
+              return undefined;
+            }
+            return column._getFacetedMinMaxValues();
+          }
+          // () => [column.getFacetedRowModel()],
+          // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
+        };
+      },
+
+      createRow: (row, table) => {
+        return {
+          columnFilters: {},
+          columnFiltersMeta: {}
+        };
+      },
+      createTable: table => {
+        return {
+          getGlobalAutoFilterFn: () => {
+            return filterFns.includesString;
+          },
+          getGlobalFilterFn: () => {
+            var _table$options$filter3, _table$options$filter4;
+            const {
+              globalFilterFn: globalFilterFn
+            } = table.options;
+            return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === 'auto' ? table.getGlobalAutoFilterFn()
+            // @ts-ignore
+            : (_table$options$filter3 = (_table$options$filter4 = table.options.filterFns) == null ? void 0 : _table$options$filter4[globalFilterFn]) != null ? _table$options$filter3 : filterFns[globalFilterFn];
+          },
+          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 => {
+            table.options.onGlobalFilterChange == null ? void 0 : table.options.onGlobalFilterChange(updater);
+          },
+          resetGlobalFilter: defaultState => {
+            table.setGlobalFilter(defaultState ? undefined : table.initialState.globalFilter);
+          },
+          resetColumnFilters: defaultState => {
+            var _table$initialState$c, _table$initialState;
+            table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []);
+          },
+          getPreFilteredRowModel: () => table.getCoreRowModel(),
+          getFilteredRowModel: () => {
+            if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
+              table._getFilteredRowModel = table.options.getFilteredRowModel(table);
+            }
+            if (table.options.manualFiltering || !table._getFilteredRowModel) {
+              return table.getPreFilteredRowModel();
+            }
+            return table._getFilteredRowModel();
+          },
+          _getGlobalFacetedRowModel: table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, '__global__'),
+          getGlobalFacetedRowModel: () => {
+            if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {
+              return table.getPreFilteredRowModel();
+            }
+            return table._getGlobalFacetedRowModel();
+          },
+          _getGlobalFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, '__global__'),
+          getGlobalFacetedUniqueValues: () => {
+            if (!table._getGlobalFacetedUniqueValues) {
+              return new Map();
+            }
+            return table._getGlobalFacetedUniqueValues();
+          },
+          _getGlobalFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, '__global__'),
+          getGlobalFacetedMinMaxValues: () => {
+            if (!table._getGlobalFacetedMinMaxValues) {
+              return;
+            }
+            return table._getGlobalFacetedMinMaxValues();
+          }
+        };
+      }
+    };
+    function shouldAutoRemoveFilter(filterFn, value, column) {
+      return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
+    }
+
+    const sum = (columnId, _leafRows, childRows) => {
+      // It's faster to just add the aggregations together instead of
+      // process leaf nodes individually
+      return childRows.reduce((sum, next) => {
+        const nextValue = next.getValue(columnId);
+        return sum + (typeof nextValue === 'number' ? nextValue : 0);
+      }, 0);
+    };
+    const min = (columnId, _leafRows, childRows) => {
+      let min;
+      childRows.forEach(row => {
+        const value = row.getValue(columnId);
+        if (value != null && (min > value || min === undefined && value >= value)) {
+          min = value;
+        }
+      });
+      return min;
+    };
+    const max = (columnId, _leafRows, childRows) => {
+      let max;
+      childRows.forEach(row => {
+        const value = row.getValue(columnId);
+        if (value != null && (max < value || max === undefined && value >= value)) {
+          max = value;
+        }
+      });
+      return max;
+    };
+    const extent = (columnId, _leafRows, childRows) => {
+      let min;
+      let max;
+      childRows.forEach(row => {
+        const value = row.getValue(columnId);
+        if (value != null) {
+          if (min === undefined) {
+            if (value >= value) min = max = value;
+          } else {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      });
+      return [min, max];
+    };
+    const mean = (columnId, leafRows) => {
+      let count = 0;
+      let sum = 0;
+      leafRows.forEach(row => {
+        let value = row.getValue(columnId);
+        if (value != null && (value = +value) >= value) {
+          ++count, sum += value;
+        }
+      });
+      if (count) return sum / count;
+      return;
+    };
+    const median = (columnId, leafRows) => {
+      if (!leafRows.length) {
+        return;
+      }
+      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);
+        }
+      });
+      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,
+      max,
+      extent,
+      mean,
+      median,
+      unique,
+      uniqueCount,
+      count
+    };
+
+    //
+
+    const Grouping = {
+      getDefaultColumnDef: () => {
+        return {
+          aggregatedCell: props => {
+            var _toString, _props$getValue;
+            return (_toString = (_props$getValue = props.getValue()) == null ? void 0 : _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null;
+          },
+          aggregationFn: 'auto'
+        };
+      },
+      getInitialState: state => {
+        return {
+          grouping: [],
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onGroupingChange: makeStateUpdater('grouping', table),
+          groupedColumnMode: 'reorder'
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          toggleGrouping: () => {
+            table.setGrouping(old => {
+              // Find any existing grouping for this column
+              if (old != null && old.includes(column.id)) {
+                return old.filter(d => d !== column.id);
+              }
+              return [...(old != null ? old : []), column.id];
+            });
+          },
+          getCanGroup: () => {
+            var _ref, _ref2, _ref3, _column$columnDef$ena;
+            return (_ref = (_ref2 = (_ref3 = (_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) != null ? _ref3 : table.options.enableGrouping) != null ? _ref2 : true) != null ? _ref : !!column.accessorFn;
+          },
+          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: () => {
+            const canGroup = column.getCanGroup();
+            return () => {
+              if (!canGroup) return;
+              column.toggleGrouping();
+            };
+          },
+          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, _table$options$aggreg2;
+            if (!column) {
+              throw new Error();
+            }
+            return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn];
+          }
+        };
+      },
+      createTable: table => {
+        return {
+          setGrouping: updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater),
+          resetGrouping: defaultState => {
+            var _table$initialState$g, _table$initialState;
+            table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []);
+          },
+          getPreGroupedRowModel: () => table.getFilteredRowModel(),
+          getGroupedRowModel: () => {
+            if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
+              table._getGroupedRowModel = table.options.getGroupedRowModel(table);
+            }
+            if (table.options.manualGrouping || !table._getGroupedRowModel) {
+              return table.getPreGroupedRowModel();
+            }
+            return table._getGroupedRowModel();
+          }
+        };
+      },
+      createRow: row => {
+        return {
+          getIsGrouped: () => !!row.groupingColumnId,
+          _groupingValuesCache: {}
+        };
+      },
+      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);
+          }
+        };
+      }
+    };
+    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 {
+          columnOrder: [],
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onColumnOrderChange: makeStateUpdater('columnOrder', table)
+        };
+      },
+      createTable: table => {
+        return {
+          setColumnOrder: updater => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater),
+          resetColumnOrder: defaultState => {
+            var _table$initialState$c;
+            table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []);
+          },
+          _getOrderColumnsFn: memo(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => {
+            // Sort grouped columns to the start of the column list
+            // before the headers are built
+            let orderedColumns = [];
+
+            // If there is no order, return the normal columns
+            if (!(columnOrder != null && columnOrder.length)) {
+              orderedColumns = columns;
+            } else {
+              const columnOrderCopy = [...columnOrder];
+
+              // If there is an order, make a copy of the columns
+              const columnsCopy = [...columns];
+
+              // And make a new ordered array of the columns
+
+              // Loop over the columns and place them in order into the new array
+              while (columnsCopy.length && columnOrderCopy.length) {
+                const targetColumnId = columnOrderCopy.shift();
+                const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId);
+                if (foundIndex > -1) {
+                  orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]);
+                }
+              }
+
+              // If there are any columns left, add them to the end
+              orderedColumns = [...orderedColumns, ...columnsCopy];
+            }
+            return orderColumns(orderedColumns, grouping, groupedColumnMode);
+          }, {
+            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(),
+            ...(state == null ? void 0 : state.pagination)
+          }
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onPaginationChange: makeStateUpdater('pagination', table)
+        };
+      },
+      createTable: table => {
+        let registered = false;
+        let queued = false;
+        return {
+          _autoResetPageIndex: () => {
+            var _ref, _table$options$autoRe;
+            if (!registered) {
+              table._queue(() => {
+                registered = true;
+              });
+              return;
+            }
+            if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetPageIndex) != null ? _ref : !table.options.manualPagination) {
+              if (queued) return;
+              queued = true;
+              table._queue(() => {
+                table.resetPageIndex();
+                queued = false;
+              });
+            }
+          },
+          setPagination: updater => {
+            const safeUpdater = old => {
+              let newState = functionalUpdate(updater, old);
+              return newState;
+            };
+            return table.options.onPaginationChange == null ? void 0 : table.options.onPaginationChange(safeUpdater);
+          },
+          resetPagination: defaultState => {
+            var _table$initialState$p;
+            table.setPagination(defaultState ? getDefaultPaginationState() : (_table$initialState$p = table.initialState.pagination) != null ? _table$initialState$p : getDefaultPaginationState());
+          },
+          setPageIndex: updater => {
+            table.setPagination(old => {
+              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.max(0, Math.min(pageIndex, maxPageIndex));
+              return {
+                ...old,
+                pageIndex
+              };
+            });
+          },
+          resetPageIndex: defaultState => {
+            var _table$initialState$p2, _table$initialState, _table$initialState$p3;
+            table.setPageIndex(defaultState ? defaultPageIndex : (_table$initialState$p2 = (_table$initialState = table.initialState) == null ? void 0 : (_table$initialState$p3 = _table$initialState.pagination) == null ? void 0 : _table$initialState$p3.pageIndex) != null ? _table$initialState$p2 : defaultPageIndex);
+          },
+          resetPageSize: defaultState => {
+            var _table$initialState$p4, _table$initialState2, _table$initialState2$;
+            table.setPageSize(defaultState ? defaultPageSize : (_table$initialState$p4 = (_table$initialState2 = table.initialState) == null ? void 0 : (_table$initialState2$ = _table$initialState2.pagination) == null ? void 0 : _table$initialState2$.pageSize) != null ? _table$initialState$p4 : defaultPageSize);
+          },
+          setPageSize: updater => {
+            table.setPagination(old => {
+              const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize));
+              const topRowIndex = old.pageSize * old.pageIndex;
+              const pageIndex = Math.floor(topRowIndex / pageSize);
+              return {
+                ...old,
+                pageIndex,
+                pageSize
+              };
+            });
+          },
+          setPageCount: updater => table.setPagination(old => {
+            var _table$options$pageCo;
+            let newPageCount = functionalUpdate(updater, (_table$options$pageCo = table.options.pageCount) != null ? _table$options$pageCo : -1);
+            if (typeof newPageCount === 'number') {
+              newPageCount = Math.max(-1, newPageCount);
+            }
+            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',
+            debug: () => {
+              var _table$options$debugA;
+              return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable;
+            }
+          }),
+          getCanPreviousPage: () => table.getState().pagination.pageIndex > 0,
+          getCanNextPage: () => {
+            const {
+              pageIndex
+            } = table.getState().pagination;
+            const pageCount = table.getPageCount();
+            if (pageCount === -1) {
+              return true;
+            }
+            if (pageCount === 0) {
+              return false;
+            }
+            return pageIndex < pageCount - 1;
+          },
+          previousPage: () => {
+            return table.setPageIndex(old => old - 1);
+          },
+          nextPage: () => {
+            return table.setPageIndex(old => {
+              return old + 1;
+            });
+          },
+          getPrePaginationRowModel: () => table.getExpandedRowModel(),
+          getPaginationRowModel: () => {
+            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: () => {
+            var _table$options$pageCo2;
+            return (_table$options$pageCo2 = table.options.pageCount) != null ? _table$options$pageCo2 : Math.ceil(table.getPrePaginationRowModel().rows.length / table.getState().pagination.pageSize);
+          }
+        };
+      }
+    };
+
+    //
+
+    const getDefaultPinningState = () => ({
+      left: [],
+      right: []
+    });
+    const Pinning = {
+      getInitialState: state => {
+        return {
+          columnPinning: getDefaultPinningState(),
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onColumnPinningChange: makeStateUpdater('columnPinning', table)
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          pin: position => {
+            const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean);
+            table.setColumnPinning(old => {
+              var _old$left3, _old$right3;
+              if (position === 'right') {
+                var _old$left, _old$right;
+                return {
+                  left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+                  right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
+                };
+              }
+              if (position === 'left') {
+                var _old$left2, _old$right2;
+                return {
+                  left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
+                  right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+                };
+              }
+              return {
+                left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+                right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+              };
+            });
+          },
+          getCanPin: () => {
+            const leafColumns = column.getLeafColumns();
+            return leafColumns.some(d => {
+              var _d$columnDef$enablePi, _table$options$enable;
+              return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_table$options$enable = table.options.enablePinning) != null ? _table$options$enable : true);
+            });
+          },
+          getIsPinned: () => {
+            const leafColumnIds = column.getLeafColumns().map(d => d.id);
+            const {
+              left,
+              right
+            } = table.getState().columnPinning;
+            const isLeft = leafColumnIds.some(d => left == null ? void 0 : left.includes(d));
+            const isRight = leafColumnIds.some(d => right == null ? void 0 : right.includes(d));
+            return isLeft ? 'left' : isRight ? 'right' : false;
+          },
+          getPinnedIndex: () => {
+            var _table$getState$colum, _table$getState$colum2, _table$getState$colum3;
+            const position = column.getIsPinned();
+            return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null ? void 0 : (_table$getState$colum3 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum3.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0;
+          }
+        };
+      },
+      createRow: (row, table) => {
+        return {
+          getCenterVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
+            const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+            return allCells.filter(d => !leftAndRight.includes(d.column.id));
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'row.getCenterVisibleCells',
+            debug: () => {
+              var _table$options$debugA;
+              return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows;
+            }
+          }),
+          getLeftVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left,,], (allCells, left) => {
+            const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+              ...d,
+              position: 'left'
+            }));
+            return cells;
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'row.getLeftVisibleCells',
+            debug: () => {
+              var _table$options$debugA2;
+              return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows;
+            }
+          }),
+          getRightVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
+            const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+              ...d,
+              position: 'right'
+            }));
+            return cells;
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'row.getRightVisibleCells',
+            debug: () => {
+              var _table$options$debugA3;
+              return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugRows;
+            }
+          })
+        };
+      },
+      createTable: table => {
+        return {
+          setColumnPinning: updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater),
+          resetColumnPinning: defaultState => {
+            var _table$initialState$c, _table$initialState;
+            return table.setColumnPinning(defaultState ? getDefaultPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : 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) => {
+            return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getLeftLeafColumns',
+            debug: () => {
+              var _table$options$debugA4;
+              return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugColumns;
+            }
+          }),
+          getRightLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => {
+            return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getRightLeafColumns',
+            debug: () => {
+              var _table$options$debugA5;
+              return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugColumns;
+            }
+          }),
+          getCenterLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => {
+            const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+            return allColumns.filter(d => !leftAndRight.includes(d.id));
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getCenterLeafColumns',
+            debug: () => {
+              var _table$options$debugA6;
+              return (_table$options$debugA6 = table.options.debugAll) != null ? _table$options$debugA6 : table.options.debugColumns;
+            }
+          })
+        };
+      }
+    };
+
+    //
+
+    const RowSelection = {
+      getInitialState: state => {
+        return {
+          rowSelection: {},
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onRowSelectionChange: makeStateUpdater('rowSelection', table),
+          enableRowSelection: true,
+          enableMultiRowSelection: true,
+          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),
+          resetRowSelection: defaultState => {
+            var _table$initialState$r;
+            return table.setRowSelection(defaultState ? {} : (_table$initialState$r = table.initialState.rowSelection) != null ? _table$initialState$r : {});
+          },
+          toggleAllRowsSelected: value => {
+            table.setRowSelection(old => {
+              value = typeof value !== 'undefined' ? value : !table.getIsAllRowsSelected();
+              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
+              if (value) {
+                preGroupedFlatRows.forEach(row => {
+                  if (!row.getCanSelect()) {
+                    return;
+                  }
+                  rowSelection[row.id] = true;
+                });
+              } else {
+                preGroupedFlatRows.forEach(row => {
+                  delete rowSelection[row.id];
+                });
+              }
+              return rowSelection;
+            });
+          },
+          toggleAllPageRowsSelected: value => table.setRowSelection(old => {
+            const resolvedValue = typeof value !== 'undefined' ? value : !table.getIsAllPageRowsSelected();
+            const rowSelection = {
+              ...old
+            };
+            table.getRowModel().rows.forEach(row => {
+              mutateRowIsSelected(rowSelection, row.id, resolvedValue, table);
+            });
+            return rowSelection;
+          }),
+          // addRowSelectionRange: rowId => {
+          //   const {
+          //     rows,
+          //     rowsById,
+          //     options: { selectGroupingRows, selectSubRows },
+          //   } = table
+
+          //   const findSelectedRow = (rows: Row[]) => {
+          //     let found
+          //     rows.find(d => {
+          //       if (d.getIsSelected()) {
+          //         found = d
+          //         return true
+          //       }
+          //       const subFound = findSelectedRow(d.subRows || [])
+          //       if (subFound) {
+          //         found = subFound
+          //         return true
+          //       }
+          //       return false
+          //     })
+          //     return found
+          //   }
+
+          //   const firstRow = findSelectedRow(rows) || rows[0]
+          //   const lastRow = rowsById[rowId]
+
+          //   let include = false
+          //   const selectedRowIds = {}
+
+          //   const addRow = (row: Row) => {
+          //     mutateRowIsSelected(selectedRowIds, row.id, true, {
+          //       rowsById,
+          //       selectGroupingRows: selectGroupingRows!,
+          //       selectSubRows: selectSubRows!,
+          //     })
+          //   }
+
+          //   table.rows.forEach(row => {
+          //     const isFirstRow = row.id === firstRow.id
+          //     const isLastRow = row.id === lastRow.id
+
+          //     if (isFirstRow || isLastRow) {
+          //       if (!include) {
+          //         include = true
+          //       } else if (include) {
+          //         addRow(row)
+          //         include = false
+          //       }
+          //     }
+
+          //     if (include) {
+          //       addRow(row)
+          //     }
+          //   })
+
+          //   table.setRowSelection(selectedRowIds)
+          // },
+          getPreSelectedRowModel: () => table.getCoreRowModel(),
+          getSelectedRowModel: memo(() => [table.getState().rowSelection, table.getCoreRowModel()], (rowSelection, rowModel) => {
+            if (!Object.keys(rowSelection).length) {
+              return {
+                rows: [],
+                flatRows: [],
+                rowsById: {}
+              };
+            }
+            return selectRowsFn(table, rowModel);
+          }, {
+            key: process.env.NODE_ENV === 'development' && 'getSelectedRowModel',
+            debug: () => {
+              var _table$options$debugA;
+              return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable;
+            }
+          }),
+          getFilteredSelectedRowModel: memo(() => [table.getState().rowSelection, table.getFilteredRowModel()], (rowSelection, rowModel) => {
+            if (!Object.keys(rowSelection).length) {
+              return {
+                rows: [],
+                flatRows: [],
+                rowsById: {}
+              };
+            }
+            return selectRowsFn(table, rowModel);
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'getFilteredSelectedRowModel',
+            debug: () => {
+              var _table$options$debugA2;
+              return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugTable;
+            }
+          }),
+          getGroupedSelectedRowModel: memo(() => [table.getState().rowSelection, table.getSortedRowModel()], (rowSelection, rowModel) => {
+            if (!Object.keys(rowSelection).length) {
+              return {
+                rows: [],
+                flatRows: [],
+                rowsById: {}
+              };
+            }
+            return selectRowsFn(table, rowModel);
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'getGroupedSelectedRowModel',
+            debug: () => {
+              var _table$options$debugA3;
+              return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : 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: () => {
+            const paginationFlatRows = table.getPaginationRowModel().flatRows;
+            const {
+              rowSelection
+            } = table.getState();
+            let isAllPageRowsSelected = !!paginationFlatRows.length;
+            if (isAllPageRowsSelected && paginationFlatRows.some(row => !rowSelection[row.id])) {
+              isAllPageRowsSelected = false;
+            }
+            return isAllPageRowsSelected;
+          },
+          getIsSomeRowsSelected: () => {
+            var _table$getState$rowSe;
+            const totalSelected = Object.keys((_table$getState$rowSe = table.getState().rowSelection) != null ? _table$getState$rowSe : {}).length;
+            return totalSelected > 0 && totalSelected < table.getFilteredRowModel().flatRows.length;
+          },
+          getIsSomePageRowsSelected: () => {
+            const paginationFlatRows = table.getPaginationRowModel().flatRows;
+            return table.getIsAllPageRowsSelected() ? false : paginationFlatRows.some(d => d.getIsSelected() || d.getIsSomeSelected());
+          },
+          getToggleAllRowsSelectedHandler: () => {
+            return e => {
+              table.toggleAllRowsSelected(e.target.checked);
+            };
+          },
+          getToggleAllPageRowsSelectedHandler: () => {
+            return e => {
+              table.toggleAllPageRowsSelected(e.target.checked);
+            };
+          }
+        };
+      },
+      createRow: (row, table) => {
+        return {
+          toggleSelected: value => {
+            const isSelected = row.getIsSelected();
+            table.setRowSelection(old => {
+              value = typeof value !== 'undefined' ? value : !isSelected;
+              if (isSelected === value) {
+                return old;
+              }
+              const selectedRowIds = {
+                ...old
+              };
+              mutateRowIsSelected(selectedRowIds, row.id, value, table);
+              return selectedRowIds;
+            });
+          },
+          getIsSelected: () => {
+            const {
+              rowSelection
+            } = table.getState();
+            return isRowSelected(row, rowSelection);
+          },
+          getIsSomeSelected: () => {
+            const {
+              rowSelection
+            } = table.getState();
+            return isSubRowSelected(row, rowSelection) === 'some';
+          },
+          getIsAllSubRowsSelected: () => {
+            const {
+              rowSelection
+            } = table.getState();
+            return isSubRowSelected(row, rowSelection) === 'all';
+          },
+          getCanSelect: () => {
+            var _table$options$enable;
+            if (typeof table.options.enableRowSelection === 'function') {
+              return table.options.enableRowSelection(row);
+            }
+            return (_table$options$enable = table.options.enableRowSelection) != null ? _table$options$enable : true;
+          },
+          getCanSelectSubRows: () => {
+            var _table$options$enable2;
+            if (typeof table.options.enableSubRowSelection === 'function') {
+              return table.options.enableSubRowSelection(row);
+            }
+            return (_table$options$enable2 = table.options.enableSubRowSelection) != null ? _table$options$enable2 : true;
+          },
+          getCanMultiSelect: () => {
+            var _table$options$enable3;
+            if (typeof table.options.enableMultiRowSelection === 'function') {
+              return table.options.enableMultiRowSelection(row);
+            }
+            return (_table$options$enable3 = table.options.enableMultiRowSelection) != null ? _table$options$enable3 : true;
+          },
+          getToggleSelectedHandler: () => {
+            const canSelect = row.getCanSelect();
+            return e => {
+              var _target;
+              if (!canSelect) return;
+              row.toggleSelected((_target = e.target) == null ? void 0 : _target.checked);
+            };
+          }
+        };
+      }
+    };
+    const mutateRowIsSelected = (selectedRowIds, id, value, table) => {
+      var _row$subRows;
+      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 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,
+              subRows: recurseRows(row.subRows)
+            };
+          }
+          if (isSelected) {
+            return row;
+          }
+        }).filter(Boolean);
+      };
+      return {
+        rows: recurseRows(rowModel.rows),
+        flatRows: newSelectedFlatRows,
+        rowsById: newSelectedRowsById
+      };
+    }
+    function isRowSelected(row, selection) {
+      var _selection$row$id;
+      return (_selection$row$id = selection[row.id]) != null ? _selection$row$id : false;
+    }
+    function isSubRowSelected(row, selection, table) {
+      if (row.subRows && row.subRows.length) {
+        let allChildrenSelected = true;
+        let someSelected = false;
+        row.subRows.forEach(subRow => {
+          // Bail out early if we know both of these
+          if (someSelected && !allChildrenSelected) {
+            return;
+          }
+          if (isRowSelected(subRow, selection)) {
+            someSelected = true;
+          } else {
+            allChildrenSelected = false;
+          }
+        });
+        return allChildrenSelected ? '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
+    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
+    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
+      // 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
+
+    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.
+    // 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
+      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
+        if (isNaN(combo[0])) {
+          if (aa > bb) {
+            return 1;
+          }
+          if (bb > aa) {
+            return -1;
+          }
+          continue;
+        }
+
+        // One is a string, one is a number
+        if (isNaN(combo[1])) {
+          return isNaN(an) ? -1 : 1;
+        }
+
+        // Both are numbers
+        if (an > bn) {
+          return 1;
+        }
+        if (bn > an) {
+          return -1;
+        }
+      }
+      return a.length - b.length;
+    }
+
+    // Exports
+
+    const sortingFns = {
+      alphanumeric,
+      alphanumericCaseSensitive,
+      text,
+      textCaseSensitive,
+      datetime,
+      basic
+    };
+
+    //
+
+    const Sorting = {
+      getInitialState: state => {
+        return {
+          sorting: [],
+          ...state
+        };
+      },
+      getDefaultColumnDef: () => {
+        return {
+          sortingFn: 'auto'
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onSortingChange: makeStateUpdater('sorting', table),
+          isMultiSortEvent: e => {
+            return e.shiftKey;
+          }
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          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, _table$options$sortin2;
+            if (!column) {
+              throw new Error();
+            }
+            return isFunction(column.columnDef.sortingFn) ? column.columnDef.sortingFn : column.columnDef.sortingFn === 'auto' ? column.getAutoSortingFn() : (_table$options$sortin = (_table$options$sortin2 = table.options.sortingFns) == null ? void 0 : _table$options$sortin2[column.columnDef.sortingFn]) != null ? _table$options$sortin : sortingFns[column.columnDef.sortingFn];
+          },
+          toggleSorting: (desc, multi) => {
+            // if (column.columns.length) {
+            //   column.columns.forEach((c, i) => {
+            //     if (c.id) {
+            //       table.toggleColumnSorting(c.id, undefined, multi || !!i)
+            //     }
+            //   })
+            //   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;
+            table.setSorting(old => {
+              // 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 sortAction;
+              let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc';
+
+              // Multi-mode
+              if (old != null && old.length && column.getCanMultiSort() && multi) {
+                if (existingSorting) {
+                  sortAction = 'toggle';
+                } else {
+                  sortAction = 'add';
+                }
+              } else {
+                // Normal mode
+                if (old != null && old.length && existingIndex !== old.length - 1) {
+                  sortAction = 'replace';
+                } else if (existingSorting) {
+                  sortAction = 'toggle';
+                } else {
+                  sortAction = 'replace';
+                }
+              }
+
+              // 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) {
+                  // Is our intention to remove?
+                  if (!nextSortingOrder) {
+                    sortAction = 'remove';
+                  }
+                }
+              }
+              if (sortAction === 'add') {
+                var _table$options$maxMul;
+                newSorting = [...old, {
+                  id: column.id,
+                  desc: nextDesc
+                }];
+                // Take latest n columns
+                newSorting.splice(0, newSorting.length - ((_table$options$maxMul = table.options.maxMultiSortColCount) != null ? _table$options$maxMul : Number.MAX_SAFE_INTEGER));
+              } else if (sortAction === 'toggle') {
+                // This flips (or sets) the
+                newSorting = old.map(d => {
+                  if (d.id === column.id) {
+                    return {
+                      ...d,
+                      desc: nextDesc
+                    };
+                  }
+                  return d;
+                });
+              } else if (sortAction === 'remove') {
+                newSorting = old.filter(d => d.id !== column.id);
+              } else {
+                newSorting = [{
+                  id: column.id,
+                  desc: nextDesc
+                }];
+              }
+              return newSorting;
+            });
+          },
+          getFirstSortDir: () => {
+            var _ref, _column$columnDef$sor;
+            const sortDescFirst = (_ref = (_column$columnDef$sor = column.columnDef.sortDescFirst) != null ? _column$columnDef$sor : table.options.sortDescFirst) != null ? _ref : column.getAutoSortDir() === 'desc';
+            return sortDescFirst ? 'desc' : 'asc';
+          },
+          getNextSortingOrder: multi => {
+            var _table$options$enable, _table$options$enable2;
+            const firstSortDirection = column.getFirstSortDir();
+            const isSorted = column.getIsSorted();
+            if (!isSorted) {
+              return firstSortDirection;
+            }
+            if (isSorted !== firstSortDirection && ((_table$options$enable = table.options.enableSortingRemoval) != null ? _table$options$enable : true) && (
+            // If enableSortRemove, enable in general
+            multi ? (_table$options$enable2 = table.options.enableMultiRemove) != null ? _table$options$enable2 : true : true) // If multi, don't allow if enableMultiRemove))
+            ) {
+              return false;
+            }
+            return isSorted === 'desc' ? 'asc' : 'desc';
+          },
+          getCanSort: () => {
+            var _column$columnDef$ena, _table$options$enable3;
+            return ((_column$columnDef$ena = column.columnDef.enableSorting) != null ? _column$columnDef$ena : true) && ((_table$options$enable3 = table.options.enableSorting) != null ? _table$options$enable3 : true) && !!column.accessorFn;
+          },
+          getCanMultiSort: () => {
+            var _ref2, _column$columnDef$ena2;
+            return (_ref2 = (_column$columnDef$ena2 = column.columnDef.enableMultiSort) != null ? _column$columnDef$ena2 : table.options.enableMultiSort) != null ? _ref2 : !!column.accessorFn;
+          },
+          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, _table$getState$sorti3;
+            return (_table$getState$sorti2 = (_table$getState$sorti3 = table.getState().sorting) == null ? void 0 : _table$getState$sorti3.findIndex(d => d.id === column.id)) != null ? _table$getState$sorti2 : -1;
+          },
+          clearSorting: () => {
+            //clear sorting for just 1 column
+            table.setSorting(old => old != null && old.length ? old.filter(d => d.id !== column.id) : []);
+          },
+          getToggleSortingHandler: () => {
+            const canSort = column.getCanSort();
+            return e => {
+              if (!canSort) return;
+              e.persist == null ? void 0 : e.persist();
+              column.toggleSorting == null ? void 0 : column.toggleSorting(undefined, column.getCanMultiSort() ? table.options.isMultiSortEvent == null ? void 0 : table.options.isMultiSortEvent(e) : false);
+            };
+          }
+        };
+      },
+      createTable: table => {
+        return {
+          setSorting: updater => table.options.onSortingChange == null ? void 0 : table.options.onSortingChange(updater),
+          resetSorting: defaultState => {
+            var _table$initialState$s, _table$initialState;
+            table.setSorting(defaultState ? [] : (_table$initialState$s = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.sorting) != null ? _table$initialState$s : []);
+          },
+          getPreSortedRowModel: () => table.getGroupedRowModel(),
+          getSortedRowModel: () => {
+            if (!table._getSortedRowModel && table.options.getSortedRowModel) {
+              table._getSortedRowModel = table.options.getSortedRowModel(table);
+            }
+            if (table.options.manualSorting || !table._getSortedRowModel) {
+              return table.getPreSortedRowModel();
+            }
+            return table._getSortedRowModel();
+          }
+        };
+      }
+    };
+
+    //
+
+    const Visibility = {
+      getInitialState: state => {
+        return {
+          columnVisibility: {},
+          ...state
+        };
+      },
+      getDefaultOptions: table => {
+        return {
+          onColumnVisibilityChange: makeStateUpdater('columnVisibility', table)
+        };
+      },
+      createColumn: (column, table) => {
+        return {
+          toggleVisibility: value => {
+            if (column.getCanHide()) {
+              table.setColumnVisibility(old => ({
+                ...old,
+                [column.id]: value != null ? value : !column.getIsVisible()
+              }));
+            }
+          },
+          getIsVisible: () => {
+            var _table$getState$colum, _table$getState$colum2;
+            return (_table$getState$colum = (_table$getState$colum2 = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum2[column.id]) != null ? _table$getState$colum : true;
+          },
+          getCanHide: () => {
+            var _column$columnDef$ena, _table$options$enable;
+            return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true);
+          },
+          getToggleVisibilityHandler: () => {
+            return e => {
+              column.toggleVisibility == null ? void 0 : column.toggleVisibility(e.target.checked);
+            };
+          }
+        };
+      },
+      createRow: (row, table) => {
+        return {
+          _getAllVisibleCells: memo(() => [row.getAllCells(), table.getState().columnVisibility], cells => {
+            return cells.filter(cell => cell.column.getIsVisible());
+          }, {
+            key: process.env.NODE_ENV === 'production' && 'row._getAllVisibleCells',
+            debug: () => {
+              var _table$options$debugA;
+              return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows;
+            }
+          }),
+          getVisibleCells: memo(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], {
+            key: process.env.NODE_ENV === 'development' && 'row.getVisibleCells',
+            debug: () => {
+              var _table$options$debugA2;
+              return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows;
+            }
+          })
+        };
+      },
+      createTable: table => {
+        const makeVisibleColumnsMethod = (key, getColumns) => {
+          return memo(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => {
+            return columns.filter(d => d.getIsVisible == null ? void 0 : d.getIsVisible());
+          }, {
+            key,
+            debug: () => {
+              var _table$options$debugA3;
+              return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugColumns;
+            }
+          });
+        };
+        return {
+          getVisibleFlatColumns: makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns()),
+          getVisibleLeafColumns: makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns()),
+          getLeftVisibleLeafColumns: makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns()),
+          getRightVisibleLeafColumns: makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns()),
+          getCenterVisibleLeafColumns: makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns()),
+          setColumnVisibility: updater => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater),
+          resetColumnVisibility: defaultState => {
+            var _table$initialState$c;
+            table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {});
+          },
+          toggleAllColumnsVisible: value => {
+            var _value;
+            value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible();
+            table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
+              ...obj,
+              [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
+            }), {}));
+          },
+          getIsAllColumnsVisible: () => !table.getAllLeafColumns().some(column => !(column.getIsVisible != null && column.getIsVisible())),
+          getIsSomeColumnsVisible: () => table.getAllLeafColumns().some(column => column.getIsVisible == null ? void 0 : column.getIsVisible()),
+          getToggleAllColumnsVisibilityHandler: () => {
+            return e => {
+              var _target;
+              table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
+            };
+          }
+        };
+      }
+    };
+
+    const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing];
+
+    //
+
+    function createTable(options) {
+      var _options$initialState;
+      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,
+          ...options
+        };
+      };
+      const coreInitialState = {};
+      let initialState = {
+        ...coreInitialState,
+        ...((_options$initialState = options.initialState) != null ? _options$initialState : {})
+      };
+      table._features.forEach(feature => {
+        var _feature$getInitialSt;
+        initialState = (_feature$getInitialSt = feature.getInitialState == null ? void 0 : feature.getInitialState(initialState)) != null ? _feature$getInitialSt : initialState;
+      });
+      const queued = [];
+      let queuedTimeout = false;
+      const coreInstance = {
+        _features: features,
+        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.
+            Promise.resolve().then(() => {
+              while (queued.length) {
+                queued.shift()();
+              }
+              queuedTimeout = false;
+            }).catch(error => setTimeout(() => {
+              throw error;
+            }));
+          }
+        },
+        reset: () => {
+          table.setState(table.initialState);
+        },
+        setOptions: updater => {
+          const newOptions = functionalUpdate(updater, table.options);
+          table.options = mergeOptions(newOptions);
+        },
+        getState: () => {
+          return table.options.state;
+        },
+        setState: updater => {
+          table.options.onStateChange == null ? void 0 : table.options.onStateChange(updater);
+        },
+        _getRowId: (row, index, parent) => {
+          var _table$options$getRow;
+          return (_table$options$getRow = table.options.getRowId == null ? void 0 : table.options.getRowId(row, index, parent)) != null ? _table$options$getRow : `${parent ? [parent.id, index].join('.') : index}`;
+        },
+        getCoreRowModel: () => {
+          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 => {
+          var _defaultColumn;
+          defaultColumn = (_defaultColumn = defaultColumn) != null ? _defaultColumn : {};
+          return {
+            header: props => {
+              const resolvedColumnDef = props.header.column.columnDef;
+              if (resolvedColumnDef.accessorKey) {
+                return resolvedColumnDef.accessorKey;
+              }
+              if (resolvedColumnDef.accessorFn) {
+                return resolvedColumnDef.id;
+              }
+              return null;
+            },
+            // footer: props => props.header.column.id,
+            cell: props => {
+              var _props$renderValue$to, _props$renderValue;
+              return (_props$renderValue$to = (_props$renderValue = props.renderValue()) == null ? void 0 : _props$renderValue.toString == null ? void 0 : _props$renderValue.toString()) != null ? _props$renderValue$to : null;
+            },
+            ...table._features.reduce((obj, feature) => {
+              return Object.assign(obj, feature.getDefaultColumnDef == null ? void 0 : feature.getDefaultColumnDef());
+            }, {}),
+            ...defaultColumn
+          };
+        }, {
+          debug: () => {
+            var _table$options$debugA;
+            return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugColumns;
+          },
+          key: process.env.NODE_ENV === 'development' && 'getDefaultColumnDef'
+        }),
+        _getColumnDefs: () => table.options.columns,
+        getAllColumns: memo(() => [table._getColumnDefs()], columnDefs => {
+          const recurseColumns = function (columnDefs, parent, depth) {
+            if (depth === void 0) {
+              depth = 0;
+            }
+            return columnDefs.map(columnDef => {
+              const column = createColumn(table, columnDef, depth, parent);
+              const groupingColumnDef = columnDef;
+              column.columns = groupingColumnDef.columns ? recurseColumns(groupingColumnDef.columns, column, depth + 1) : [];
+              return column;
+            });
+          };
+          return recurseColumns(columnDefs);
+        }, {
+          key: process.env.NODE_ENV === 'development' && 'getAllColumns',
+          debug: () => {
+            var _table$options$debugA2;
+            return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugColumns;
+          }
+        }),
+        getAllFlatColumns: memo(() => [table.getAllColumns()], allColumns => {
+          return allColumns.flatMap(column => {
+            return column.getFlatColumns();
+          });
+        }, {
+          key: process.env.NODE_ENV === 'development' && 'getAllFlatColumns',
+          debug: () => {
+            var _table$options$debugA3;
+            return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugColumns;
+          }
+        }),
+        _getAllFlatColumnsById: memo(() => [table.getAllFlatColumns()], flatColumns => {
+          return flatColumns.reduce((acc, column) => {
+            acc[column.id] = column;
+            return acc;
+          }, {});
+        }, {
+          key: process.env.NODE_ENV === 'development' && 'getAllFlatColumnsById',
+          debug: () => {
+            var _table$options$debugA4;
+            return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugColumns;
+          }
+        }),
+        getAllLeafColumns: memo(() => [table.getAllColumns(), table._getOrderColumnsFn()], (allColumns, orderColumns) => {
+          let leafColumns = allColumns.flatMap(column => column.getLeafColumns());
+          return orderColumns(leafColumns);
+        }, {
+          key: process.env.NODE_ENV === 'development' && 'getAllLeafColumns',
+          debug: () => {
+            var _table$options$debugA5;
+            return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugColumns;
+          }
+        }),
+        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 = () => {
+        var _cell$getValue;
+        return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue;
+      };
+      const cell = {
+        id: `${row.id}_${column.id}`,
+        row,
+        column,
+        getValue: () => row.getValue(columnId),
+        renderValue: getRenderValue,
+        getContext: memo(() => [table, column, row, cell], (table, column, row, cell) => ({
+          table,
+          column,
+          row,
+          cell: cell,
+          getValue: cell.getValue,
+          renderValue: cell.renderValue
+        }), {
+          key: process.env.NODE_ENV === 'development' && 'cell.getContext',
+          debug: () => table.options.debugAll
+        })
+      };
+      table._features.forEach(feature => {
+        Object.assign(cell, feature.createCell == null ? void 0 : feature.createCell(cell, column, row, table));
+      }, {});
+      return cell;
+    }
+
+    const createRow = (table, id, original, rowIndex, depth, subRows) => {
+      let row = {
+        id,
+        index: rowIndex,
+        original,
+        depth,
+        _valuesCache: {},
+        _uniqueValuesCache: {},
+        getValue: columnId => {
+          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];
+        },
+        getUniqueValues: columnId => {
+          if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
+            return row._uniqueValuesCache[columnId];
+          }
+          const column = table.getColumn(columnId);
+          if (!column.accessorFn) {
+            return undefined;
+          }
+          if (!column.columnDef.getUniqueValues) {
+            row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
+            return row._uniqueValuesCache[columnId];
+          }
+          row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex);
+          return row._uniqueValuesCache[columnId];
+        },
+        renderValue: columnId => {
+          var _row$getValue;
+          return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
+        },
+        subRows: subRows != null ? subRows : [],
+        getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
+        getAllCells: memo(() => [table.getAllLeafColumns()], leafColumns => {
+          return leafColumns.map(column => {
+            return createCell(table, row, column, column.id);
+          });
+        }, {
+          key: process.env.NODE_ENV === 'development' && 'row.getAllCells',
+          debug: () => {
+            var _table$options$debugA;
+            return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows;
+          }
+        }),
+        _getAllCellsByColumnId: memo(() => [row.getAllCells()], allCells => {
+          return allCells.reduce((acc, cell) => {
+            acc[cell.column.id] = cell;
+            return acc;
+          }, {});
+        }, {
+          key: process.env.NODE_ENV === 'production' && 'row.getAllCellsByColumnId',
+          debug: () => {
+            var _table$options$debugA2;
+            return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : 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;
+    };
+
+    function getCoreRowModel() {
+      return table => memo(() => [table.options.data], data => {
+        const rowModel = {
+          rows: [],
+          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) {
+            //   if (process.env.NODE_ENV !== 'production') {
+            //     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
+            rows.push(row);
+
+            // Get the original subrows
+            if (table.options.getSubRows) {
+              var _row$originalSubRows;
+              row.originalSubRows = table.options.getSubRows(originalRows[i], i);
+
+              // 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;
+      }, {
+        key: process.env.NODE_ENV === 'development' && 'getRowModel',
+        debug: () => {
+          var _table$options$debugA;
+          return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable;
+        },
+        onChange: () => {
+          table._autoResetPageIndex();
+        }
+      });
+    }
+
     const styles$9 = css `
     ${display('flex')}
+
+    .table-container {
+        width: 100%;
+        height: 100%;
+        font: ${bodyFont};
+        color: ${bodyFontColor};
+    }
+
+    .table-header {
+        display: flex;
+        flex-direction: row;
+    }
+
+    .table-row {
+        display: flex;
+        flex-direction: row;
+    }
+
+    .table-cell {
+        flex: 1;
+    }
 `;
 
-    const template$3 = html ` <template> Nimble table here </template> `;
+    // prettier-ignore
+    const template$3 = html `
+    <template>
+        <div class="table-container">
+            <div class="table-header">
+                ${repeat(x => x.columnHeaders, html `
+                    <span class="table-cell">${x => x}</span>
+                `)}
+            </div>
+            <div class="table-viewport">
+                ${repeat(x => x.tableData, html `
+                    <div class="table-row">
+                        ${repeat(x => x, html `
+                            <span class="table-cell">${x => x}</span>
+                        `)}
+                    </div>
+                `)}
+            </div>
+        </div>
+    </template>
+`;
 
     /**
      * A nimble-styled table.
      */
     class Table extends FoundationElement {
+        constructor() {
+            super();
+            this.data = [];
+            // TODO: Temporarily expose the table data as arrays of strings.
+            this.tableData = [];
+            // TODO: Temporarily expose the column headers as a string array.
+            this.columnHeaders = [];
+            this.tableInitialized = false;
+            this.update = (state) => {
+                this.table.setOptions(prev => ({
+                    ...prev,
+                    ...this.options,
+                    state,
+                    onStateChange: (updater) => {
+                        const updatedState = typeof updater === 'function'
+                            ? updater(state)
+                            : updater;
+                        this.update(updatedState);
+                    }
+                }));
+            };
+            this.options = {
+                data: [],
+                onStateChange: (_) => { },
+                getCoreRowModel: getCoreRowModel(),
+                columns: [],
+                state: {},
+                renderFallbackValue: null,
+                autoResetAll: false
+            };
+            this.table = createTable(this.options);
+            this.tableInitialized = true;
+        }
+        dataChanged(prev, next) {
+            if ((!prev || prev.length === 0) && next && next.length > 0) {
+                this.generateColumns();
+            }
+            // Ignore any updates that occur prior to the TanStack table being initialized.
+            if (this.tableInitialized) {
+                this.updateTableOptions({ data: this.data });
+                this.refreshRows();
+            }
+        }
+        // TODO: For now, assume all cells can be rendered as strings. Ultimately, the data
+        // should be passed to nimble-row elements to use the view template from a column definition.
+        refreshRows() {
+            const tableData = [];
+            const rows = this.table.getRowModel().rows;
+            for (const row of rows) {
+                const rowArray = [];
+                for (const cell of row.getVisibleCells()) {
+                    const cellValue = cell.getValue();
+                    const stringValue = cellValue == null ? '' : cellValue.toString();
+                    rowArray.push(stringValue);
+                }
+                tableData.push(rowArray);
+            }
+            this.tableData = tableData;
+        }
+        updateTableOptions(updatedOptions) {
+            this.options = { ...this.options, ...updatedOptions };
+            this.update(this.table.initialState);
+        }
+        // Temporarily auto-detect the keys in TData to make columns.
+        // TODO: Remove this logic when another way to specify columns is provided.
+        generateColumns() {
+            if (this.data.length === 0) {
+                return;
+            }
+            const firstItem = this.data[0];
+            const keys = Object.keys(firstItem);
+            const generatedColumns = keys.map(key => {
+                const columnDef = {
+                    id: key,
+                    accessorKey: key,
+                    header: key
+                };
+                return columnDef;
+            });
+            this.updateTableOptions({ columns: generatedColumns });
+            this.columnHeaders = generatedColumns.map(x => x.header);
+        }
     }
+    __decorate([
+        observable
+    ], Table.prototype, "data", void 0);
+    __decorate([
+        observable
+    ], Table.prototype, "tableData", void 0);
+    __decorate([
+        observable
+    ], Table.prototype, "columnHeaders", void 0);
     const nimbleTable = Table.compose({
         baseName: 'table',
         template: template$3,