@hillac/mantine-react-table 0.0.0

package/dist/index.js

@@ -0,0 +1,3876 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import clsx from 'clsx';
+import { useMemo, useCallback, useState, memo, useEffect, useRef, Fragment as Fragment$1, useReducer, createElement, useLayoutEffect } from 'react';
+import { Select, MultiSelect, TextInput, TableTr, TableTd, Collapse, CopyButton, Tooltip, UnstyledButton, Highlight, useDirection, Skeleton, Box, ActionIcon, Text, TableTbody, Flex, Button, useMantineTheme, Menu, Switch, TableTh, TableTfoot, Radio, Checkbox, Badge, Alert, Stack, Autocomplete, RangeSlider, Popover, Transition, Indicator, TableThead, Progress, Group, Pagination, Modal, useMantineColorScheme, Table, lighten, darken, LoadingOverlay, Paper } from '@mantine/core';
+import { compareItems, rankItem, rankings } from '@tanstack/match-sorter-utils';
+import { sortFns, constructRow, filterFns, Subscribe, flexRender as flexRender$1, aggregationFns, stockFeatures, createFacetedUniqueValues, createFacetedMinMaxValues, createFacetedRowModel, createGroupedRowModel, createExpandedRowModel, createPaginatedRowModel, createSortedRowModel, createFilteredRowModel, useTable } from '@tanstack/react-table';
+import { defaultRangeExtractor, useVirtualizer } from '@tanstack/react-virtual';
+import { useDebouncedValue, useHover, useMediaQuery } from '@mantine/hooks';
+import { DateInput } from '@mantine/dates';
+import { useCreateAtom, useSelector } from '@tanstack/react-store';
+import { IconX, IconSortDescending, IconSortAscending, IconSearchOff, IconSearch, IconPinnedOff, IconPinned, IconMinimize, IconMaximize, IconGripHorizontal, IconFilterOff, IconFilterCog, IconFilter, IconEyeOff, IconEdit, IconDotsVertical, IconDots, IconDeviceFloppy, IconColumns, IconClearAll, IconCircleX, IconChevronsDown, IconChevronRightPipe, IconChevronRight, IconChevronLeftPipe, IconChevronLeft, IconChevronDown, IconBoxMultiple, IconBaselineDensitySmall, IconBaselineDensityMedium, IconBaselineDensityLarge, IconArrowsSort, IconArrowAutofitContent } from '@tabler/icons-react';
+
+const fuzzy$1 = (rowA, rowB, columnId) => {
+    let dir = 0;
+    if (rowA.columnFiltersMeta[columnId]) {
+        dir = compareItems(rowA.columnFiltersMeta[columnId], rowB.columnFiltersMeta[columnId]);
+    }
+    // Provide a fallback for when the item ranks are equal
+    return dir === 0
+        ? sortFns.alphanumeric(rowA, rowB, columnId)
+        : dir;
+};
+const MRT_SortFns = {
+    ...sortFns,
+    fuzzy: fuzzy$1,
+};
+const rankGlobalFuzzy = (rowA, rowB) => Math.max(...Object.values(rowB.columnFiltersMeta).map((v) => v.rank)) -
+    Math.max(...Object.values(rowA.columnFiltersMeta).map((v) => v.rank));
+
+const parseFromValuesOrFunc = (fn, arg) => (fn instanceof Function ? fn(arg) : fn);
+
+const getMRT_Rows = (table, all) => {
+    const { getCenterRows, getPrePaginatedRowModel, getRowModel, state, getTopRows, options: { createDisplayMode, enablePagination, enableRowPinning, manualPagination, positionCreatingRow, rowPinningDisplayMode, }, } = table;
+    const { creatingRow, pagination } = state;
+    const isRankingRows = getIsRankingRows(table);
+    let rows = [];
+    if (!isRankingRows) {
+        rows =
+            !enableRowPinning || rowPinningDisplayMode?.includes('sticky')
+                ? all
+                    ? getPrePaginatedRowModel().rows
+                    : getRowModel().rows
+                : getCenterRows();
+    }
+    else {
+        // fuzzy ranking adjustments
+        rows = getPrePaginatedRowModel().rows.sort((a, b) => rankGlobalFuzzy(a, b));
+        if (enablePagination && !manualPagination && !all) {
+            const start = pagination.pageIndex * pagination.pageSize;
+            rows = rows.slice(start, start + pagination.pageSize);
+        }
+        if (enableRowPinning && !rowPinningDisplayMode?.includes('sticky')) {
+            // "re-center-ize" the rows (no top or bottom pinned rows unless sticky)
+            rows = rows.filter((row) => !row.getIsPinned());
+        }
+    }
+    // row pinning adjustments
+    if (enableRowPinning && rowPinningDisplayMode?.includes('sticky')) {
+        const centerPinnedRowIds = rows
+            .filter((row) => row.getIsPinned())
+            .map((r) => r.id);
+        rows = [
+            ...getTopRows().filter((row) => !centerPinnedRowIds.includes(row.id)),
+            ...rows,
+        ];
+    }
+    // blank inserted creating row adjustments
+    if (positionCreatingRow !== undefined &&
+        creatingRow &&
+        createDisplayMode === 'row') {
+        const creatingRowIndex = !isNaN(+positionCreatingRow)
+            ? +positionCreatingRow
+            : positionCreatingRow === 'top'
+                ? 0
+                : rows.length;
+        rows = [
+            ...rows.slice(0, creatingRowIndex),
+            creatingRow,
+            ...rows.slice(creatingRowIndex),
+        ];
+    }
+    return rows;
+};
+const getCanRankRows = (table) => {
+    const { state, options: { enableGlobalFilterRankedResults, manualExpanding, manualFiltering, manualGrouping, manualSorting, }, } = table;
+    const { expanded, globalFilterFn } = state;
+    return (!manualExpanding &&
+        !manualFiltering &&
+        !manualGrouping &&
+        !manualSorting &&
+        enableGlobalFilterRankedResults &&
+        globalFilterFn === 'fuzzy' &&
+        expanded !== true &&
+        !Object.values(expanded).some(Boolean));
+};
+const getIsRankingRows = (table) => {
+    const { globalFilter, sorting } = table.state;
+    return (getCanRankRows(table) &&
+        globalFilter &&
+        !Object.values(sorting).some(Boolean));
+};
+const getIsRowSelected = ({ row, table, }) => {
+    const { options: { enableRowSelection }, } = table;
+    return (row.getIsSelected() ||
+        (parseFromValuesOrFunc(enableRowSelection, row) &&
+            row.getCanSelectSubRows() &&
+            row.getIsAllSubRowsSelected()));
+};
+const getMRT_RowSelectionHandler = ({ renderedRowIndex = 0, row, table, }) => (event, value) => {
+    const { state, options: { enableBatchRowSelection, enableMultiRowSelection, enableRowPinning, manualPagination, rowPinningDisplayMode, }, refs: { lastSelectedRowId: lastSelectedRowId }, } = table;
+    const { pagination: { pageIndex, pageSize }, } = state;
+    const paginationOffset = manualPagination ? 0 : pageSize * pageIndex;
+    const wasCurrentRowChecked = getIsRowSelected({ row, table });
+    // toggle selection of this row
+    row.toggleSelected(value ?? !wasCurrentRowChecked);
+    const changedRowIds = new Set([row.id]);
+    // if shift key is pressed, select all rows between last selected and this one
+    if (enableBatchRowSelection &&
+        enableMultiRowSelection &&
+        event.nativeEvent.shiftKey &&
+        lastSelectedRowId.current !== null) {
+        const rows = getMRT_Rows(table, true);
+        const lastIndex = rows.findIndex((r) => r.id === lastSelectedRowId.current);
+        if (lastIndex !== -1) {
+            const isLastIndexChecked = getIsRowSelected({
+                row: rows?.[lastIndex],
+                table,
+            });
+            const currentIndex = renderedRowIndex + paginationOffset;
+            const [start, end] = lastIndex < currentIndex
+                ? [lastIndex, currentIndex]
+                : [currentIndex, lastIndex];
+            // toggle selection of all rows between last selected and this one
+            // but only if the last selected row is not the same as the current one
+            if (wasCurrentRowChecked !== isLastIndexChecked) {
+                for (let i = start; i <= end; i++) {
+                    rows[i].toggleSelected(!wasCurrentRowChecked);
+                    changedRowIds.add(rows[i].id);
+                }
+            }
+        }
+    }
+    // record the last selected row id
+    lastSelectedRowId.current = row.id;
+    // if all sub rows were selected, unselect them
+    if (row.getCanSelectSubRows() && row.getIsAllSubRowsSelected()) {
+        row.subRows?.forEach((r) => r.toggleSelected(false));
+    }
+    if (enableRowPinning && rowPinningDisplayMode?.includes('select')) {
+        changedRowIds.forEach((rowId) => {
+            const rowToTogglePin = table.getRow(rowId);
+            rowToTogglePin.pin(!wasCurrentRowChecked // was not previously pinned or selected
+                ? rowPinningDisplayMode?.includes('bottom')
+                    ? 'bottom'
+                    : 'top'
+                : false);
+        });
+    }
+};
+const getMRT_SelectAllHandler = ({ table }) => (event, value, forceAll) => {
+    const { options: { enableRowPinning, rowPinningDisplayMode, selectAllMode }, refs: { lastSelectedRowId }, } = table;
+    if (selectAllMode === 'all' || forceAll) {
+        table.toggleAllRowsSelected(value ?? event.target.checked);
+    }
+    else {
+        table.toggleAllPageRowsSelected(value ?? event.target.checked);
+    }
+    if (enableRowPinning && rowPinningDisplayMode?.includes('select')) {
+        table.setRowPinning({ bottom: [], top: [] });
+    }
+    lastSelectedRowId.current = null;
+};
+
+const useMRT_Rows = (table) => {
+    const { getRowModel, state, options: { data, enableGlobalFilterRankedResults, positionCreatingRow }, } = table;
+    const { creatingRow, expanded, globalFilter, pagination, rowPinning, sorting, } = state;
+    const rows = useMemo(() => getMRT_Rows(table), [
+        creatingRow,
+        data,
+        enableGlobalFilterRankedResults,
+        expanded,
+        getRowModel().rows,
+        globalFilter,
+        pagination.pageIndex,
+        pagination.pageSize,
+        positionCreatingRow,
+        rowPinning,
+        sorting,
+    ]);
+    return rows;
+};
+
+const extraIndexRangeExtractor = (range, draggingIndex) => {
+    const newIndexes = defaultRangeExtractor(range);
+    if (draggingIndex === undefined)
+        return newIndexes;
+    if (draggingIndex >= 0 &&
+        draggingIndex < Math.max(range.startIndex - range.overscan, 0)) {
+        newIndexes.unshift(draggingIndex);
+    }
+    if (draggingIndex >= 0 && draggingIndex > range.endIndex + range.overscan) {
+        newIndexes.push(draggingIndex);
+    }
+    return newIndexes;
+};
+
+const useMRT_RowVirtualizer = (table, rows) => {
+    const { getRowModel, state, options: { enableRowVirtualization, renderDetailPanel, rowVirtualizerInstanceRef, rowVirtualizerOptions, }, refs: { tableContainerRef }, } = table;
+    const { density, draggingRow, expanded } = state;
+    if (!enableRowVirtualization)
+        return undefined;
+    const rowVirtualizerProps = parseFromValuesOrFunc(rowVirtualizerOptions, {
+        table,
+    });
+    const rowCount = rows?.length ?? getRowModel().rows.length;
+    const defaultRowHeightByDensity = {
+        lg: 62.7,
+        md: 54.7,
+        sm: 48.7,
+        xl: 70.7,
+        xs: 42.7,
+    };
+    const normalRowHeight = defaultRowHeightByDensity[density] ?? defaultRowHeightByDensity['md'];
+    const rowVirtualizer = useVirtualizer({
+        count: renderDetailPanel ? rowCount * 2 : rowCount,
+        estimateSize: (index) => renderDetailPanel && index % 2 === 1
+            ? expanded === true
+                ? 100
+                : 0
+            : normalRowHeight,
+        getScrollElement: () => tableContainerRef.current,
+        measureElement: typeof window !== 'undefined' &&
+            navigator.userAgent.indexOf('Firefox') === -1
+            ? (element) => element?.getBoundingClientRect().height
+            : undefined,
+        overscan: 4,
+        rangeExtractor: useCallback((range) => {
+            const current_index = getRowModel().rows.findIndex((row) => row.id === draggingRow?.id);
+            return extraIndexRangeExtractor(range, current_index >= 0 ? current_index : 0);
+        }, [draggingRow]),
+        ...rowVirtualizerProps,
+    });
+    rowVirtualizer.virtualRows = rowVirtualizer.getVirtualItems();
+    if (rowVirtualizerInstanceRef) {
+        // @ts-ignore
+        rowVirtualizerInstanceRef.current = rowVirtualizer;
+    }
+    return rowVirtualizer;
+};
+
+const MRT_EditCellTextInput = ({ cell, table, ...rest }) => {
+    const { state, options: { createDisplayMode, editDisplayMode, mantineEditSelectProps, mantineEditTextInputProps, }, refs: { editInputRefs }, setCreatingRow, setEditingCell, setEditingRow, } = table;
+    const { column, row } = cell;
+    const { columnDef } = column;
+    const { creatingRow, editingRow } = state;
+    const isCreating = creatingRow?.id === row.id;
+    const isEditing = editingRow?.id === row.id;
+    const isSelectEdit = columnDef.editVariant === 'select';
+    const isMultiSelectEdit = columnDef.editVariant === 'multi-select';
+    const [value, setValue] = useState(() => cell.getValue());
+    const arg = { cell, column, row, table };
+    const textInputProps = {
+        ...parseFromValuesOrFunc(mantineEditTextInputProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineEditTextInputProps, arg),
+        ...rest,
+    };
+    const selectProps = {
+        ...parseFromValuesOrFunc(mantineEditSelectProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineEditSelectProps, arg),
+        ...rest,
+    };
+    const saveInputValueToRowCache = (newValue) => {
+        // @ts-ignore
+        row._valuesCache[column.id] = newValue;
+        if (isCreating) {
+            setCreatingRow(row);
+        }
+        else if (isEditing) {
+            setEditingRow(row);
+        }
+    };
+    const handleBlur = (event) => {
+        textInputProps.onBlur?.(event);
+        saveInputValueToRowCache(value);
+        setEditingCell(null);
+    };
+    const handleEnterKeyDown = (event) => {
+        textInputProps.onKeyDown?.(event);
+        if (event.key === 'Enter') {
+            editInputRefs.current[cell.id]?.blur();
+        }
+    };
+    if (columnDef.Edit) {
+        return columnDef.Edit?.({ cell, column, row, table });
+    }
+    const commonProps = {
+        disabled: parseFromValuesOrFunc(columnDef.enableEditing, row) === false,
+        label: ['custom', 'modal'].includes((isCreating ? createDisplayMode : editDisplayMode))
+            ? column.columnDef.header
+            : undefined,
+        name: cell.id,
+        onClick: (e) => {
+            e.stopPropagation();
+            textInputProps?.onClick?.(e);
+        },
+        placeholder: !['custom', 'modal'].includes((isCreating ? createDisplayMode : editDisplayMode))
+            ? columnDef.header
+            : undefined,
+        value,
+        variant: editDisplayMode === 'table' ? 'unstyled' : 'default',
+    };
+    if (isSelectEdit) {
+        return (jsx(Select, { ...commonProps, searchable: true, value: value, ...selectProps, onBlur: handleBlur, onChange: (value, option) => {
+                selectProps.onChange?.(value, option);
+                setValue(value);
+            }, onClick: (e) => {
+                e.stopPropagation();
+                selectProps?.onClick?.(e);
+            }, ref: (node) => {
+                if (node) {
+                    editInputRefs.current[cell.id] = node;
+                    if (selectProps.ref && typeof selectProps.ref === 'object') {
+                        selectProps.ref.current = node;
+                    }
+                }
+            } }));
+    }
+    if (isMultiSelectEdit) {
+        return (jsx(MultiSelect, { ...commonProps, searchable: true, value: value, ...selectProps, onBlur: handleBlur, onChange: (newValue) => {
+                selectProps.onChange?.(value);
+                setValue(newValue);
+                // Save if not in focus, otherwise it will be handled by onBlur
+                if (document.activeElement === editInputRefs.current[cell.id])
+                    return;
+                saveInputValueToRowCache(newValue);
+            }, onClick: (e) => {
+                e.stopPropagation();
+                selectProps?.onClick?.(e);
+            }, ref: (node) => {
+                if (node) {
+                    editInputRefs.current[cell.id] = node;
+                    if (selectProps.ref && typeof selectProps.ref === 'object') {
+                        selectProps.ref.current = node;
+                    }
+                }
+            } }));
+    }
+    return (jsx(TextInput, { ...commonProps, onKeyDown: handleEnterKeyDown, value: value ?? '', ...textInputProps, onBlur: handleBlur, onChange: (event) => {
+            textInputProps.onChange?.(event);
+            setValue(event.target.value);
+        }, onClick: (event) => {
+            event.stopPropagation();
+            textInputProps?.onClick?.(event);
+        }, ref: (node) => {
+            if (node) {
+                editInputRefs.current[cell.id] = node;
+                if (textInputProps.ref) {
+                    textInputProps.ref.current = node;
+                }
+            }
+        } }));
+};
+
+var classes$C = {"root":"MRT_TableDetailPanel-module_root__vQAlM","root-grid":"MRT_TableDetailPanel-module_root-grid__7UMC6","root-virtual-row":"MRT_TableDetailPanel-module_root-virtual-row__r-X4Z","inner":"MRT_TableDetailPanel-module_inner__o-Fk-","inner-grid":"MRT_TableDetailPanel-module_inner-grid__WLZgF","inner-expanded":"MRT_TableDetailPanel-module_inner-expanded__6tg9T","inner-virtual":"MRT_TableDetailPanel-module_inner-virtual__TItRy"};
+
+const MRT_TableDetailPanel = ({ parentRowRef, renderedRowIndex = 0, row, rowVirtualizer, striped, table, virtualRow, ...rest }) => {
+    const { state, getVisibleLeafColumns, options: { layoutMode, mantineDetailPanelProps, mantineTableBodyRowProps, renderDetailPanel, }, } = table;
+    const { isLoading } = state;
+    const tableRowProps = parseFromValuesOrFunc(mantineTableBodyRowProps, {
+        isDetailPanel: true,
+        row,
+        table,
+    });
+    const tableCellProps = {
+        ...parseFromValuesOrFunc(mantineDetailPanelProps, {
+            row,
+            table,
+        }),
+        ...rest,
+    };
+    const internalEditComponents = row
+        .getAllCells()
+        .filter((cell) => cell.column.columnDef.columnDefType === 'data')
+        .map((cell) => (jsx(MRT_EditCellTextInput, { cell: cell, table: table }, cell.id)));
+    const DetailPanel = !isLoading &&
+        row.getIsExpanded() &&
+        renderDetailPanel?.({ internalEditComponents, row, table });
+    return (jsx(TableTr, { "data-index": renderDetailPanel ? renderedRowIndex * 2 + 1 : renderedRowIndex, "data-striped": striped, ref: (node) => {
+            if (node) {
+                rowVirtualizer?.measureElement?.(node);
+            }
+        }, ...tableRowProps, __vars: {
+            '--mrt-parent-row-height': virtualRow
+                ? `${parentRowRef.current?.getBoundingClientRect()?.height}px`
+                : undefined,
+            '--mrt-virtual-row-start': virtualRow
+                ? `${virtualRow.start}px`
+                : undefined,
+            ...tableRowProps?.__vars,
+        }, className: clsx('mantine-Table-tr-detail-panel', classes$C.root, layoutMode?.startsWith('grid') && classes$C['root-grid'], virtualRow && classes$C['root-virtual-row'], tableRowProps?.className), children: jsx(TableTd, { colSpan: getVisibleLeafColumns().length, component: "td", ...tableCellProps, __vars: {
+                '--mrt-inner-width': `${table.getTotalSize()}px`,
+            }, className: clsx('mantine-Table-td-detail-panel', classes$C.inner, layoutMode?.startsWith('grid') && classes$C['inner-grid'], row.getIsExpanded() && classes$C['inner-expanded'], virtualRow && classes$C['inner-virtual']), p: row.getIsExpanded() && DetailPanel ? 'md' : 0, children: rowVirtualizer ? (row.getIsExpanded() && DetailPanel) : (jsx(Collapse, { expanded: row.getIsExpanded(), children: DetailPanel })) }) }));
+};
+
+const parseCSSVarId = (id) => id.replace(/[^a-zA-Z0-9]/g, '_');
+const getPrimaryShade = (theme) => typeof theme.primaryShade === 'number'
+    ? theme.primaryShade
+    : (theme.primaryShade?.dark ?? 7);
+const getPrimaryColor = (theme, shade) => theme.colors[theme.primaryColor][shade ?? getPrimaryShade(theme)];
+function dataVariable(name, value) {
+    const key = `data-${name}`;
+    switch (typeof value) {
+        case 'boolean':
+            return value ? { [key]: '' } : null;
+        case 'number':
+            return { [key]: `${value}` };
+        case 'string':
+            return { [key]: value };
+        default:
+            return null;
+    }
+}
+
+var classes$B = {"root":"MRT_CopyButton-module_root__mkXy4"};
+
+const MRT_CopyButton = ({ cell, children, table, ...rest }) => {
+    const { options: { localization: { clickToCopy, copiedToClipboard }, mantineCopyButtonProps, }, } = table;
+    const { column, row } = cell;
+    const { columnDef } = column;
+    const arg = { cell, column, row, table };
+    const buttonProps = {
+        ...parseFromValuesOrFunc(mantineCopyButtonProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineCopyButtonProps, arg),
+        ...rest,
+    };
+    return (jsx(CopyButton, { value: cell.getValue(), children: ({ copied, copy }) => (jsx(Tooltip, { color: copied ? 'green' : undefined, label: buttonProps?.title ?? (copied ? copiedToClipboard : clickToCopy), openDelay: 1000, withinPortal: true, children: jsx(UnstyledButton, { ...buttonProps, className: clsx('mrt-copy-button', classes$B.root, buttonProps?.className), onClick: (e) => {
+                    e.stopPropagation();
+                    copy();
+                }, role: "presentation", title: undefined, children: children }) })) }));
+};
+
+const allowedTypes = ['string', 'number'];
+const allowedFilterVariants = ['text', 'autocomplete'];
+const MRT_TableBodyCellValue = ({ cell, renderedColumnIndex = 0, renderedRowIndex = 0, table, }) => {
+    const { state, options: { enableFilterMatchHighlighting, mantineHighlightProps = { size: 'sm' }, }, } = table;
+    const { column, row } = cell;
+    const { columnDef } = column;
+    const { globalFilter, globalFilterFn } = state;
+    const filterValue = column.getFilterValue();
+    const highlightProps = parseFromValuesOrFunc(mantineHighlightProps, {
+        cell,
+        column,
+        row,
+        table,
+    });
+    let renderedCellValue = cell.getIsAggregated() && columnDef.AggregatedCell
+        ? columnDef.AggregatedCell({
+            cell,
+            column,
+            row,
+            table,
+        })
+        : row.getIsGrouped() && !cell.getIsGrouped()
+            ? null
+            : cell.getIsGrouped() && columnDef.GroupedCell
+                ? columnDef.GroupedCell({
+                    cell,
+                    column,
+                    row,
+                    table,
+                })
+                : undefined;
+    const isGroupedValue = renderedCellValue !== undefined;
+    if (!isGroupedValue) {
+        renderedCellValue = cell.renderValue();
+    }
+    if (enableFilterMatchHighlighting &&
+        columnDef.enableFilterMatchHighlighting !== false &&
+        renderedCellValue &&
+        allowedTypes.includes(typeof renderedCellValue) &&
+        ((filterValue &&
+            allowedTypes.includes(typeof filterValue) &&
+            allowedFilterVariants.includes(columnDef.filterVariant)) ||
+            (globalFilter &&
+                allowedTypes.includes(typeof globalFilter) &&
+                column.getCanGlobalFilter()))) {
+        let highlight = (column.getFilterValue() ??
+            globalFilter ??
+            '').toString();
+        if ((filterValue ? columnDef._filterFn : globalFilterFn) === 'fuzzy') {
+            highlight = highlight.split(' ');
+        }
+        renderedCellValue = (jsx(Highlight, { color: "yellow.3", highlight: highlight, ...highlightProps, children: renderedCellValue?.toString() }));
+    }
+    if (columnDef.Cell && !isGroupedValue) {
+        renderedCellValue = columnDef.Cell({
+            cell,
+            column,
+            renderedCellValue,
+            renderedColumnIndex,
+            renderedRowIndex,
+            row,
+            table,
+        });
+    }
+    return renderedCellValue;
+};
+
+var classes$A = {"root":"MRT_TableBodyCell-module_root__Wf-zi","root-grid":"MRT_TableBodyCell-module_root-grid__zIuC-","root-virtualized":"MRT_TableBodyCell-module_root-virtualized__jLl8R","root-data-col":"MRT_TableBodyCell-module_root-data-col__HHcxc","root-nowrap":"MRT_TableBodyCell-module_root-nowrap__-k1Jo","root-cursor-pointer":"MRT_TableBodyCell-module_root-cursor-pointer__4kw7J","root-editable-hover":"MRT_TableBodyCell-module_root-editable-hover__2DKSa","root-cell-hover-reveal":"MRT_TableBodyCell-module_root-cell-hover-reveal__T1fAH","cell-hover-reveal":"MRT_TableBodyCell-module_cell-hover-reveal__Q-1Xj","overflowing":"MRT_TableBodyCell-module_overflowing__QcXP4"};
+
+const MRT_TableBodyCell = ({ cell, numRows = 1, renderedColumnIndex = 0, renderedRowIndex = 0, rowRef, table, virtualCell, ...rest }) => {
+    const direction = useDirection();
+    const { state, options: { columnResizeDirection, columnResizeMode, createDisplayMode, editDisplayMode, enableClickToCopy, enableColumnOrdering, enableColumnPinning, enableEditing, enableGrouping, layoutMode, mantineSkeletonProps, mantineTableBodyCellProps, }, refs: { editInputRefs }, setEditingCell, setHoveredColumn, } = table;
+    const { columnResizing, creatingRow, density, draggingColumn, editingCell, editingRow, hoveredColumn, isLoading, showSkeletons, } = state;
+    const { column, row } = cell;
+    const { columnDef } = column;
+    const { columnDefType } = columnDef;
+    const args = {
+        cell,
+        column,
+        renderedColumnIndex,
+        renderedRowIndex,
+        row,
+        table,
+    };
+    const tableCellProps = {
+        ...parseFromValuesOrFunc(mantineTableBodyCellProps, args),
+        ...parseFromValuesOrFunc(columnDef.mantineTableBodyCellProps, args),
+        ...rest,
+    };
+    const skeletonProps = parseFromValuesOrFunc(mantineSkeletonProps, args);
+    const [skeletonWidth, setSkeletonWidth] = useState(100);
+    useEffect(() => {
+        if ((!isLoading && !showSkeletons) || skeletonWidth !== 100)
+            return;
+        const size = column.getSize();
+        setSkeletonWidth(columnDefType === 'display'
+            ? size / 2
+            : Math.round(Math.random() * (size - size / 3) + size / 3));
+    }, [isLoading, showSkeletons]);
+    const widthStyles = {
+        minWidth: `max(calc(var(--col-${parseCSSVarId(column?.id)}-size) * 1px), ${columnDef.minSize ?? 30}px)`,
+        width: `calc(var(--col-${parseCSSVarId(column.id)}-size) * 1px)`,
+    };
+    if (layoutMode === 'grid') {
+        widthStyles.flex = `${[0, false].includes(columnDef.grow)
+            ? 0
+            : `var(--col-${parseCSSVarId(column.id)}-size)`} 0 auto`;
+    }
+    else if (layoutMode === 'grid-no-grow') {
+        widthStyles.flex = `${+(columnDef.grow || 0)} 0 auto`;
+    }
+    const isDraggingColumn = draggingColumn?.id === column.id;
+    const isHoveredColumn = hoveredColumn?.id === column.id;
+    const isColumnPinned = enableColumnPinning &&
+        columnDef.columnDefType !== 'group' &&
+        column.getIsPinned();
+    const isEditable = !cell.getIsPlaceholder() &&
+        parseFromValuesOrFunc(enableEditing, row) &&
+        parseFromValuesOrFunc(columnDef.enableEditing, row) !== false;
+    const isEditing = isEditable &&
+        !['custom', 'modal'].includes(editDisplayMode) &&
+        (editDisplayMode === 'table' ||
+            editingRow?.id === row.id ||
+            editingCell?.id === cell.id) &&
+        !row.getIsGrouped();
+    const isCreating = isEditable && createDisplayMode === 'row' && creatingRow?.id === row.id;
+    const showClickToCopyButton = parseFromValuesOrFunc(enableClickToCopy, cell) ||
+        (parseFromValuesOrFunc(columnDef.enableClickToCopy, cell) &&
+            parseFromValuesOrFunc(columnDef.enableClickToCopy, cell) !== false);
+    const handleDoubleClick = (event) => {
+        tableCellProps?.onDoubleClick?.(event);
+        if (isEditable && editDisplayMode === 'cell') {
+            setEditingCell(cell);
+            setTimeout(() => {
+                const textField = editInputRefs.current[cell.id];
+                if (textField) {
+                    textField.focus();
+                    textField.select?.();
+                }
+            }, 100);
+        }
+    };
+    const handleDragEnter = (e) => {
+        tableCellProps?.onDragEnter?.(e);
+        if (enableGrouping && hoveredColumn?.id === 'drop-zone') {
+            setHoveredColumn(null);
+        }
+        if (enableColumnOrdering && draggingColumn) {
+            setHoveredColumn(columnDef.enableColumnOrdering !== false ? column : null);
+        }
+    };
+    const cellValueProps = {
+        cell,
+        renderedColumnIndex,
+        renderedRowIndex,
+        table,
+    };
+    const cellHoverRevealDivRef = useRef(null);
+    const [isCellContentOverflowing, setIsCellContentOverflowing] = useState(false);
+    const onMouseEnter = () => {
+        if (!columnDef.enableCellHoverReveal)
+            return;
+        const div = cellHoverRevealDivRef.current;
+        if (div) {
+            const isOverflow = div.scrollWidth > div.clientWidth;
+            setIsCellContentOverflowing(isOverflow);
+        }
+    };
+    const onMouseLeave = () => {
+        if (!columnDef.enableCellHoverReveal)
+            return;
+        setIsCellContentOverflowing(false);
+    };
+    const renderCellContent = () => {
+        if (cell.getIsPlaceholder()) {
+            return columnDef.PlaceholderCell?.({ cell, column, row, table }) ?? null;
+        }
+        if (showSkeletons !== false && (isLoading || showSkeletons)) {
+            return jsx(Skeleton, { height: 20, width: skeletonWidth, ...skeletonProps });
+        }
+        if (columnDefType === 'display' &&
+            (['mrt-row-expand', 'mrt-row-numbers', 'mrt-row-select'].includes(column.id) ||
+                !row.getIsGrouped())) {
+            return columnDef.Cell?.({
+                column,
+                renderedCellValue: cell.renderValue(),
+                row,
+                rowRef,
+                ...cellValueProps,
+            });
+        }
+        if (isCreating || isEditing) {
+            return jsx(MRT_EditCellTextInput, { cell: cell, table: table });
+        }
+        if (showClickToCopyButton && columnDef.enableClickToCopy !== false) {
+            return (jsx(MRT_CopyButton, { cell: cell, table: table, children: jsx(MRT_TableBodyCellValue, { ...cellValueProps }) }));
+        }
+        return jsx(MRT_TableBodyCellValue, { ...cellValueProps });
+    };
+    return (jsx(TableTd, { "data-column-pinned": isColumnPinned || undefined, "data-dragging-column": isDraggingColumn || undefined, "data-first-end-pinned": (isColumnPinned === 'end' && column.getIsFirstColumn(isColumnPinned)) ||
+            undefined, "data-hovered-column-target": isHoveredColumn || undefined, "data-index": renderedColumnIndex, "data-last-start-pinned": (isColumnPinned === 'start' &&
+            column.getIsLastColumn(isColumnPinned)) ||
+            undefined, "data-last-row": renderedRowIndex === numRows - 1 || undefined, "data-resizing": (columnResizeMode === 'onChange' &&
+            columnResizing?.isResizingColumn === column.id &&
+            columnResizeDirection) ||
+            undefined, ...tableCellProps, __vars: {
+            '--mrt-cell-align': tableCellProps.align ?? (direction.dir === 'rtl' ? 'right' : 'left'),
+            '--mrt-table-cell-start': isColumnPinned === 'start'
+                ? `${column.getStart(isColumnPinned)}`
+                : undefined,
+            '--mrt-table-cell-end': isColumnPinned === 'end'
+                ? `${column.getAfter(isColumnPinned)}`
+                : undefined,
+            ...tableCellProps.__vars,
+        }, className: clsx(classes$A.root, layoutMode?.startsWith('grid') && classes$A['root-grid'], virtualCell && classes$A['root-virtualized'], isEditable &&
+            editDisplayMode === 'cell' &&
+            classes$A['root-cursor-pointer'], isEditable &&
+            ['cell', 'table'].includes(editDisplayMode ?? '') &&
+            columnDefType !== 'display' &&
+            classes$A['root-editable-hover'], columnDefType === 'data' && classes$A['root-data-col'], density === 'xs' && classes$A['root-nowrap'], columnDef.enableCellHoverReveal && classes$A['root-cell-hover-reveal'], tableCellProps?.className), onDoubleClick: handleDoubleClick, onDragEnter: handleDragEnter, onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave, style: (theme) => ({
+            ...widthStyles,
+            ...parseFromValuesOrFunc(tableCellProps.style, theme),
+        }), children: jsx(Fragment, { children: tableCellProps.children ??
+                (columnDef.enableCellHoverReveal ? (jsxs("div", { className: clsx(columnDef.enableCellHoverReveal &&
+                        !(isCreating || isEditing) &&
+                        classes$A['cell-hover-reveal'], isCellContentOverflowing && classes$A['overflowing']), ref: cellHoverRevealDivRef, children: [renderCellContent(), cell.getIsGrouped() && !columnDef.GroupedCell && (jsxs(Fragment, { children: [" (", row.subRows?.length, ")"] }))] })) : (jsxs(Fragment, { children: [renderCellContent(), cell.getIsGrouped() && !columnDef.GroupedCell && (jsxs(Fragment, { children: [" (", row.subRows?.length, ")"] }))] }))) }) }));
+};
+const Memo_MRT_TableBodyCell = memo(MRT_TableBodyCell, (prev, next) => next.cell === prev.cell);
+
+var classes$z = {"root":"MRT_TableBodyRow-module_root__2c3D4","root-grid":"MRT_TableBodyRow-module_root-grid__AwXTe","root-virtualized":"MRT_TableBodyRow-module_root-virtualized__zYgxq"};
+
+const MRT_TableBodyRow = ({ children, columnVirtualizer, numRows, pinnedRowIds, renderedRowIndex = 0, row, rowVirtualizer, table, tableProps, virtualRow, ...rest }) => {
+    const { state, options: { enableRowOrdering, enableRowPinning, enableStickyFooter, enableStickyHeader, layoutMode, mantineTableBodyRowProps, memoMode, renderDetailPanel, rowPinningDisplayMode, }, refs: { tableFooterRef, tableHeadRef }, setHoveredRow, } = table;
+    const { density, draggingColumn, draggingRow, editingCell, editingRow, hoveredRow, isFullScreen, rowPinning, } = state;
+    const visibleCells = row.getVisibleCells();
+    const { virtualColumns, virtualPaddingLeft, virtualPaddingRight } = columnVirtualizer ?? {};
+    const isRowSelected = getIsRowSelected({ row, table });
+    const isRowPinned = enableRowPinning && row.getIsPinned();
+    const isRowStickyPinned = isRowPinned && rowPinningDisplayMode?.includes('sticky') && 'sticky';
+    const isDraggingRow = draggingRow?.id === row.id;
+    const isHoveredRow = hoveredRow?.id === row.id;
+    const tableRowProps = {
+        ...parseFromValuesOrFunc(mantineTableBodyRowProps, {
+            renderedRowIndex,
+            row,
+            table,
+        }),
+        ...rest,
+    };
+    const [bottomPinnedIndex, topPinnedIndex] = useMemo(() => {
+        if (!enableRowPinning ||
+            !isRowStickyPinned ||
+            !pinnedRowIds ||
+            !row.getIsPinned())
+            return [];
+        return [
+            [...pinnedRowIds].reverse().indexOf(row.id),
+            pinnedRowIds.indexOf(row.id),
+        ];
+    }, [pinnedRowIds, rowPinning]);
+    const tableHeadHeight = ((enableStickyHeader || isFullScreen) &&
+        tableHeadRef.current?.clientHeight) ||
+        0;
+    const tableFooterHeight = (enableStickyFooter && tableFooterRef.current?.clientHeight) || 0;
+    const defaultRowHeightByDensity = {
+        lg: 61,
+        md: 53,
+        sm: 45,
+        xl: 69,
+        xs: 37,
+    };
+    const rowHeight = 
+    // @ts-ignore
+    parseInt(tableRowProps?.style?.height, 10) ||
+        (defaultRowHeightByDensity[density] ?? defaultRowHeightByDensity['md']);
+    const handleDragEnter = (_e) => {
+        if (enableRowOrdering && draggingRow) {
+            setHoveredRow(row);
+        }
+    };
+    const rowRef = useRef(null);
+    let striped = tableProps.striped;
+    if (striped) {
+        if (striped === true) {
+            striped = 'odd';
+        }
+        if (striped === 'odd' && renderedRowIndex % 2 !== 0) {
+            striped = false;
+        }
+        if (striped === 'even' && renderedRowIndex % 2 === 0) {
+            striped = false;
+        }
+    }
+    return (jsxs(Fragment, { children: [jsxs(TableTr, { "data-dragging-row": isDraggingRow || undefined, "data-hovered-row-target": isHoveredRow || undefined, "data-index": renderDetailPanel ? renderedRowIndex * 2 : renderedRowIndex, "data-row-pinned": isRowStickyPinned || isRowPinned || undefined, "data-selected": isRowSelected || undefined, "data-striped": striped, onDragEnter: handleDragEnter, ref: (node) => {
+                    if (node) {
+                        rowRef.current = node;
+                        rowVirtualizer?.measureElement(node);
+                    }
+                }, ...tableRowProps, __vars: {
+                    ...tableRowProps?.__vars,
+                    '--mrt-pinned-row-bottom': !virtualRow && bottomPinnedIndex !== undefined && isRowPinned
+                        ? `${bottomPinnedIndex * rowHeight +
+                            (enableStickyFooter ? tableFooterHeight - 1 : 0)}`
+                        : undefined,
+                    '--mrt-pinned-row-top': virtualRow
+                        ? undefined
+                        : topPinnedIndex !== undefined && isRowPinned
+                            ? `${topPinnedIndex * rowHeight +
+                                (enableStickyHeader || isFullScreen ? tableHeadHeight - 1 : 0)}`
+                            : undefined,
+                    '--mrt-virtual-row-start': virtualRow
+                        ? `${virtualRow.start}`
+                        : undefined,
+                }, className: clsx(classes$z.root, layoutMode?.startsWith('grid') && classes$z['root-grid'], virtualRow && classes$z['root-virtualized'], tableRowProps?.className), children: [virtualPaddingLeft ? (jsx(Box, { component: "td", display: "flex", w: virtualPaddingLeft })) : null, children
+                        ? children
+                        : (virtualColumns ?? row.getVisibleCells()).map((cellOrVirtualCell, renderedColumnIndex) => {
+                            let cell = cellOrVirtualCell;
+                            if (columnVirtualizer) {
+                                renderedColumnIndex = cellOrVirtualCell
+                                    .index;
+                                cell = visibleCells[renderedColumnIndex];
+                            }
+                            const cellProps = {
+                                cell,
+                                numRows,
+                                renderedColumnIndex,
+                                renderedRowIndex,
+                                rowRef,
+                                table,
+                                virtualCell: columnVirtualizer
+                                    ? cellOrVirtualCell
+                                    : undefined,
+                            };
+                            return memoMode === 'cells' &&
+                                cell.column.columnDef.columnDefType === 'data' &&
+                                !draggingColumn &&
+                                !draggingRow &&
+                                editingCell?.id !== cell.id &&
+                                editingRow?.id !== row.id ? (jsx(Memo_MRT_TableBodyCell, { ...cellProps }, cell.id)) : (jsx(MRT_TableBodyCell, { ...cellProps }, cell.id));
+                        }), virtualPaddingRight ? (jsx(Box, { component: "td", display: "flex", w: virtualPaddingRight })) : null] }), renderDetailPanel && !row.getIsGrouped() && (jsx(MRT_TableDetailPanel, { parentRowRef: rowRef, renderedRowIndex: renderedRowIndex, row: row, rowVirtualizer: rowVirtualizer, striped: striped, table: table, virtualRow: virtualRow }))] }));
+};
+const Memo_MRT_TableBodyRow = memo(MRT_TableBodyRow, (prev, next) => prev.row === next.row);
+
+var classes$y = {"root":"MRT_ExpandButton-module_root__IFYio","root-ltr":"MRT_ExpandButton-module_root-ltr__FHNnp","chevron":"MRT_ExpandButton-module_chevron__XzC5P","right":"MRT_ExpandButton-module_right__-pC-A","up":"MRT_ExpandButton-module_up__TZGBo","root-rtl":"MRT_ExpandButton-module_root-rtl__zoudS"};
+
+const MRT_ExpandButton = ({ row, table, ...rest }) => {
+    const direction = useDirection();
+    const { options: { icons: { IconChevronDown }, localization, mantineExpandButtonProps, positionExpandColumn, renderDetailPanel, }, } = table;
+    const actionIconProps = {
+        ...parseFromValuesOrFunc(mantineExpandButtonProps, {
+            row,
+            table,
+        }),
+        ...rest,
+    };
+    const internalEditComponents = row
+        .getAllCells()
+        .filter((cell) => cell.column.columnDef.columnDefType === 'data')
+        .map((cell) => (jsx(MRT_EditCellTextInput, { cell: cell, table: table }, cell.id)));
+    const canExpand = row.getCanExpand();
+    const isExpanded = row.getIsExpanded();
+    const DetailPanel = !!renderDetailPanel?.({
+        internalEditComponents,
+        row,
+        table,
+    });
+    const handleToggleExpand = (event) => {
+        event.stopPropagation();
+        row.toggleExpanded();
+        actionIconProps?.onClick?.(event);
+    };
+    const rtl = direction.dir === 'rtl' || positionExpandColumn === 'last';
+    return (jsx(Tooltip, { disabled: !canExpand && !DetailPanel, label: actionIconProps?.title ??
+            (isExpanded ? localization.collapse : localization.expand), openDelay: 1000, withinPortal: true, children: jsx(ActionIcon, { "aria-label": localization.expand, color: "gray", disabled: !canExpand && !DetailPanel, variant: "subtle", ...actionIconProps, __vars: {
+                '--mrt-row-depth': `${row.depth}`,
+            }, className: clsx('mrt-expand-button', classes$y.root, classes$y[`root-${rtl ? 'rtl' : 'ltr'}`], actionIconProps?.className), onClick: handleToggleExpand, title: undefined, children: actionIconProps?.children ?? (jsx(IconChevronDown, { className: clsx('mrt-expand-button-chevron', classes$y.chevron, !canExpand && !renderDetailPanel
+                    ? classes$y.right
+                    : isExpanded
+                        ? classes$y.up
+                        : undefined) })) }) }));
+};
+
+var classes$x = {"root":"MRT_TableBody-module_root__kGhRy","root-grid":"MRT_TableBody-module_root-grid__WdOGg","root-no-rows":"MRT_TableBody-module_root-no-rows__iyi9K","root-virtualized":"MRT_TableBody-module_root-virtualized__TxPAi","empty-row-tr-grid":"MRT_TableBody-module_empty-row-tr-grid__LTgxw","empty-row-td-grid":"MRT_TableBody-module_empty-row-td-grid__pzlgG","empty-row-td-content":"MRT_TableBody-module_empty-row-td-content__Cc2XW","pinned":"MRT_TableBody-module_pinned__XHpcs"};
+
+const MRT_TableBodyEmptyRow = ({ table, tableProps, ...commonRowProps }) => {
+    const { state, options: { layoutMode, localization, renderDetailPanel, renderEmptyRowsFallback, }, refs: { tablePaperRef }, } = table;
+    const { columnFilters, globalFilter } = state;
+    const emptyRow = useMemo(() => constructRow(table, 'mrt-row-empty', {}, 0, 0), []);
+    const emptyRowProps = {
+        ...commonRowProps,
+        renderedRowIndex: 0,
+        row: emptyRow,
+        virtualRow: undefined,
+    };
+    return (jsxs(MRT_TableBodyRow, { className: clsx('mrt-table-body-row', layoutMode?.startsWith('grid') && classes$x['empty-row-tr-grid']), table: table, tableProps: tableProps, ...emptyRowProps, children: [renderDetailPanel && (jsx(TableTd, { className: clsx('mrt-table-body-cell', layoutMode?.startsWith('grid') && classes$x['empty-row-td-grid']), colSpan: 1, children: jsx(MRT_ExpandButton, { row: emptyRow, table: table }) })), jsx("td", { className: clsx('mrt-table-body-cell', layoutMode?.startsWith('grid') && classes$x['empty-row-td-grid']), colSpan: table.getVisibleLeafColumns().length, children: renderEmptyRowsFallback?.({ table }) ?? (jsx(Text, { __vars: {
+                        '--mrt-paper-width': `${tablePaperRef.current?.clientWidth}`,
+                    }, className: clsx(classes$x['empty-row-td-content']), children: globalFilter || columnFilters.length
+                        ? localization.noResultsFound
+                        : localization.noRecordsToDisplay })) })] }));
+};
+
+const MRT_TableBody = ({ columnVirtualizer, table, tableProps, ...rest }) => {
+    const { getBottomRows, getIsSomeRowsPinned, getRowModel, state, getTopRows, options: { enableStickyFooter, enableStickyHeader, layoutMode, mantineTableBodyProps, memoMode, renderDetailPanel, rowPinningDisplayMode, }, refs: { tableFooterRef, tableHeadRef }, } = table;
+    const { isFullScreen, rowPinning } = state;
+    const tableBodyProps = {
+        ...parseFromValuesOrFunc(mantineTableBodyProps, { table }),
+        ...rest,
+    };
+    const tableHeadHeight = ((enableStickyHeader || isFullScreen) &&
+        tableHeadRef.current?.clientHeight) ||
+        0;
+    const tableFooterHeight = (enableStickyFooter && tableFooterRef.current?.clientHeight) || 0;
+    const pinnedRowIds = useMemo(() => {
+        if (!rowPinning.bottom?.length && !rowPinning.top?.length)
+            return [];
+        return getRowModel()
+            .rows.filter((row) => row.getIsPinned())
+            .map((r) => r.id);
+    }, [rowPinning, getRowModel().rows]);
+    const rows = useMRT_Rows(table);
+    const rowVirtualizer = useMRT_RowVirtualizer(table, rows);
+    const { virtualRows } = rowVirtualizer ?? {};
+    const commonRowProps = {
+        columnVirtualizer,
+        numRows: rows.length,
+        table,
+        tableProps,
+    };
+    return (jsxs(Fragment, { children: [!rowPinningDisplayMode?.includes('sticky') &&
+                getIsSomeRowsPinned('top') && (jsx(TableTbody, { ...tableBodyProps, __vars: {
+                    '--mrt-table-head-height': `${tableHeadHeight}`,
+                    ...tableBodyProps?.__vars,
+                }, className: clsx(classes$x.pinned, layoutMode?.startsWith('grid') && classes$x['root-grid'], tableBodyProps?.className), children: getTopRows().map((row, renderedRowIndex) => {
+                    const rowProps = {
+                        ...commonRowProps,
+                        renderedRowIndex,
+                        row,
+                    };
+                    return memoMode === 'rows' ? (jsx(Memo_MRT_TableBodyRow, { ...rowProps }, row.id)) : (jsx(MRT_TableBodyRow, { ...rowProps }, row.id));
+                }) })), jsx(TableTbody, { ...tableBodyProps, __vars: {
+                    '--mrt-table-body-height': rowVirtualizer
+                        ? `${rowVirtualizer.getTotalSize()}px`
+                        : undefined,
+                    ...tableBodyProps?.__vars,
+                }, className: clsx(classes$x.root, layoutMode?.startsWith('grid') && classes$x['root-grid'], !rows.length && classes$x['root-no-rows'], rowVirtualizer && classes$x['root-virtualized'], tableBodyProps?.className), children: tableBodyProps?.children ??
+                    (!rows.length ? (jsx(MRT_TableBodyEmptyRow, { ...commonRowProps })) : (jsx(Fragment, { children: (virtualRows ?? rows).map((rowOrVirtualRow, renderedRowIndex) => {
+                            if (rowVirtualizer) {
+                                if (renderDetailPanel) {
+                                    if (rowOrVirtualRow.index % 2 === 1) {
+                                        return null;
+                                    }
+                                    else {
+                                        renderedRowIndex = rowOrVirtualRow.index / 2;
+                                    }
+                                }
+                                else {
+                                    renderedRowIndex = rowOrVirtualRow.index;
+                                }
+                            }
+                            const row = rowVirtualizer
+                                ? rows[renderedRowIndex]
+                                : rowOrVirtualRow;
+                            const props = {
+                                ...commonRowProps,
+                                pinnedRowIds,
+                                renderedRowIndex,
+                                row,
+                                rowVirtualizer,
+                                virtualRow: rowVirtualizer
+                                    ? rowOrVirtualRow
+                                    : undefined,
+                            };
+                            const key = `${row.id}-${row.index}`;
+                            return memoMode === 'rows' ? (jsx(Memo_MRT_TableBodyRow, { ...props }, key)) : (jsx(MRT_TableBodyRow, { ...props }, key));
+                        }) }))) }), !rowPinningDisplayMode?.includes('sticky') &&
+                getIsSomeRowsPinned('bottom') && (jsx(TableTbody, { ...tableBodyProps, __vars: {
+                    '--mrt-table-footer-height': `${tableFooterHeight}`,
+                    ...tableBodyProps?.__vars,
+                }, className: clsx(classes$x.pinned, layoutMode?.startsWith('grid') && classes$x['root-grid'], tableBodyProps?.className), children: getBottomRows().map((row, renderedRowIndex) => {
+                    const props = {
+                        ...commonRowProps,
+                        renderedRowIndex,
+                        row,
+                    };
+                    return memoMode === 'rows' ? (jsx(Memo_MRT_TableBodyRow, { ...props }, row.id)) : (jsx(MRT_TableBodyRow, { ...props }, row.id));
+                }) }))] }));
+};
+const Memo_MRT_TableBody = memo(MRT_TableBody, (prev, next) => prev.table.options.data === next.table.options.data);
+
+var classes$w = {"grab-icon":"MRT_GrabHandleButton-module_grab-icon__mQimy"};
+
+const MRT_GrabHandleButton = ({ actionIconProps, onDragEnd, onDragStart, table: { options: { icons: { IconGripHorizontal }, localization: { move }, }, }, }) => {
+    return (jsx(Tooltip, { label: actionIconProps?.title ?? move, openDelay: 1000, withinPortal: true, children: jsx(ActionIcon, { "aria-label": actionIconProps?.title ?? move, draggable: true, ...actionIconProps, className: clsx('mrt-grab-handle-button', classes$w['grab-icon'], actionIconProps?.className), color: "gray", onClick: (e) => {
+                e.stopPropagation();
+                actionIconProps?.onClick?.(e);
+            }, onDragEnd: onDragEnd, onDragStart: onDragStart, size: "sm", title: undefined, variant: "transparent", children: jsx(IconGripHorizontal, { size: "100%" }) }) }));
+};
+
+const MRT_TableBodyRowGrabHandle = ({ row, rowRef, table, ...rest }) => {
+    const { options: { mantineRowDragHandleProps }, } = table;
+    const actionIconProps = {
+        ...parseFromValuesOrFunc(mantineRowDragHandleProps, {
+            row,
+            table,
+        }),
+        ...rest,
+    };
+    const handleDragStart = (event) => {
+        actionIconProps?.onDragStart?.(event);
+        event.dataTransfer.setDragImage(rowRef.current, 0, 0);
+        table.setDraggingRow(row);
+    };
+    const handleDragEnd = (event) => {
+        actionIconProps?.onDragEnd?.(event);
+        table.setDraggingRow(null);
+        table.setHoveredRow(null);
+    };
+    return (jsx(MRT_GrabHandleButton, { actionIconProps: actionIconProps, onDragEnd: handleDragEnd, onDragStart: handleDragStart, table: table }));
+};
+
+const MRT_RowPinButton = ({ pinningPosition, row, table, ...rest }) => {
+    const { options: { icons: { IconPinned, IconX }, localization, rowPinningDisplayMode, }, } = table;
+    const isPinned = row.getIsPinned();
+    const [tooltipOpened, setTooltipOpened] = useState(false);
+    const handleTogglePin = (event) => {
+        setTooltipOpened(false);
+        event.stopPropagation();
+        row.pin(isPinned ? false : pinningPosition);
+    };
+    return (jsx(Tooltip, { label: isPinned ? localization.unpin : localization.pin, openDelay: 1000, opened: tooltipOpened, children: jsx(ActionIcon, { "aria-label": localization.pin, color: "gray", onClick: handleTogglePin, onMouseEnter: () => setTooltipOpened(true), onMouseLeave: () => setTooltipOpened(false), size: "xs", style: {
+                height: '24px',
+                width: '24px',
+            }, variant: "subtle", ...rest, children: isPinned ? (jsx(IconX, {})) : (jsx(IconPinned, { fontSize: "small", style: {
+                    transform: `rotate(${rowPinningDisplayMode === 'sticky'
+                        ? 135
+                        : pinningPosition === 'top'
+                            ? 180
+                            : 0}deg)`,
+                } })) }) }));
+};
+
+const MRT_TableBodyRowPinButton = ({ row, table, ...rest }) => {
+    const { state, options: { enableRowPinning, rowPinningDisplayMode }, } = table;
+    const { density } = state;
+    const canPin = parseFromValuesOrFunc(enableRowPinning, row);
+    if (!canPin)
+        return null;
+    const rowPinButtonProps = {
+        row,
+        table,
+        ...rest,
+    };
+    if (rowPinningDisplayMode === 'top-and-bottom' && !row.getIsPinned()) {
+        return (jsxs(Box, { style: {
+                display: 'flex',
+                flexDirection: density === 'xs' ? 'row' : 'column',
+            }, children: [jsx(MRT_RowPinButton, { pinningPosition: "top", ...rowPinButtonProps }), jsx(MRT_RowPinButton, { pinningPosition: "bottom", ...rowPinButtonProps })] }));
+    }
+    return (jsx(MRT_RowPinButton, { pinningPosition: rowPinningDisplayMode === 'bottom' ? 'bottom' : 'top', ...rowPinButtonProps }));
+};
+
+var classes$v = {"root":"MRT_ColumnPinningButtons-module_root__scTtW","left":"MRT_ColumnPinningButtons-module_left__W6Aog","right":"MRT_ColumnPinningButtons-module_right__7AJE3"};
+
+const MRT_ColumnPinningButtons = ({ column, table, }) => {
+    const { options: { icons: { IconPinned, IconPinnedOff }, localization, }, } = table;
+    return (jsx(Flex, { className: clsx('mrt-column-pinning-buttons', classes$v.root), children: column.getIsPinned() ? (jsx(Tooltip, { label: localization.unpin, withinPortal: true, children: jsx(ActionIcon, { color: "gray", onClick: () => column.pin(false), size: "md", variant: "subtle", children: jsx(IconPinnedOff, {}) }) })) : (jsxs(Fragment, { children: [jsx(Tooltip, { label: localization.pinToLeft, withinPortal: true, children: jsx(ActionIcon, { color: "gray", onClick: () => column.pin('start'), size: "md", variant: "subtle", children: jsx(IconPinned, { className: classes$v.left }) }) }), jsx(Tooltip, { label: localization.pinToRight, withinPortal: true, children: jsx(ActionIcon, { color: "gray", onClick: () => column.pin('end'), size: "md", variant: "subtle", children: jsx(IconPinned, { className: classes$v.right }) }) })] })) }));
+};
+
+var classes$u = {"root":"MRT_EditActionButtons-module_root__BfxVZ"};
+
+const MRT_EditActionButtons = ({ row, table, variant = 'icon', ...rest }) => {
+    const { state, options: { icons: { IconCircleX, IconDeviceFloppy }, localization, onCreatingRowCancel, onCreatingRowSave, onEditingRowCancel, onEditingRowSave, }, refs: { editInputRefs }, setCreatingRow, setEditingRow, } = table;
+    const { creatingRow, editingRow, isSaving } = state;
+    const isCreating = creatingRow?.id === row.id;
+    const isEditing = editingRow?.id === row.id;
+    const handleCancel = () => {
+        if (isCreating) {
+            onCreatingRowCancel?.({ row, table });
+            setCreatingRow(null);
+        }
+        else if (isEditing) {
+            onEditingRowCancel?.({ row, table });
+            setEditingRow(null);
+        }
+        row._valuesCache = {}; // reset values cache
+    };
+    const handleSubmitRow = () => {
+        // look for auto-filled input values
+        Object.values(editInputRefs?.current)
+            .filter((inputRef) => row.id === inputRef?.name?.split('_')?.[0])
+            ?.forEach((input) => {
+            if (input.value !== undefined &&
+                Object.hasOwn(row?._valuesCache, input.name)) {
+                // @ts-ignore
+                row._valuesCache[input.name] = input.value;
+            }
+        });
+        if (isCreating)
+            onCreatingRowSave?.({
+                exitCreatingMode: () => setCreatingRow(null),
+                row,
+                table,
+                values: row._valuesCache,
+            });
+        else if (isEditing) {
+            onEditingRowSave?.({
+                exitEditingMode: () => setEditingRow(null),
+                row,
+                table,
+                values: row?._valuesCache,
+            });
+        }
+    };
+    return (jsx(Box, { className: clsx('mrt-edit-action-buttons', classes$u.root), onClick: (e) => e.stopPropagation(), ...rest, children: variant === 'icon' ? (jsxs(Fragment, { children: [jsx(Tooltip, { label: localization.cancel, withinPortal: true, children: jsx(ActionIcon, { "aria-label": localization.cancel, color: "red", onClick: handleCancel, variant: "subtle", children: jsx(IconCircleX, {}) }) }), jsx(Tooltip, { label: localization.save, withinPortal: true, children: jsx(ActionIcon, { "aria-label": localization.save, color: "blue", loading: isSaving, onClick: handleSubmitRow, variant: "subtle", children: jsx(IconDeviceFloppy, {}) }) })] })) : (jsxs(Fragment, { children: [jsx(Button, { onClick: handleCancel, variant: "subtle", children: localization.cancel }), jsx(Button, { loading: isSaving, onClick: handleSubmitRow, variant: "filled", children: localization.save })] })) }));
+};
+
+var classes$t = {"root":"MRT_ExpandAllButton-module_root__gkBZD","chevron":"MRT_ExpandAllButton-module_chevron__Iep0j","up":"MRT_ExpandAllButton-module_up__Xth3U","right":"MRT_ExpandAllButton-module_right__bS4L-"};
+
+const MRT_ExpandAllButton = ({ table, ...rest }) => {
+    const { getCanSomeRowsExpand, getIsAllRowsExpanded, getIsSomeRowsExpanded, state, options: { icons: { IconChevronsDown }, localization, mantineExpandAllButtonProps, renderDetailPanel, }, toggleAllRowsExpanded, } = table;
+    const { density, isLoading } = state;
+    const actionIconProps = {
+        ...parseFromValuesOrFunc(mantineExpandAllButtonProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const isAllRowsExpanded = getIsAllRowsExpanded();
+    return (jsx(Tooltip, { label: (actionIconProps?.title ?? isAllRowsExpanded)
+            ? localization.collapseAll
+            : localization.expandAll, openDelay: 1000, withinPortal: true, children: jsx(ActionIcon, { "aria-label": localization.expandAll, color: "gray", variant: "subtle", ...actionIconProps, className: clsx('mrt-expand-all-button', classes$t.root, actionIconProps?.className, density), disabled: isLoading || (!renderDetailPanel && !getCanSomeRowsExpand()), onClick: () => toggleAllRowsExpanded(!isAllRowsExpanded), title: undefined, children: actionIconProps?.children ?? (jsx(IconChevronsDown, { className: clsx(classes$t.chevron, isAllRowsExpanded
+                    ? classes$t.up
+                    : getIsSomeRowsExpanded()
+                        ? classes$t.right
+                        : undefined) })) }) }));
+};
+
+const getColumnId = (columnDef) => columnDef.id ?? columnDef.accessorKey?.toString?.() ?? columnDef.header;
+const getAllLeafColumnDefs = (columns) => {
+    const allLeafColumnDefs = [];
+    const getLeafColumns = (cols) => {
+        cols.forEach((col) => {
+            if (col.columns) {
+                getLeafColumns(col.columns);
+            }
+            else {
+                allLeafColumnDefs.push(col);
+            }
+        });
+    };
+    getLeafColumns(columns);
+    return allLeafColumnDefs;
+};
+const prepareColumns = ({ columnDefs, tableOptions, }) => {
+    const { defaultDisplayColumn, filterFns = {}, sortFns = {}, state: { columnFilterFns = {} } = {}, } = tableOptions;
+    return columnDefs.map((columnDef) => {
+        // assign columnId
+        if (!columnDef.id)
+            columnDef.id = getColumnId(columnDef);
+        // assign columnDefType
+        if (!columnDef.columnDefType)
+            columnDef.columnDefType = 'data';
+        if (columnDef.columns?.length) {
+            columnDef.columnDefType = 'group';
+            // recursively prepare columns if this is a group column
+            columnDef.columns = prepareColumns({
+                columnDefs: columnDef.columns,
+                tableOptions,
+            });
+        }
+        else if (columnDef.columnDefType === 'data') {
+            // assign filterFns
+            if (Object.keys(filterFns).includes(columnFilterFns[columnDef.id])) {
+                columnDef.filterFn =
+                    filterFns[columnFilterFns[columnDef.id]] ?? filterFns.fuzzy;
+                columnDef._filterFn =
+                    columnFilterFns[columnDef.id];
+            }
+            // assign sortFns
+            if (Object.keys(sortFns).includes(columnDef.sortFn)) {
+                columnDef.sortFn = sortFns[columnDef.sortFn];
+            }
+        }
+        else if (columnDef.columnDefType === 'display') {
+            columnDef = {
+                ...defaultDisplayColumn,
+                ...columnDef,
+            };
+        }
+        return columnDef;
+    });
+};
+const reorderColumn = (draggedColumn, targetColumn, columnOrder) => {
+    if (draggedColumn.getCanPin()) {
+        draggedColumn.pin(targetColumn.getIsPinned());
+    }
+    const newColumnOrder = [...columnOrder];
+    newColumnOrder.splice(newColumnOrder.indexOf(targetColumn.id), 0, newColumnOrder.splice(newColumnOrder.indexOf(draggedColumn.id), 1)[0]);
+    return newColumnOrder;
+};
+const getDefaultColumnFilterFn = (columnDef) => {
+    const { filterVariant } = columnDef;
+    if (filterVariant === 'multi-select')
+        return 'arrIncludesSome';
+    if (filterVariant?.includes('range'))
+        return 'betweenInclusive';
+    if (['checkbox', 'date', 'select'].includes(filterVariant || ''))
+        return 'equals';
+    return 'fuzzy';
+};
+
+function defaultDisplayColumnProps({ header, id, size, tableOptions, }) {
+    const { defaultDisplayColumn, displayColumnDefOptions, localization } = tableOptions;
+    return {
+        ...defaultDisplayColumn,
+        header: header ? localization[header] : '',
+        size,
+        ...displayColumnDefOptions?.[id],
+        id,
+    };
+}
+const showRowPinningColumn = (tableOptions) => {
+    const { enableRowPinning, rowPinningDisplayMode } = tableOptions;
+    return !!(enableRowPinning && !rowPinningDisplayMode?.startsWith('select'));
+};
+const showRowDragColumn = (tableOptions) => {
+    const { enableRowDragging, enableRowOrdering } = tableOptions;
+    return !!(enableRowDragging || enableRowOrdering);
+};
+const showRowExpandColumn = (tableOptions) => {
+    const { enableExpanding, enableGrouping, renderDetailPanel, state: { grouping }, } = tableOptions;
+    return !!(enableExpanding ||
+        (enableGrouping && grouping?.length) ||
+        renderDetailPanel);
+};
+const showRowActionsColumn = (tableOptions) => {
+    const { createDisplayMode, editDisplayMode, enableEditing, enableRowActions, state: { creatingRow }, } = tableOptions;
+    return !!(enableRowActions ||
+        (creatingRow && createDisplayMode === 'row') ||
+        (enableEditing && ['modal', 'row'].includes(editDisplayMode ?? '')));
+};
+const showRowSelectionColumn = (tableOptions) => !!tableOptions.enableRowSelection;
+const showRowNumbersColumn = (tableOptions) => !!tableOptions.enableRowNumbers;
+const showRowSpacerColumn = (tableOptions) => tableOptions.layoutMode === 'grid-no-grow';
+const getLeadingDisplayColumnIds = (tableOptions) => [
+    showRowPinningColumn(tableOptions) && 'mrt-row-pin',
+    showRowDragColumn(tableOptions) && 'mrt-row-drag',
+    tableOptions.positionActionsColumn === 'first' &&
+        showRowActionsColumn(tableOptions) &&
+        'mrt-row-actions',
+    tableOptions.positionExpandColumn === 'first' &&
+        showRowExpandColumn(tableOptions) &&
+        'mrt-row-expand',
+    showRowSelectionColumn(tableOptions) && 'mrt-row-select',
+    showRowNumbersColumn(tableOptions) && 'mrt-row-numbers',
+].filter(Boolean);
+const getTrailingDisplayColumnIds = (tableOptions) => [
+    tableOptions.positionActionsColumn === 'last' &&
+        showRowActionsColumn(tableOptions) &&
+        'mrt-row-actions',
+    tableOptions.positionExpandColumn === 'last' &&
+        showRowExpandColumn(tableOptions) &&
+        'mrt-row-expand',
+    showRowSpacerColumn(tableOptions) && 'mrt-row-spacer',
+].filter(Boolean);
+const getDefaultColumnOrderIds = (tableOptions, reset = false) => {
+    const { state: { columnOrder: currentColumnOrderIds = [] }, } = tableOptions;
+    const leadingDisplayColIds = getLeadingDisplayColumnIds(tableOptions);
+    const trailingDisplayColIds = getTrailingDisplayColumnIds(tableOptions);
+    const defaultColumnDefIds = getAllLeafColumnDefs(tableOptions.columns).map((columnDef) => getColumnId(columnDef));
+    let allLeafColumnDefIds = reset
+        ? defaultColumnDefIds
+        : Array.from(new Set([...currentColumnOrderIds, ...defaultColumnDefIds]));
+    allLeafColumnDefIds = allLeafColumnDefIds.filter((colId) => !leadingDisplayColIds.includes(colId) &&
+        !trailingDisplayColIds.includes(colId));
+    return [
+        ...leadingDisplayColIds,
+        ...allLeafColumnDefIds,
+        ...trailingDisplayColIds,
+    ];
+};
+
+var classes$s = {"root":"MRT_ShowHideColumnsMenuItems-module_root__wYgv-","menu":"MRT_ShowHideColumnsMenuItems-module_menu__CeATR","grab":"MRT_ShowHideColumnsMenuItems-module_grab__a-d-y","pin":"MRT_ShowHideColumnsMenuItems-module_pin__P437b","switch":"MRT_ShowHideColumnsMenuItems-module_switch__tMsdt","header":"MRT_ShowHideColumnsMenuItems-module_header__xVkKb"};
+
+const MRT_ShowHideColumnsMenuItems = ({ allColumns, column, hoveredColumn, setHoveredColumn, table, }) => {
+    const theme = useMantineTheme();
+    const { state, options: { enableColumnOrdering, enableColumnPinning, enableHiding, localization, }, setColumnOrder, } = table;
+    const { columnOrder } = state;
+    const { columnDef } = column;
+    const { columnDefType } = columnDef;
+    const switchChecked = (columnDefType !== 'group' && column.getIsVisible()) ||
+        (columnDefType === 'group' &&
+            column.getLeafColumns().some((col) => col.getIsVisible()));
+    const handleToggleColumnHidden = (column) => {
+        if (columnDefType === 'group') {
+            column?.columns?.forEach?.((childColumn) => {
+                childColumn.toggleVisibility(!switchChecked);
+            });
+        }
+        else {
+            column.toggleVisibility();
+        }
+    };
+    const menuItemRef = useRef(null);
+    const [isDragging, setIsDragging] = useState(false);
+    const handleDragStart = (e) => {
+        setIsDragging(true);
+        e.dataTransfer.setDragImage(menuItemRef.current, 0, 0);
+    };
+    const handleDragEnd = (_e) => {
+        setIsDragging(false);
+        setHoveredColumn(null);
+        if (hoveredColumn) {
+            setColumnOrder(reorderColumn(column, hoveredColumn, columnOrder));
+        }
+    };
+    const handleDragEnter = (_e) => {
+        if (!isDragging && columnDef.enableColumnOrdering !== false) {
+            setHoveredColumn(column);
+        }
+    };
+    if (!columnDef.header || columnDef.visibleInShowHideMenu === false) {
+        return null;
+    }
+    return (jsxs(Fragment, { children: [jsx(Menu.Item, { className: classes$s.root, component: "span", onDragEnter: handleDragEnter, ref: menuItemRef, style: {
+                    '--_column-depth': `${(column.depth + 0.5) * 2}rem`,
+                    '--_hover-color': getPrimaryColor(theme),
+                }, ...dataVariable('dragging', isDragging), ...dataVariable('order-hovered', hoveredColumn?.id === column.id), children: jsxs(Box, { className: classes$s.menu, children: [columnDefType !== 'group' &&
+                            enableColumnOrdering &&
+                            !allColumns.some((col) => col.columnDef.columnDefType === 'group') &&
+                            (columnDef.enableColumnOrdering !== false ? (jsx(MRT_GrabHandleButton, { onDragEnd: handleDragEnd, onDragStart: handleDragStart, table: table })) : (jsx(Box, { className: classes$s.grab }))), enableColumnPinning &&
+                            (column.getCanPin() ? (jsx(MRT_ColumnPinningButtons, { column: column, table: table })) : (jsx(Box, { className: classes$s.pin }))), enableHiding ? (jsx(Tooltip, { label: localization.toggleVisibility, openDelay: 1000, withinPortal: true, children: jsx(Switch, { checked: switchChecked, className: classes$s.switch, disabled: !column.getCanHide(), label: columnDef.header, onChange: () => handleToggleColumnHidden(column) }) })) : (jsx(Text, { className: classes$s.header, children: columnDef.header }))] }) }), column.columns?.map((c, i) => (jsx(MRT_ShowHideColumnsMenuItems, { allColumns: allColumns, column: c, hoveredColumn: hoveredColumn, setHoveredColumn: setHoveredColumn, table: table }, `${i}-${c.id}`)))] }));
+};
+
+var classes$r = {"root":"MRT_ShowHideColumnsMenu-module_root__2UWak","content":"MRT_ShowHideColumnsMenu-module_content__ehkWQ"};
+
+const MRT_ShowHideColumnsMenu = ({ table, }) => {
+    const { getAllColumns, getAllLeafColumns, getCenterLeafColumns, getIsAllColumnsVisible, getIsSomeColumnsPinned, getIsSomeColumnsVisible, getStartLeafColumns, getEndLeafColumns, state, options: { enableColumnOrdering, enableColumnPinning, enableHiding, localization, }, } = table;
+    const { columnOrder, columnPinning } = state;
+    const handleToggleAllColumns = (value) => {
+        getAllLeafColumns()
+            .filter((col) => col.columnDef.enableHiding !== false)
+            .forEach((col) => col.toggleVisibility(value));
+    };
+    const allColumns = useMemo(() => {
+        const columns = getAllColumns();
+        if (columnOrder.length > 0 &&
+            !columns.some((col) => col.columnDef.columnDefType === 'group')) {
+            return [
+                ...getStartLeafColumns(),
+                ...Array.from(new Set(columnOrder)).map((colId) => getCenterLeafColumns().find((col) => col?.id === colId)),
+                ...getEndLeafColumns(),
+            ].filter(Boolean);
+        }
+        return columns;
+    }, [
+        columnOrder,
+        columnPinning,
+        getAllColumns(),
+        getCenterLeafColumns(),
+        getStartLeafColumns(),
+        getEndLeafColumns(),
+    ]);
+    const [hoveredColumn, setHoveredColumn] = useState(null);
+    return (jsxs(Menu.Dropdown, { className: clsx('mrt-show-hide-columns-menu', classes$r.root), children: [jsxs(Flex, { className: classes$r.content, children: [enableHiding && (jsx(Button, { disabled: !getIsSomeColumnsVisible(), onClick: () => handleToggleAllColumns(false), variant: "subtle", children: localization.hideAll })), enableColumnOrdering && (jsx(Button, { onClick: () => table.setColumnOrder(getDefaultColumnOrderIds({
+                            ...table.options,
+                            state,
+                        }, true)), variant: "subtle", children: localization.resetOrder })), enableColumnPinning && (jsx(Button, { disabled: !getIsSomeColumnsPinned(), onClick: () => table.resetColumnPinning(true), variant: "subtle", children: localization.unpinAll })), enableHiding && (jsx(Button, { disabled: getIsAllColumnsVisible(), onClick: () => handleToggleAllColumns(true), variant: "subtle", children: localization.showAll }))] }), jsx(Menu.Divider, {}), allColumns.map((column, index) => (jsx(MRT_ShowHideColumnsMenuItems, { allColumns: allColumns, column: column, hoveredColumn: hoveredColumn, setHoveredColumn: setHoveredColumn, table: table }, `${index}-${column.id}`)))] }));
+};
+
+const MRT_ShowHideColumnsButton = ({ table, title, ...rest }) => {
+    const { icons: { IconColumns }, localization: { showHideColumns }, } = table.options;
+    return (jsxs(Menu, { closeOnItemClick: false, withinPortal: true, children: [jsx(Tooltip, { label: title ?? showHideColumns, withinPortal: true, children: jsx(Menu.Target, { children: jsx(ActionIcon, { "aria-label": title ?? showHideColumns, color: "gray", size: "lg", variant: "subtle", ...rest, children: jsx(IconColumns, {}) }) }) }), jsx(MRT_ShowHideColumnsMenu, { table: table })] }));
+};
+
+const next = {
+    md: 'xs',
+    xl: 'md',
+    xs: 'xl',
+};
+const MRT_ToggleDensePaddingButton = ({ table: { state, options: { icons: { IconBaselineDensityLarge, IconBaselineDensityMedium, IconBaselineDensitySmall, }, localization: { toggleDensity }, }, setDensity, }, title, ...rest }) => {
+    const { density } = state;
+    return (jsx(Tooltip, { label: title ?? toggleDensity, withinPortal: true, children: jsx(ActionIcon, { "aria-label": title ?? toggleDensity, color: "gray", onClick: () => setDensity((current) => next[current]), size: "lg", variant: "subtle", ...rest, children: density === 'xs' ? (jsx(IconBaselineDensitySmall, {})) : density === 'md' ? (jsx(IconBaselineDensityMedium, {})) : (jsx(IconBaselineDensityLarge, {})) }) }));
+};
+
+const MRT_ToggleFiltersButton = ({ table: { state, options: { icons: { IconFilter, IconFilterOff }, localization: { showHideFilters }, }, setShowColumnFilters, }, title, ...rest }) => {
+    const { showColumnFilters } = state;
+    return (jsx(Tooltip, { label: title ?? showHideFilters, withinPortal: true, children: jsx(ActionIcon, { "aria-label": title ?? showHideFilters, color: "gray", onClick: () => setShowColumnFilters((current) => !current), size: "lg", variant: "subtle", ...rest, children: showColumnFilters ? jsx(IconFilterOff, {}) : jsx(IconFilter, {}) }) }));
+};
+
+const MRT_ToggleFullScreenButton = ({ table: { state, options: { icons: { IconMaximize, IconMinimize }, localization: { toggleFullScreen }, }, setIsFullScreen, }, title, ...rest }) => {
+    const { isFullScreen } = state;
+    const [tooltipOpened, setTooltipOpened] = useState(false);
+    const handleToggleFullScreen = () => {
+        setTooltipOpened(false);
+        setIsFullScreen((current) => !current);
+    };
+    return (jsx(Tooltip, { label: title ?? toggleFullScreen, opened: tooltipOpened, withinPortal: true, children: jsx(ActionIcon, { "aria-label": title ?? toggleFullScreen, color: "gray", onClick: handleToggleFullScreen, onMouseEnter: () => setTooltipOpened(true), onMouseLeave: () => setTooltipOpened(false), size: "lg", variant: "subtle", ...rest, children: isFullScreen ? jsx(IconMinimize, {}) : jsx(IconMaximize, {}) }) }));
+};
+
+const MRT_ToggleGlobalFilterButton = ({ table: { state, options: { icons: { IconSearch, IconSearchOff }, localization: { showHideSearch }, }, refs: { searchInputRef }, setShowGlobalFilter, }, title, ...rest }) => {
+    const { globalFilter, showGlobalFilter } = state;
+    const handleToggleSearch = () => {
+        setShowGlobalFilter(!showGlobalFilter);
+        setTimeout(() => searchInputRef.current?.focus(), 100);
+    };
+    return (jsx(Tooltip, { label: title ?? showHideSearch, withinPortal: true, children: jsx(ActionIcon, { "aria-label": title ?? showHideSearch, color: "gray", disabled: !!globalFilter, onClick: handleToggleSearch, size: "lg", variant: "subtle", ...rest, children: showGlobalFilter ? jsx(IconSearchOff, {}) : jsx(IconSearch, {}) }) }));
+};
+
+const MRT_RowActionMenu = ({ handleEdit, row, table, ...rest }) => {
+    const { options: { editDisplayMode, enableEditing, icons: { IconDots, IconEdit }, localization, positionActionsColumn, renderRowActionMenuItems, }, } = table;
+    return (jsxs(Menu, { closeOnItemClick: true, position: positionActionsColumn === 'first'
+            ? 'bottom-start'
+            : positionActionsColumn === 'last'
+                ? 'bottom-end'
+                : undefined, withinPortal: true, children: [jsx(Tooltip, { label: localization.rowActions, openDelay: 1000, withinPortal: true, children: jsx(Menu.Target, { children: jsx(ActionIcon, { "aria-label": localization.rowActions, color: "gray", onClick: (event) => event.stopPropagation(), size: "sm", variant: "subtle", ...rest, children: jsx(IconDots, {}) }) }) }), jsxs(Menu.Dropdown, { onClick: (event) => event.stopPropagation(), children: [enableEditing && editDisplayMode !== 'table' && (jsx(Menu.Item, { leftSection: jsx(IconEdit, {}), onClick: handleEdit, children: localization.edit })), renderRowActionMenuItems?.({
+                        row,
+                        table,
+                    })] })] }));
+};
+
+const MRT_ToggleRowActionMenuButton = ({ cell, row, table, }) => {
+    const { state, options: { createDisplayMode, editDisplayMode, enableEditing, icons: { IconEdit }, localization: { edit }, renderRowActionMenuItems, renderRowActions, }, setEditingRow, } = table;
+    const { creatingRow, editingRow } = state;
+    const isCreating = creatingRow?.id === row.id;
+    const isEditing = editingRow?.id === row.id;
+    const handleStartEditMode = (event) => {
+        event.stopPropagation();
+        setEditingRow(row);
+    };
+    const showEditActionButtons = (isCreating && createDisplayMode === 'row') ||
+        (isEditing && editDisplayMode === 'row');
+    return (jsx(Fragment, { children: renderRowActions && !showEditActionButtons ? (renderRowActions({ cell, row, table })) : showEditActionButtons ? (jsx(MRT_EditActionButtons, { row: row, table: table })) : !renderRowActionMenuItems &&
+            parseFromValuesOrFunc(enableEditing, row) ? (jsx(Tooltip, { label: edit, openDelay: 1000, position: "right", withinPortal: true, children: jsx(ActionIcon, { "aria-label": edit, color: "gray", disabled: !!editingRow && editingRow.id !== row.id, onClick: handleStartEditMode, size: "md", variant: "subtle", children: jsx(IconEdit, {}) }) })) : renderRowActionMenuItems ? (jsx(MRT_RowActionMenu, { handleEdit: handleStartEditMode, row: row, table: table })) : null }));
+};
+
+var classes$q = {"root":"MRT_TableFooterCell-module_root__d8Scs","grid":"MRT_TableFooterCell-module_grid__H9jLk","group":"MRT_TableFooterCell-module_group__l3-p-"};
+
+const MRT_TableFooterCell = ({ footer, renderedColumnIndex, table, ...rest }) => {
+    const direction = useDirection();
+    const { options: { enableColumnPinning, layoutMode, mantineTableFooterCellProps }, } = table;
+    const { column } = footer;
+    const { columnDef } = column;
+    const { columnDefType } = columnDef;
+    const isColumnPinned = enableColumnPinning &&
+        columnDef.columnDefType !== 'group' &&
+        column.getIsPinned();
+    const args = { column, table };
+    const tableCellProps = {
+        ...parseFromValuesOrFunc(mantineTableFooterCellProps, args),
+        ...parseFromValuesOrFunc(columnDef.mantineTableFooterCellProps, args),
+        ...rest,
+    };
+    const widthStyles = {
+        minWidth: `max(calc(var(--header-${parseCSSVarId(footer?.id)}-size) * 1px), ${columnDef.minSize ?? 30}px)`,
+        width: `calc(var(--header-${parseCSSVarId(footer.id)}-size) * 1px)`,
+    };
+    if (layoutMode === 'grid') {
+        widthStyles.flex = `${[0, false].includes(columnDef.grow)
+            ? 0
+            : `var(--header-${parseCSSVarId(footer.id)}-size)`} 0 auto`;
+    }
+    else if (layoutMode === 'grid-no-grow') {
+        widthStyles.flex = `${+(columnDef.grow || 0)} 0 auto`;
+    }
+    return (jsx(TableTh, { colSpan: footer.colSpan, "data-column-pinned": isColumnPinned || undefined, "data-first-end-pinned": (isColumnPinned === 'end' && column.getIsFirstColumn(isColumnPinned)) ||
+            undefined, "data-index": renderedColumnIndex, "data-last-start-pinned": (isColumnPinned === 'start' &&
+            column.getIsLastColumn(isColumnPinned)) ||
+            undefined, ...tableCellProps, __vars: {
+            '--mrt-cell-align': tableCellProps.align ??
+                (columnDefType === 'group'
+                    ? 'center'
+                    : direction.dir === 'rtl'
+                        ? 'right'
+                        : 'left'),
+            '--mrt-table-cell-start': isColumnPinned === 'start'
+                ? `${column.getStart(isColumnPinned)}`
+                : undefined,
+            '--mrt-table-cell-end': isColumnPinned === 'end'
+                ? `${column.getAfter(isColumnPinned)}`
+                : undefined,
+            ...tableCellProps?.__vars,
+        }, className: clsx(classes$q.root, layoutMode?.startsWith('grid') && classes$q.grid, columnDefType === 'group' && classes$q.group, tableCellProps?.className), style: (theme) => ({
+            ...widthStyles,
+            ...parseFromValuesOrFunc(tableCellProps.style, theme),
+        }), children: tableCellProps.children ??
+            (footer.isPlaceholder
+                ? null
+                : (parseFromValuesOrFunc(columnDef.Footer, {
+                    column,
+                    footer,
+                    table,
+                }) ??
+                    columnDef.footer ??
+                    null)) }));
+};
+
+var classes$p = {"root":"MRT_TableFooterRow-module_root__EuoPr","layout-mode-grid":"MRT_TableFooterRow-module_layout-mode-grid__dUEMF"};
+
+const MRT_TableFooterRow = ({ columnVirtualizer, footerGroup, table, ...rest }) => {
+    const { options: { layoutMode, mantineTableFooterRowProps }, } = table;
+    const { virtualColumns, virtualPaddingLeft, virtualPaddingRight } = columnVirtualizer ?? {};
+    // if no content in row, skip row
+    if (!footerGroup.headers?.some((header) => (typeof header.column.columnDef.footer === 'string' &&
+        !!header.column.columnDef.footer) ||
+        header.column.columnDef.Footer)) {
+        return null;
+    }
+    const tableRowProps = {
+        ...parseFromValuesOrFunc(mantineTableFooterRowProps, {
+            footerGroup,
+            table,
+        }),
+        ...rest,
+    };
+    return (jsxs(TableTr, { className: clsx(classes$p.root, layoutMode?.startsWith('grid') && classes$p['layout-mode-grid']), ...tableRowProps, children: [virtualPaddingLeft ? (jsx(Box, { component: "th", display: "flex", w: virtualPaddingLeft })) : null, (virtualColumns ?? footerGroup.headers).map((footerOrVirtualFooter, renderedColumnIndex) => {
+                let footer = footerOrVirtualFooter;
+                if (columnVirtualizer) {
+                    renderedColumnIndex = footerOrVirtualFooter
+                        .index;
+                    footer = footerGroup.headers[renderedColumnIndex];
+                }
+                return (jsx(MRT_TableFooterCell, { footer: footer, renderedColumnIndex: renderedColumnIndex, table: table }, footer.id));
+            }), virtualPaddingRight ? (jsx(Box, { component: "th", display: "flex", w: virtualPaddingRight })) : null] }));
+};
+
+var classes$o = {"root":"MRT_TableFooter-module_root__-JXpw","grid":"MRT_TableFooter-module_grid__J3Ga-","sticky":"MRT_TableFooter-module_sticky__GcoK6"};
+
+const MRT_TableFooter = ({ columnVirtualizer, table, ...rest }) => {
+    const { getFooterGroups, state, options: { enableStickyFooter, layoutMode, mantineTableFooterProps }, refs: { tableFooterRef }, } = table;
+    const { isFullScreen } = state;
+    const tableFooterProps = {
+        ...parseFromValuesOrFunc(mantineTableFooterProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const stickFooter = (isFullScreen || enableStickyFooter) && enableStickyFooter !== false;
+    return (jsx(TableTfoot, { ...tableFooterProps, className: clsx(classes$o.root, tableFooterProps?.className, stickFooter && classes$o.sticky, layoutMode?.startsWith('grid') && classes$o.grid), ref: (ref) => {
+            tableFooterRef.current = ref;
+            if (tableFooterProps?.ref) {
+                // @ts-ignore
+                tableFooterProps.ref.current = ref;
+            }
+        }, children: getFooterGroups().map((footerGroup) => (jsx(MRT_TableFooterRow, { columnVirtualizer: columnVirtualizer, footerGroup: footerGroup, table: table }, footerGroup.id))) }));
+};
+
+const MRT_SelectCheckbox = ({ renderedRowIndex = 0, row, table, ...rest }) => {
+    const { state, options: { enableMultiRowSelection, localization, mantineSelectAllCheckboxProps, mantineSelectCheckboxProps, selectAllMode, selectDisplayMode, }, } = table;
+    const { density, isLoading } = state;
+    const selectAll = !row;
+    const allRowsSelected = selectAll
+        ? selectAllMode === 'page'
+            ? table.getIsAllPageRowsSelected()
+            : table.getIsAllRowsSelected()
+        : undefined;
+    const isChecked = selectAll
+        ? allRowsSelected
+        : getIsRowSelected({ row, table });
+    const checkboxProps = {
+        ...(selectAll
+            ? parseFromValuesOrFunc(mantineSelectAllCheckboxProps, { table })
+            : parseFromValuesOrFunc(mantineSelectCheckboxProps, {
+                row,
+                table,
+            })),
+        ...rest,
+    };
+    const onSelectionChange = row
+        ? getMRT_RowSelectionHandler({
+            renderedRowIndex,
+            row,
+            table,
+        })
+        : undefined;
+    const onSelectAllChange = getMRT_SelectAllHandler({ table });
+    const commonProps = {
+        'aria-label': selectAll
+            ? localization.toggleSelectAll
+            : localization.toggleSelectRow,
+        checked: isChecked,
+        disabled: isLoading || (row && !row.getCanSelect()) || row?.id === 'mrt-row-create',
+        onChange: (event) => {
+            event.stopPropagation();
+            if (selectAll) {
+                onSelectAllChange(event);
+            }
+            else {
+                onSelectionChange(event);
+            }
+        },
+        size: density === 'xs' ? 'sm' : 'md',
+        ...checkboxProps,
+        onClick: (e) => {
+            e.stopPropagation();
+            checkboxProps?.onClick?.(e);
+        },
+        title: undefined,
+    };
+    return (jsx(Tooltip, { label: checkboxProps?.title ??
+            (selectAll
+                ? localization.toggleSelectAll
+                : localization.toggleSelectRow), openDelay: 1000, withinPortal: true, children: jsx("span", { children: selectDisplayMode === 'switch' ? (jsx(Switch, { ...commonProps })) : selectDisplayMode === 'radio' ||
+                enableMultiRowSelection === false ? (jsx(Radio, { ...commonProps })) : (jsx(Checkbox, { indeterminate: !isChecked && selectAll
+                    ? table.getIsSomeRowsSelected()
+                    : row?.getIsSomeSelected() && row.getCanSelectSubRows(), ...commonProps })) }) }));
+};
+
+var classes$n = {"alert":"MRT_ToolbarAlertBanner-module_alert__PAhUK","alert-stacked":"MRT_ToolbarAlertBanner-module_alert-stacked__HR7Nq","alert-bottom":"MRT_ToolbarAlertBanner-module_alert-bottom__u9L-S","alert-badge":"MRT_ToolbarAlertBanner-module_alert-badge__GwDmX","toolbar-alert":"MRT_ToolbarAlertBanner-module_toolbar-alert__3sJGU","head-overlay":"MRT_ToolbarAlertBanner-module_head-overlay__Hw7jK"};
+
+const MRT_ToolbarAlertBanner = ({ stackAlertBanner, table, ...rest }) => {
+    const { getFilteredSelectedRowModel, getPrePaginatedRowModel, state, options: { enableRowSelection, enableSelectAll, icons: { IconX }, localization, mantineToolbarAlertBannerBadgeProps, mantineToolbarAlertBannerProps, manualPagination, positionToolbarAlertBanner, renderToolbarAlertBannerContent, rowCount, }, } = table;
+    const { density, grouping, rowSelection, showAlertBanner } = state;
+    const alertProps = {
+        ...parseFromValuesOrFunc(mantineToolbarAlertBannerProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const badgeProps = parseFromValuesOrFunc(mantineToolbarAlertBannerBadgeProps, { table });
+    const totalRowCount = rowCount ?? getPrePaginatedRowModel().flatRows.length;
+    const selectedRowCount = useMemo(() => manualPagination
+        ? Object.values(rowSelection).filter(Boolean).length
+        : getFilteredSelectedRowModel().rows.length, [rowSelection, totalRowCount, manualPagination]);
+    const selectedAlert = selectedRowCount ? (jsxs(Flex, { align: "center", gap: "sm", children: [localization.selectedCountOfRowCountRowsSelected
+                ?.replace('{selectedCount}', selectedRowCount.toString())
+                ?.replace('{rowCount}', totalRowCount.toString()), jsx(Button, { onClick: (event) => getMRT_SelectAllHandler({ table })(event, false, true), size: "compact-xs", variant: "subtle", children: localization.clearSelection })] })) : null;
+    const groupedAlert = grouping.length > 0 ? (jsxs(Flex, { children: [localization.groupedBy, ' ', grouping.map((columnId, index) => (jsxs(Fragment$1, { children: [index > 0 ? localization.thenBy : '', jsxs(Badge, { className: classes$n['alert-badge'], rightSection: jsx(ActionIcon, { color: "white", onClick: () => table.getColumn(columnId).toggleGrouping(), size: "xs", variant: "subtle", children: jsx(IconX, { style: { transform: 'scale(0.8)' } }) }), variant: "filled", ...badgeProps, children: [table.getColumn(columnId).columnDef.header, ' '] })] }, `${index}-${columnId}`)))] })) : null;
+    return (jsx(Collapse, { expanded: showAlertBanner || !!selectedAlert || !!groupedAlert, transitionDuration: stackAlertBanner ? 200 : 0, children: jsx(Alert, { color: "blue", icon: false, ...alertProps, className: clsx(classes$n.alert, stackAlertBanner &&
+                !positionToolbarAlertBanner &&
+                classes$n['alert-stacked'], !stackAlertBanner &&
+                positionToolbarAlertBanner === 'bottom' &&
+                classes$n['alert-bottom'], alertProps?.className), children: renderToolbarAlertBannerContent?.({
+                groupedAlert,
+                selectedAlert,
+                table,
+            }) ?? (jsxs(Flex, { className: clsx(classes$n['toolbar-alert'], positionToolbarAlertBanner === 'head-overlay' &&
+                    classes$n['head-overlay'], density), children: [enableRowSelection &&
+                        enableSelectAll &&
+                        positionToolbarAlertBanner === 'head-overlay' && (jsx(MRT_SelectCheckbox, { table: table })), jsxs(Stack, { children: [alertProps?.children, selectedAlert, groupedAlert] })] })) }) }));
+};
+
+var classes$m = {"left":"MRT_ColumnActionMenu-module_left__cfNmY","right":"MRT_ColumnActionMenu-module_right__-nK56"};
+
+const MRT_ColumnActionMenu = ({ header, table, ...rest }) => {
+    const { state, options: { columnFilterDisplayMode, enableColumnFilters, enableColumnPinning, enableColumnResizing, enableGrouping, enableHiding, enableSorting, enableSortingRemoval, icons: { IconArrowAutofitContent, IconBoxMultiple, IconClearAll, IconColumns, IconDotsVertical, IconEyeOff, IconFilter, IconFilterOff, IconPinned, IconPinnedOff, IconSortAscending, IconSortDescending, }, localization, mantineColumnActionsButtonProps, renderColumnActionsMenuItems, }, refs: { filterInputRefs }, setColumnOrder, setColumnResizing, setShowColumnFilters, toggleAllColumnsVisible, } = table;
+    const { column } = header;
+    const { columnDef } = column;
+    const { columnSizing, columnVisibility } = state;
+    const arg = { column, table };
+    const actionIconProps = {
+        ...parseFromValuesOrFunc(mantineColumnActionsButtonProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineColumnActionsButtonProps, arg),
+    };
+    const handleClearSort = () => {
+        column.clearSorting();
+    };
+    const handleSortAsc = () => {
+        column.toggleSorting(false);
+    };
+    const handleSortDesc = () => {
+        column.toggleSorting(true);
+    };
+    const handleResetColumnSize = () => {
+        setColumnResizing((old) => ({ ...old, isResizingColumn: false }));
+        column.resetSize();
+    };
+    const handleHideColumn = () => {
+        column.toggleVisibility(false);
+    };
+    const handlePinColumn = (pinDirection) => {
+        column.pin(pinDirection);
+    };
+    const handleGroupByColumn = () => {
+        column.toggleGrouping();
+        setColumnOrder((old) => ['mrt-row-expand', ...old]);
+    };
+    const handleClearFilter = () => {
+        column.setFilterValue('');
+    };
+    const handleFilterByColumn = () => {
+        setShowColumnFilters(true);
+        setTimeout(() => filterInputRefs.current[`${column.id}-0`]?.focus(), 100);
+    };
+    const handleShowAllColumns = () => {
+        toggleAllColumnsVisible(true);
+    };
+    const internalColumnMenuItems = (jsxs(Fragment, { children: [enableSorting && column.getCanSort() && (jsxs(Fragment, { children: [enableSortingRemoval !== false && (jsx(Menu.Item, { disabled: !column.getIsSorted(), leftSection: jsx(IconClearAll, {}), onClick: handleClearSort, children: localization.clearSort })), jsx(Menu.Item, { disabled: column.getIsSorted() === 'asc', leftSection: jsx(IconSortAscending, {}), onClick: handleSortAsc, children: localization.sortByColumnAsc?.replace('{column}', String(columnDef.header)) }), jsx(Menu.Item, { disabled: column.getIsSorted() === 'desc', leftSection: jsx(IconSortDescending, {}), onClick: handleSortDesc, children: localization.sortByColumnDesc?.replace('{column}', String(columnDef.header)) }), (enableColumnFilters || enableGrouping || enableHiding) && (jsx(Menu.Divider, {}, 3))] })), enableColumnFilters &&
+                columnFilterDisplayMode !== 'popover' &&
+                column.getCanFilter() && (jsxs(Fragment, { children: [jsx(Menu.Item, { disabled: !column.getFilterValue(), leftSection: jsx(IconFilterOff, {}), onClick: handleClearFilter, children: localization.clearFilter }), jsx(Menu.Item, { leftSection: jsx(IconFilter, {}), onClick: handleFilterByColumn, children: localization.filterByColumn?.replace('{column}', String(columnDef.header)) }), (enableGrouping || enableHiding) && jsx(Menu.Divider, {}, 2)] })), enableGrouping && column.getCanGroup() && (jsxs(Fragment, { children: [jsx(Menu.Item, { leftSection: jsx(IconBoxMultiple, {}), onClick: handleGroupByColumn, children: localization[column.getIsGrouped() ? 'ungroupByColumn' : 'groupByColumn']?.replace('{column}', String(columnDef.header)) }), enableColumnPinning && jsx(Menu.Divider, {})] })), enableColumnPinning && column.getCanPin() && (jsxs(Fragment, { children: [jsx(Menu.Item, { disabled: column.getIsPinned() === 'start' || !column.getCanPin(), leftSection: jsx(IconPinned, { className: classes$m.left }), onClick: () => handlePinColumn('start'), children: localization.pinToLeft }), jsx(Menu.Item, { disabled: column.getIsPinned() === 'end' || !column.getCanPin(), leftSection: jsx(IconPinned, { className: classes$m.right }), onClick: () => handlePinColumn('end'), children: localization.pinToRight }), jsx(Menu.Item, { disabled: !column.getIsPinned(), leftSection: jsx(IconPinnedOff, {}), onClick: () => handlePinColumn(false), children: localization.unpin }), enableHiding && jsx(Menu.Divider, {})] })), enableColumnResizing && column.getCanResize() && (jsx(Menu.Item, { disabled: !columnSizing[column.id], leftSection: jsx(IconArrowAutofitContent, {}), onClick: handleResetColumnSize, children: localization.resetColumnSize }, 0)), enableHiding && (jsxs(Fragment, { children: [jsx(Menu.Item, { disabled: !column.getCanHide(), leftSection: jsx(IconEyeOff, {}), onClick: handleHideColumn, children: localization.hideColumn?.replace('{column}', String(columnDef.header)) }, 0), jsx(Menu.Item, { disabled: !Object.values(columnVisibility).filter((visible) => !visible)
+                            .length, leftSection: jsx(IconColumns, {}), onClick: handleShowAllColumns, children: localization.showAllColumns?.replace('{column}', String(columnDef.header)) }, 1)] }))] }));
+    return (jsxs(Menu, { closeOnItemClick: true, position: "bottom-start", withinPortal: true, ...rest, children: [jsx(Tooltip, { label: actionIconProps?.title ?? localization.columnActions, openDelay: 1000, withinPortal: true, children: jsx(Menu.Target, { children: jsx(ActionIcon, { "aria-label": localization.columnActions, color: "gray", size: "sm", variant: "subtle", ...actionIconProps, children: jsx(IconDotsVertical, { size: "100%" }) }) }) }), jsx(Menu.Dropdown, { children: columnDef.renderColumnActionsMenuItems?.({
+                    column,
+                    internalColumnMenuItems,
+                    table,
+                }) ??
+                    renderColumnActionsMenuItems?.({
+                        column,
+                        internalColumnMenuItems,
+                        table,
+                    }) ??
+                    internalColumnMenuItems })] }));
+};
+
+const fuzzy = (row, columnId, filterValue, addMeta) => {
+    const itemRank = rankItem(row.getValue(columnId), filterValue, {
+        threshold: rankings.MATCHES,
+    });
+    addMeta(itemRank);
+    return itemRank.passed;
+};
+fuzzy.autoRemove = (val) => !val;
+const contains = (row, id, filterValue) => row
+    .getValue(id)
+    ?.toString()
+    .toLowerCase()
+    .trim()
+    .includes(filterValue.toString().toLowerCase().trim());
+contains.autoRemove = (val) => !val;
+const startsWith = (row, id, filterValue) => row
+    .getValue(id)
+    ?.toString()
+    .toLowerCase()
+    .trim()
+    .startsWith(filterValue.toString().toLowerCase().trim());
+startsWith.autoRemove = (val) => !val;
+const endsWith = (row, id, filterValue) => row
+    .getValue(id)
+    ?.toString()
+    .toLowerCase()
+    .trim()
+    .endsWith(filterValue.toString().toLowerCase().trim());
+endsWith.autoRemove = (val) => !val;
+const equals = (row, id, filterValue) => row.getValue(id)?.toString().toLowerCase().trim() ===
+    filterValue?.toString().toLowerCase().trim();
+equals.autoRemove = (val) => !val;
+const notEquals = (row, id, filterValue) => row.getValue(id)?.toString().toLowerCase().trim() !==
+    filterValue.toString().toLowerCase().trim();
+notEquals.autoRemove = (val) => !val;
+const greaterThan = (row, id, filterValue) => !isNaN(+filterValue) && !isNaN(+row.getValue(id))
+    ? +row.getValue(id) > +filterValue
+    : row.getValue(id)?.toString().toLowerCase().trim() >
+        filterValue?.toString().toLowerCase().trim();
+greaterThan.autoRemove = (val) => !val;
+const greaterThanOrEqualTo = (row, id, filterValue) => equals(row, id, filterValue) || greaterThan(row, id, filterValue);
+greaterThanOrEqualTo.autoRemove = (val) => !val;
+const lessThan = (row, id, filterValue) => !isNaN(+filterValue) && !isNaN(+row.getValue(id))
+    ? +row.getValue(id) < +filterValue
+    : row.getValue(id)?.toString().toLowerCase().trim() <
+        filterValue?.toString().toLowerCase().trim();
+lessThan.autoRemove = (val) => !val;
+const lessThanOrEqualTo = (row, id, filterValue) => equals(row, id, filterValue) || lessThan(row, id, filterValue);
+lessThanOrEqualTo.autoRemove = (val) => !val;
+const between = (row, id, filterValues) => (['', undefined].includes(filterValues[0]) ||
+    greaterThan(row, id, filterValues[0])) &&
+    ((!isNaN(+filterValues[0]) &&
+        !isNaN(+filterValues[1]) &&
+        +filterValues[0] > +filterValues[1]) ||
+        ['', undefined].includes(filterValues[1]) ||
+        lessThan(row, id, filterValues[1]));
+between.autoRemove = (val) => !val;
+const betweenInclusive = (row, id, filterValues) => (['', undefined].includes(filterValues[0]) ||
+    greaterThanOrEqualTo(row, id, filterValues[0])) &&
+    ((!isNaN(+filterValues[0]) &&
+        !isNaN(+filterValues[1]) &&
+        +filterValues[0] > +filterValues[1]) ||
+        ['', undefined].includes(filterValues[1]) ||
+        lessThanOrEqualTo(row, id, filterValues[1]));
+betweenInclusive.autoRemove = (val) => !val;
+const empty = (row, id, _filterValue) => !row.getValue(id)?.toString().trim();
+empty.autoRemove = (val) => !val;
+const notEmpty = (row, id, _filterValue) => !!row.getValue(id)?.toString().trim();
+notEmpty.autoRemove = (val) => !val;
+const MRT_FilterFns = {
+    ...filterFns,
+    between,
+    betweenInclusive,
+    contains,
+    empty,
+    endsWith,
+    equals,
+    fuzzy,
+    greaterThan,
+    greaterThanOrEqualTo,
+    lessThan,
+    lessThanOrEqualTo,
+    notEmpty,
+    notEquals,
+    startsWith,
+};
+function localizedFilterOption(localization, option) {
+    if (!option) {
+        return '';
+    }
+    const key = `filter${option[0].toUpperCase()}${option.slice(1)}`;
+    return localization[key] ?? '';
+}
+
+var classes$l = {"root":"MRT_FilterCheckBox-module_root__59h9r"};
+
+const MRT_FilterCheckbox = ({ column, table, ...rest }) => {
+    const { state, options: { localization, mantineFilterCheckboxProps }, } = table;
+    const { density } = state;
+    const { columnDef } = column;
+    const arg = { column, table };
+    const checkboxProps = {
+        ...parseFromValuesOrFunc(mantineFilterCheckboxProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterCheckboxProps, arg),
+        ...rest,
+    };
+    const filterLabel = localization.filterByColumn?.replace('{column}', columnDef.header);
+    const value = column.getFilterValue();
+    return (jsx(Tooltip, { label: checkboxProps?.title ?? filterLabel, openDelay: 1000, withinPortal: true, children: jsx(Checkbox, { checked: value === 'true', className: clsx('mrt-filter-checkbox', classes$l.root), indeterminate: value === undefined, label: checkboxProps.title ?? filterLabel, size: density === 'xs' ? 'sm' : 'md', ...checkboxProps, onChange: (e) => {
+                column.setFilterValue(column.getFilterValue() === undefined
+                    ? 'true'
+                    : column.getFilterValue() === 'true'
+                        ? 'false'
+                        : undefined);
+                checkboxProps?.onChange?.(e);
+            }, onClick: (e) => {
+                e.stopPropagation();
+                checkboxProps?.onClick?.(e);
+            }, title: undefined }) }));
+};
+
+var classes$k = {"root":"MRT_FilterRangeFields-module_root__KfCcg"};
+
+var classes$j = {"root":"MRT_FilterTextInput-module_root__Ss8Ql","date-filter":"MRT_FilterTextInput-module_date-filter__jOBLB","range-filter":"MRT_FilterTextInput-module_range-filter__JQHAL","not-filter-chip":"MRT_FilterTextInput-module_not-filter-chip__u8b1y","filter-chip-badge":"MRT_FilterTextInput-module_filter-chip-badge__Sel2k"};
+
+const MRT_FilterTextInput = ({ header, rangeFilterIndex, table, ...rest }) => {
+    const { options: { columnFilterDisplayMode, columnFilterModeOptions, icons: { IconX }, localization, mantineFilterAutocompleteProps, mantineFilterDateInputProps, mantineFilterMultiSelectProps = {
+        clearable: true,
+    }, mantineFilterSelectProps, mantineFilterTextInputProps, manualFiltering, }, refs: { filterInputRefs }, setColumnFilterFns, } = table;
+    const { column } = header;
+    const { columnDef } = column;
+    const arg = { column, rangeFilterIndex, table };
+    const textInputProps = {
+        ...parseFromValuesOrFunc(mantineFilterTextInputProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterTextInputProps, arg),
+        ...rest,
+    };
+    const selectProps = {
+        ...parseFromValuesOrFunc(mantineFilterSelectProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterSelectProps, arg),
+    };
+    const multiSelectProps = {
+        ...parseFromValuesOrFunc(mantineFilterMultiSelectProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterMultiSelectProps, arg),
+    };
+    const dateInputProps = {
+        ...parseFromValuesOrFunc(mantineFilterDateInputProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterDateInputProps, arg),
+    };
+    const autoCompleteProps = {
+        ...parseFromValuesOrFunc(mantineFilterAutocompleteProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterAutocompleteProps, arg),
+    };
+    const isRangeFilter = columnDef.filterVariant === 'range' ||
+        columnDef.filterVariant === 'date-range' ||
+        rangeFilterIndex !== undefined;
+    const isSelectFilter = columnDef.filterVariant === 'select';
+    const isMultiSelectFilter = columnDef.filterVariant === 'multi-select';
+    const isDateFilter = columnDef.filterVariant === 'date' ||
+        columnDef.filterVariant === 'date-range';
+    const isAutoCompleteFilter = columnDef.filterVariant === 'autocomplete';
+    const allowedColumnFilterOptions = columnDef?.columnFilterModeOptions ?? columnFilterModeOptions;
+    const currentFilterOption = columnDef._filterFn;
+    const filterChipLabel = ['empty', 'notEmpty'].includes(currentFilterOption)
+        ? localizedFilterOption(localization, currentFilterOption)
+        : '';
+    const filterPlaceholder = !isRangeFilter
+        ? (textInputProps?.placeholder ??
+            localization.filterByColumn?.replace('{column}', String(columnDef.header)))
+        : rangeFilterIndex === 0
+            ? localization.min
+            : rangeFilterIndex === 1
+                ? localization.max
+                : '';
+    const facetedUniqueValues = column.getFacetedUniqueValues();
+    const filterSelectOptions = useMemo(() => (autoCompleteProps?.data ??
+        selectProps?.data ??
+        multiSelectProps?.data ??
+        ((isAutoCompleteFilter || isSelectFilter || isMultiSelectFilter) &&
+            facetedUniqueValues
+            ? Array.from(facetedUniqueValues.keys())
+                .filter((key) => key !== null)
+                .sort((a, b) => a.localeCompare(b))
+            : []))
+        // @ts-ignore
+        .filter((o) => o !== undefined && o !== null), [
+        autoCompleteProps?.data,
+        facetedUniqueValues,
+        isAutoCompleteFilter,
+        isMultiSelectFilter,
+        isSelectFilter,
+        multiSelectProps?.data,
+        selectProps?.data,
+    ]);
+    const isMounted = useRef(false);
+    const [filterValue, setFilterValue] = useState(() => isMultiSelectFilter
+        ? column.getFilterValue() || []
+        : isRangeFilter
+            ? column.getFilterValue()?.[rangeFilterIndex] || ''
+            : (column.getFilterValue() ?? ''));
+    const [debouncedFilterValue] = useDebouncedValue(filterValue, manualFiltering ? 400 : 200);
+    // send debounced filterValue to table instance
+    useEffect(() => {
+        if (!isMounted.current)
+            return;
+        if (isRangeFilter) {
+            column.setFilterValue((old) => {
+                const newFilterValues = Array.isArray(old) ? old : ['', ''];
+                newFilterValues[rangeFilterIndex] =
+                    debouncedFilterValue;
+                return newFilterValues;
+            });
+        }
+        else {
+            column.setFilterValue(debouncedFilterValue ?? undefined);
+        }
+    }, [debouncedFilterValue]);
+    // receive table filter value and set it to local state
+    useEffect(() => {
+        if (!isMounted.current) {
+            isMounted.current = true;
+            return;
+        }
+        const tableFilterValue = column.getFilterValue();
+        if (tableFilterValue === undefined) {
+            handleClear();
+        }
+        else if (isRangeFilter && rangeFilterIndex !== undefined) {
+            setFilterValue((tableFilterValue ?? ['', ''])[rangeFilterIndex]);
+        }
+        else {
+            setFilterValue(tableFilterValue ?? '');
+        }
+    }, [column.getFilterValue()]);
+    const handleClear = () => {
+        if (isMultiSelectFilter) {
+            setFilterValue([]);
+            column.setFilterValue([]);
+        }
+        else if (isRangeFilter) {
+            setFilterValue('');
+            column.setFilterValue((old) => {
+                const newFilterValues = Array.isArray(old) ? old : ['', ''];
+                newFilterValues[rangeFilterIndex] = undefined;
+                return newFilterValues;
+            });
+            // This is from Mantine v6 but it also applies for v7
+            // https://github.com/mantinedev/mantine/issues/4716#issuecomment-1702699688
+        }
+        else if (isSelectFilter) {
+            setFilterValue(null);
+            column.setFilterValue(null);
+        }
+        else {
+            setFilterValue('');
+            column.setFilterValue(undefined);
+        }
+    };
+    const handleClearEmptyFilterChip = () => {
+        if (isMultiSelectFilter) {
+            setFilterValue([]);
+            column.setFilterValue([]);
+        }
+        else {
+            setFilterValue('');
+            column.setFilterValue(undefined);
+        }
+        setColumnFilterFns((prev) => ({
+            ...prev,
+            [header.id]: allowedColumnFilterOptions?.[0] ?? 'fuzzy',
+        }));
+    };
+    const { className, ...commonProps } = {
+        'aria-label': filterPlaceholder,
+        className: clsx('mrt-filter-text-input', classes$j.root, isDateFilter
+            ? classes$j['date-filter']
+            : isRangeFilter
+                ? classes$j['range-filter']
+                : !filterChipLabel && classes$j['not-filter-chip']),
+        disabled: !!filterChipLabel,
+        onChange: setFilterValue,
+        onClick: (event) => event.stopPropagation(),
+        placeholder: filterPlaceholder,
+        style: {
+            ...(isMultiSelectFilter
+                ? multiSelectProps?.style
+                : isSelectFilter
+                    ? selectProps?.style
+                    : isDateFilter
+                        ? dateInputProps?.style
+                        : textInputProps?.style),
+        },
+        title: filterPlaceholder,
+        value: isMultiSelectFilter && !Array.isArray(filterValue) ? [] : filterValue,
+        variant: 'unstyled',
+    };
+    const ClearButton = filterValue ? (jsx(ActionIcon, { "aria-label": localization.clearFilter, color: "var(--mantine-color-gray-7)", onClick: handleClear, size: "sm", title: localization.clearFilter ?? '', variant: "transparent", children: jsx(IconX, {}) })) : null;
+    if (columnDef.Filter) {
+        return (jsx(Fragment, { children: columnDef.Filter?.({ column, header, rangeFilterIndex, table }) }));
+    }
+    if (filterChipLabel) {
+        return (jsx(Box, { style: commonProps.style, children: jsx(Badge, { className: classes$j['filter-chip-badge'], onClick: handleClearEmptyFilterChip, rightSection: ClearButton, size: "lg", children: filterChipLabel }) }));
+    }
+    if (isMultiSelectFilter) {
+        return (jsx(MultiSelect, { ...commonProps, searchable: true, ...multiSelectProps, className: clsx(className, multiSelectProps.className), data: filterSelectOptions, onChange: (value) => setFilterValue(value), ref: (node) => {
+                if (node) {
+                    filterInputRefs.current[`${column.id}-${rangeFilterIndex ?? 0}`] =
+                        node;
+                    if (multiSelectProps.ref) {
+                        multiSelectProps.ref.current = node;
+                    }
+                }
+            }, rightSection: filterValue?.toString()?.length && multiSelectProps?.clearable
+                ? ClearButton
+                : undefined, style: commonProps.style }));
+    }
+    if (isSelectFilter) {
+        return (jsx(Select, { ...commonProps, clearable: true, searchable: true, ...selectProps, className: clsx(className, selectProps.className), clearButtonProps: {
+                size: 'md',
+            }, data: filterSelectOptions, ref: (node) => {
+                if (node) {
+                    filterInputRefs.current[`${column.id}-${rangeFilterIndex ?? 0}`] =
+                        node;
+                    if (selectProps.ref) {
+                        selectProps.ref.current = node;
+                    }
+                }
+            }, style: commonProps.style }));
+    }
+    if (isDateFilter) {
+        return (jsx(DateInput, { ...commonProps, allowDeselect: true, clearable: true, popoverProps: { withinPortal: columnFilterDisplayMode !== 'popover' }, ...dateInputProps, className: clsx(className, dateInputProps.className), onChange: (event) => commonProps.onChange(event === null ? '' : event), ref: (node) => {
+                if (node) {
+                    filterInputRefs.current[`${column.id}-${rangeFilterIndex ?? 0}`] =
+                        node;
+                    if (dateInputProps.ref) {
+                        dateInputProps.ref.current = node;
+                    }
+                }
+            }, style: commonProps.style }));
+    }
+    if (isAutoCompleteFilter) {
+        return (jsx(Autocomplete, { ...commonProps, onChange: (value) => setFilterValue(value), rightSection: filterValue?.toString()?.length ? ClearButton : undefined, ...autoCompleteProps, className: clsx(className, autoCompleteProps.className), data: filterSelectOptions, ref: (node) => {
+                if (node) {
+                    filterInputRefs.current[`${column.id}-${rangeFilterIndex ?? 0}`] =
+                        node;
+                    if (autoCompleteProps.ref) {
+                        autoCompleteProps.ref.current = node;
+                    }
+                }
+            }, style: commonProps.style }));
+    }
+    return (jsx(TextInput, { ...commonProps, onChange: (e) => setFilterValue(e.target.value), rightSection: filterValue?.toString()?.length ? ClearButton : undefined, ...textInputProps, className: clsx(className, textInputProps.className), mt: 0, ref: (node) => {
+            if (node) {
+                filterInputRefs.current[`${column.id}-${rangeFilterIndex ?? 0}`] =
+                    node;
+                if (textInputProps.ref && typeof textInputProps.ref === 'object') {
+                    textInputProps.ref.current = node;
+                }
+            }
+        }, style: commonProps.style }));
+};
+
+const MRT_FilterRangeFields = ({ header, table, ...rest }) => {
+    return (jsxs(Box, { ...rest, className: clsx('mrt-filter-range-fields', classes$k.root, rest.className), children: [jsx(MRT_FilterTextInput, { header: header, rangeFilterIndex: 0, table: table }), jsx(MRT_FilterTextInput, { header: header, rangeFilterIndex: 1, table: table })] }));
+};
+
+var classes$i = {"root":"MRT_FilterRangeSlider-module_root__uwYEk"};
+
+const MRT_FilterRangeSlider = ({ header, table, ...rest }) => {
+    const { options: { mantineFilterRangeSliderProps }, refs: { filterInputRefs }, } = table;
+    const { column } = header;
+    const { columnDef } = column;
+    const arg = { column, table };
+    const rangeSliderProps = {
+        ...parseFromValuesOrFunc(mantineFilterRangeSliderProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineFilterRangeSliderProps, arg),
+        ...rest,
+    };
+    let [min, max] = rangeSliderProps.min !== undefined && rangeSliderProps.max !== undefined
+        ? [rangeSliderProps.min, rangeSliderProps.max]
+        : (column.getFacetedMinMaxValues() ?? [0, 1]);
+    // fix potential TanStack Table bugs where min or max is an array
+    if (Array.isArray(min))
+        min = min[0];
+    if (Array.isArray(max))
+        max = max[0];
+    if (min === null)
+        min = 0;
+    if (max === null)
+        max = 1;
+    const [filterValues, setFilterValues] = useState([min, max]);
+    const columnFilterValue = column.getFilterValue();
+    const isMounted = useRef(false);
+    useEffect(() => {
+        if (isMounted.current) {
+            if (columnFilterValue === undefined) {
+                setFilterValues([min, max]);
+            }
+            else if (Array.isArray(columnFilterValue)) {
+                setFilterValues(columnFilterValue);
+            }
+        }
+        isMounted.current = true;
+    }, [columnFilterValue, min, max]);
+    return (jsx(RangeSlider, { className: clsx('mrt-filter-range-slider', classes$i.root), max: max, min: min, onChange: (values) => {
+            setFilterValues(values);
+        }, onChangeEnd: (values) => {
+            if (Array.isArray(values)) {
+                if (values[0] <= min && values[1] >= max) {
+                    // if the user has selected the entire range, remove the filter
+                    column.setFilterValue(undefined);
+                }
+                else {
+                    column.setFilterValue(values);
+                }
+            }
+        }, value: filterValues, ...rangeSliderProps, ref: (node) => {
+            if (node) {
+                // @ts-ignore
+                filterInputRefs.current[`${column.id}-0`] = node;
+                // @ts-ignore
+                if (rangeSliderProps?.ref) {
+                    // @ts-ignore
+                    rangeSliderProps.ref = node;
+                }
+            }
+        } }));
+};
+
+var classes$h = {"symbol":"MRT_FilterOptionMenu-module_symbol__a1Bsy"};
+
+const mrtFilterOptions = (localization) => [
+    {
+        divider: false,
+        label: localization.filterFuzzy,
+        option: 'fuzzy',
+        symbol: '≈',
+    },
+    {
+        divider: false,
+        label: localization.filterContains,
+        option: 'contains',
+        symbol: '*',
+    },
+    {
+        divider: false,
+        label: localization.filterStartsWith,
+        option: 'startsWith',
+        symbol: 'a',
+    },
+    {
+        divider: true,
+        label: localization.filterEndsWith,
+        option: 'endsWith',
+        symbol: 'z',
+    },
+    {
+        divider: false,
+        label: localization.filterEquals,
+        option: 'equals',
+        symbol: '=',
+    },
+    {
+        divider: true,
+        label: localization.filterNotEquals,
+        option: 'notEquals',
+        symbol: '≠',
+    },
+    {
+        divider: false,
+        label: localization.filterBetween,
+        option: 'between',
+        symbol: '⇿',
+    },
+    {
+        divider: true,
+        label: localization.filterBetweenInclusive,
+        option: 'betweenInclusive',
+        symbol: '⬌',
+    },
+    {
+        divider: false,
+        label: localization.filterGreaterThan,
+        option: 'greaterThan',
+        symbol: '>',
+    },
+    {
+        divider: false,
+        label: localization.filterGreaterThanOrEqualTo,
+        option: 'greaterThanOrEqualTo',
+        symbol: '≥',
+    },
+    {
+        divider: false,
+        label: localization.filterLessThan,
+        option: 'lessThan',
+        symbol: '<',
+    },
+    {
+        divider: true,
+        label: localization.filterLessThanOrEqualTo,
+        option: 'lessThanOrEqualTo',
+        symbol: '≤',
+    },
+    {
+        divider: false,
+        label: localization.filterEmpty,
+        option: 'empty',
+        symbol: '∅',
+    },
+    {
+        divider: false,
+        label: localization.filterNotEmpty,
+        option: 'notEmpty',
+        symbol: '!∅',
+    },
+];
+const rangeModes = ['between', 'betweenInclusive', 'inNumberRange'];
+const emptyModes = ['empty', 'notEmpty'];
+const arrModes = ['arrIncludesSome', 'arrIncludesAll', 'arrIncludes'];
+const rangeVariants = ['range-slider', 'date-range', 'range'];
+const MRT_FilterOptionMenu = ({ header, onSelect, table, }) => {
+    const { state, options: { columnFilterModeOptions, globalFilterModeOptions, localization, renderColumnFilterModeMenuItems, renderGlobalFilterModeMenuItems, }, setColumnFilterFns, setGlobalFilterFn, } = table;
+    const { globalFilterFn } = state;
+    const { column } = header ?? {};
+    const { columnDef } = column ?? {};
+    const currentFilterValue = column?.getFilterValue();
+    let allowedColumnFilterOptions = columnDef?.columnFilterModeOptions ?? columnFilterModeOptions;
+    if (rangeVariants.includes(columnDef?.filterVariant)) {
+        allowedColumnFilterOptions = [
+            ...rangeModes,
+            ...(allowedColumnFilterOptions ?? []),
+        ].filter((option) => rangeModes.includes(option));
+    }
+    const internalFilterOptions = useMemo(() => {
+        const filterOptions = mrtFilterOptions(localization).filter((filterOption) => columnDef
+            ? allowedColumnFilterOptions === undefined ||
+                allowedColumnFilterOptions?.includes(filterOption.option)
+            : (!globalFilterModeOptions ||
+                globalFilterModeOptions.includes(filterOption.option)) &&
+                ['contains', 'fuzzy', 'startsWith'].includes(filterOption.option));
+        if (filterOptions[filterOptions.length - 1].divider) {
+            filterOptions[filterOptions.length - 1].divider = false;
+        }
+        return filterOptions;
+    }, [columnDef, globalFilterModeOptions]);
+    const handleSelectFilterMode = (option) => {
+        const prevFilterMode = columnDef?._filterFn ?? '';
+        if (!header || !column) {
+            // global filter mode
+            setGlobalFilterFn(option);
+        }
+        else if (option !== prevFilterMode) {
+            // column filter mode
+            setColumnFilterFns((prev) => ({
+                ...prev,
+                [header.id]: option,
+            }));
+            // reset filter value and/or perform new filter render
+            if (emptyModes.includes(option)) {
+                // will now be empty/notEmpty filter mode
+                if (currentFilterValue !== ' ' &&
+                    !emptyModes.includes(prevFilterMode)) {
+                    column.setFilterValue(' ');
+                }
+                else if (currentFilterValue) {
+                    column.setFilterValue(currentFilterValue); // perform new filter render
+                }
+            }
+            else if (columnDef?.filterVariant === 'multi-select' ||
+                arrModes.includes(option)) {
+                // will now be array filter mode
+                if (currentFilterValue instanceof String ||
+                    currentFilterValue?.length) {
+                    column.setFilterValue([]);
+                }
+                else if (currentFilterValue) {
+                    column.setFilterValue(currentFilterValue); // perform new filter render
+                }
+            }
+            else if (rangeVariants.includes(columnDef?.filterVariant) ||
+                rangeModes.includes(option)) {
+                // will now be range filter mode
+                if (!Array.isArray(currentFilterValue) ||
+                    (!currentFilterValue?.every((v) => v === '') &&
+                        !rangeModes.includes(prevFilterMode))) {
+                    column.setFilterValue(['', '']);
+                }
+                else {
+                    column.setFilterValue(currentFilterValue); // perform new filter render
+                }
+            }
+            else {
+                // will now be single value filter mode
+                if (Array.isArray(currentFilterValue)) {
+                    column.setFilterValue('');
+                }
+                else if (currentFilterValue === ' ' &&
+                    emptyModes.includes(prevFilterMode)) {
+                    column.setFilterValue(undefined);
+                }
+                else {
+                    column.setFilterValue(currentFilterValue); // perform new filter render
+                }
+            }
+        }
+        onSelect?.();
+    };
+    const filterOption = !!header && columnDef ? columnDef._filterFn : globalFilterFn;
+    return (jsx(Menu.Dropdown, { children: (header && column && columnDef
+            ? (columnDef.renderColumnFilterModeMenuItems?.({
+                column: column,
+                internalFilterOptions,
+                onSelectFilterMode: handleSelectFilterMode,
+                table,
+            }) ??
+                renderColumnFilterModeMenuItems?.({
+                    column: column,
+                    internalFilterOptions,
+                    onSelectFilterMode: handleSelectFilterMode,
+                    table,
+                }))
+            : renderGlobalFilterModeMenuItems?.({
+                internalFilterOptions,
+                onSelectFilterMode: handleSelectFilterMode,
+                table,
+            })) ??
+            internalFilterOptions.map(({ divider, label, option, symbol }, index) => (jsxs(Fragment$1, { children: [jsx(Menu.Item, { color: option === filterOption ? 'blue' : undefined, leftSection: jsx("span", { className: classes$h.symbol, children: symbol }), onClick: () => handleSelectFilterMode(option), value: option, children: label }), divider && jsx(Menu.Divider, {})] }, index))) }));
+};
+
+var classes$g = {"filter-mode-label":"MRT_TableHeadCellFilterContainer-module_filter-mode-label__8reK-"};
+
+const MRT_TableHeadCellFilterContainer = ({ header, table, ...rest }) => {
+    const { state, options: { columnFilterDisplayMode, columnFilterModeOptions, enableColumnFilterModes, icons: { IconFilterCog }, localization, }, refs: { filterInputRefs }, } = table;
+    const { showColumnFilters } = state;
+    const { column } = header;
+    const { columnDef } = column;
+    const currentFilterOption = columnDef._filterFn;
+    const allowedColumnFilterOptions = columnDef?.columnFilterModeOptions ?? columnFilterModeOptions;
+    const showChangeModeButton = enableColumnFilterModes &&
+        columnDef.enableColumnFilterModes !== false &&
+        (allowedColumnFilterOptions === undefined ||
+            !!allowedColumnFilterOptions?.length);
+    return (jsx(Collapse, { expanded: showColumnFilters || columnFilterDisplayMode === 'popover', children: jsxs(Flex, { direction: "column", ...rest, children: [jsxs(Flex, { align: "flex-end", children: [columnDef.filterVariant === 'checkbox' ? (jsx(MRT_FilterCheckbox, { column: column, table: table })) : columnDef.filterVariant === 'range-slider' ? (jsx(MRT_FilterRangeSlider, { header: header, table: table })) : ['date-range', 'range'].includes(columnDef.filterVariant ?? '') ||
+                            ['between', 'betweenInclusive', 'inNumberRange'].includes(columnDef._filterFn) ? (jsx(MRT_FilterRangeFields, { header: header, table: table })) : (jsx(MRT_FilterTextInput, { header: header, table: table })), showChangeModeButton && (jsxs(Menu, { withinPortal: columnFilterDisplayMode !== 'popover', children: [jsx(Tooltip, { label: localization.changeFilterMode, position: "bottom-start", withinPortal: true, children: jsx(Menu.Target, { children: jsx(ActionIcon, { "aria-label": localization.changeFilterMode, color: "gray", size: "md", variant: "subtle", children: jsx(IconFilterCog, {}) }) }) }), jsx(MRT_FilterOptionMenu, { header: header, onSelect: () => setTimeout(() => filterInputRefs.current[`${column.id}-0`]?.focus(), 100), table: table })] }))] }), showChangeModeButton ? (jsx(Text, { c: "dimmed", className: classes$g['filter-mode-label'], component: "label", children: localization.filterMode.replace('{filterType}', localizedFilterOption(localization, currentFilterOption)) })) : null] }) }));
+};
+
+var classes$f = {"root":"MRT_TableHeadCellFilterLabel-module_root__Rur2R"};
+
+const MRT_TableHeadCellFilterLabel = ({ header, table, ...rest }) => {
+    const { options: { columnFilterDisplayMode, icons: { IconFilter }, localization, }, refs: { filterInputRefs }, setShowColumnFilters, } = table;
+    const { column } = header;
+    const { columnDef } = column;
+    const filterValue = column.getFilterValue();
+    const [popoverOpened, setPopoverOpened] = useState(false);
+    const isFilterActive = (Array.isArray(filterValue) && filterValue.some(Boolean)) ||
+        (!!filterValue && !Array.isArray(filterValue));
+    const isRangeFilter = columnDef.filterVariant === 'range' ||
+        columnDef.filterVariant === 'date-range' ||
+        ['between', 'betweenInclusive', 'inNumberRange'].includes(columnDef._filterFn);
+    const currentFilterOption = columnDef._filterFn;
+    const filterValueFn = columnDef.filterTooltipValueFn || ((value) => value);
+    const filterTooltip = columnFilterDisplayMode === 'popover' && !isFilterActive
+        ? localization.filterByColumn?.replace('{column}', String(columnDef.header))
+        : localization.filteringByColumn
+            .replace('{column}', String(columnDef.header))
+            .replace('{filterType}', localizedFilterOption(localization, currentFilterOption))
+            .replace('{filterValue}', `"${Array.isArray(column.getFilterValue())
+            ? column.getFilterValue()
+                .map((v) => filterValueFn(v))
+                .join(`" ${isRangeFilter ? localization.and : localization.or} "`)
+            : filterValueFn(column.getFilterValue())}"`)
+            .replace('" "', '');
+    return (jsx(Fragment, { children: jsxs(Popover, { keepMounted: columnDef.filterVariant === 'range-slider', onChange: setPopoverOpened, onClose: () => setPopoverOpened(false), opened: popoverOpened, position: "top", shadow: "xl", width: 360, withinPortal: true, children: [jsx(Transition, { mounted: columnFilterDisplayMode === 'popover' ||
+                        (!!column.getFilterValue() && !isRangeFilter) ||
+                        (isRangeFilter &&
+                            (!!column.getFilterValue()?.[0] ||
+                                !!column.getFilterValue()?.[1])), transition: "scale", children: () => (jsx(Popover.Target, { children: jsx(Tooltip, { disabled: popoverOpened, label: filterTooltip, multiline: true, w: filterTooltip.length > 40 ? 300 : undefined, withinPortal: true, children: jsx(ActionIcon, { "aria-label": filterTooltip, className: clsx('mrt-table-head-cell-filter-label-icon', classes$f.root), size: 18, ...dataVariable('active', isFilterActive), onClick: (event) => {
+                                    event.stopPropagation();
+                                    if (columnFilterDisplayMode === 'popover') {
+                                        setPopoverOpened((opened) => !opened);
+                                    }
+                                    else {
+                                        setShowColumnFilters(true);
+                                    }
+                                    setTimeout(() => {
+                                        const input = filterInputRefs.current[`${column.id}-0`];
+                                        input?.focus();
+                                        input?.select();
+                                    }, 100);
+                                }, ...rest, children: jsx(IconFilter, { size: "100%" }) }) }) })) }), columnFilterDisplayMode === 'popover' && (jsx(Popover.Dropdown, { onClick: (event) => event.stopPropagation(), onKeyDown: (event) => event.key === 'Enter' && setPopoverOpened(false), onMouseDown: (event) => event.stopPropagation(), children: jsx(MRT_TableHeadCellFilterContainer, { header: header, table: table }) }))] }) }));
+};
+
+const MRT_TableHeadCellGrabHandle = ({ column, table, tableHeadCellRef, ...rest }) => {
+    const { state, options: { enableColumnOrdering, mantineColumnDragHandleProps }, setColumnOrder, setDraggingColumn, setHoveredColumn, } = table;
+    const { columnDef } = column;
+    const { columnOrder, draggingColumn, hoveredColumn } = state;
+    const arg = { column, table };
+    const actionIconProps = {
+        ...parseFromValuesOrFunc(mantineColumnDragHandleProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineColumnDragHandleProps, arg),
+        ...rest,
+    };
+    const handleDragStart = (event) => {
+        actionIconProps?.onDragStart?.(event);
+        setDraggingColumn(column);
+        event.dataTransfer.setDragImage(tableHeadCellRef.current, 0, 0);
+    };
+    const handleDragEnd = (event) => {
+        actionIconProps?.onDragEnd?.(event);
+        if (hoveredColumn?.id === 'drop-zone') {
+            column.toggleGrouping();
+        }
+        else if (enableColumnOrdering &&
+            hoveredColumn &&
+            hoveredColumn?.id !== draggingColumn?.id) {
+            setColumnOrder(reorderColumn(column, hoveredColumn, columnOrder));
+        }
+        setDraggingColumn(null);
+        setHoveredColumn(null);
+    };
+    return (jsx(MRT_GrabHandleButton, { actionIconProps: actionIconProps, onDragEnd: handleDragEnd, onDragStart: handleDragStart, table: table }));
+};
+
+var classes$e = {"root":"MRT_TableHeadCellResizeHandle-module_root__paufe","root-ltr":"MRT_TableHeadCellResizeHandle-module_root-ltr__652AZ","root-rtl":"MRT_TableHeadCellResizeHandle-module_root-rtl__5VlSo","root-hide":"MRT_TableHeadCellResizeHandle-module_root-hide__-ILlD"};
+
+const MRT_TableHeadCellResizeHandle = ({ header, table, ...rest }) => {
+    const { state, options: { columnResizeDirection, columnResizeMode }, setColumnResizing, } = table;
+    const { density } = state;
+    const { column } = header;
+    const handler = header.getResizeHandler();
+    const offset = column.getIsResizing() && columnResizeMode === 'onEnd'
+        ? `translateX(${(columnResizeDirection === 'rtl' ? -1 : 1) *
+            (state.columnResizing.deltaOffset ?? 0)}px)`
+        : undefined;
+    return (jsx(Box, { onDoubleClick: () => {
+            setColumnResizing((old) => ({
+                ...old,
+                isResizingColumn: false,
+            }));
+            column.resetSize();
+        }, onMouseDown: handler, onTouchStart: handler, role: "separator", ...rest, __vars: { '--mrt-transform': offset, ...rest.__vars }, className: clsx('mrt-table-head-cell-resize-handle', classes$e.root, classes$e[`root-${columnResizeDirection}`], !header.subHeaders.length &&
+            columnResizeMode === 'onChange' &&
+            classes$e['root-hide'], density, rest.className) }));
+};
+
+var classes$d = {"sort-icon":"MRT_TableHeadCellSortLabel-module_sort-icon__zs1xA","multi-sort-indicator":"MRT_TableHeadCellSortLabel-module_multi-sort-indicator__MGBj2"};
+
+const MRT_TableHeadCellSortLabel = ({ header, table, ...rest }) => {
+    const { options: { icons: { IconArrowsSort, IconSortAscending, IconSortDescending }, localization, }, } = table;
+    const column = header.column;
+    const { columnDef } = column;
+    return (jsx(Subscribe, { source: table.atoms.sorting, children: (sorting) => {
+            const sorted = column.getIsSorted();
+            const sortIndex = column.getSortIndex();
+            const sortTooltip = sorted
+                ? sorted === 'desc'
+                    ? localization.sortedByColumnDesc.replace('{column}', columnDef.header)
+                    : localization.sortedByColumnAsc.replace('{column}', columnDef.header)
+                : column.getNextSortingOrder() === 'desc'
+                    ? localization.sortByColumnDesc.replace('{column}', columnDef.header)
+                    : localization.sortByColumnAsc.replace('{column}', columnDef.header);
+            const SortActionButton = (jsx(ActionIcon, { "aria-label": sortTooltip, ...dataVariable('sorted', sorted), ...rest, className: clsx('mrt-table-head-sort-button', classes$d['sort-icon'], rest.className), children: sorted === 'desc' ? (jsx(IconSortDescending, { size: "100%" })) : sorted === 'asc' ? (jsx(IconSortAscending, { size: "100%" })) : (jsx(IconArrowsSort, { size: "100%" })) }));
+            return (jsx(Tooltip, { label: sortTooltip, openDelay: 1000, withinPortal: true, children: sorting.length < 2 || sortIndex === -1 ? (SortActionButton) : (jsx(Indicator, { classNames: {
+                        root: clsx('mrt-table-head-multi-sort-indicator', classes$d['multi-sort-indicator']),
+                    }, inline: true, label: sortIndex + 1, offset: 4, children: SortActionButton })) }));
+        } }));
+};
+
+var classes$c = {"root":"MRT_TableHeadCell-module_root__6y50a","root-grid":"MRT_TableHeadCell-module_root-grid__bAf1d","root-virtualized":"MRT_TableHeadCell-module_root-virtualized__CWLit","root-no-select":"MRT_TableHeadCell-module_root-no-select__BEOVU","content":"MRT_TableHeadCell-module_content__-pzSK","content-spaced":"MRT_TableHeadCell-module_content-spaced__S85Aa","content-center":"MRT_TableHeadCell-module_content-center__c-17L","content-right":"MRT_TableHeadCell-module_content-right__NSRZU","content-wrapper":"MRT_TableHeadCell-module_content-wrapper__py6aJ","content-wrapper-hidden-overflow":"MRT_TableHeadCell-module_content-wrapper-hidden-overflow__QY40r","content-wrapper-nowrap":"MRT_TableHeadCell-module_content-wrapper-nowrap__-4aIg","labels":"MRT_TableHeadCell-module_labels__oiMSr","labels-right":"MRT_TableHeadCell-module_labels-right__6ZJp-","labels-center":"MRT_TableHeadCell-module_labels-center__MM9q8","labels-sortable":"MRT_TableHeadCell-module_labels-sortable__tyuLr","labels-data":"MRT_TableHeadCell-module_labels-data__PvFGO","content-actions":"MRT_TableHeadCell-module_content-actions__utxbm"};
+
+const MRT_TableHeadCell = ({ columnVirtualizer, header, renderedHeaderIndex = 0, table, ...rest }) => {
+    const direction = useDirection();
+    const { state, options: { columnFilterDisplayMode, columnResizeDirection, columnResizeMode, enableColumnActions, enableColumnDragging, enableColumnOrdering, enableColumnPinning, enableGrouping, enableHeaderActionsHoverReveal, enableMultiSort, layoutMode, mantineTableHeadCellProps, }, refs: { tableHeadCellRefs }, setHoveredColumn, } = table;
+    const { columnResizing, draggingColumn, grouping, hoveredColumn } = state;
+    const { column } = header;
+    const { columnDef } = column;
+    const { columnDefType } = columnDef;
+    const arg = { column, table };
+    const tableCellProps = {
+        ...parseFromValuesOrFunc(mantineTableHeadCellProps, arg),
+        ...parseFromValuesOrFunc(columnDef.mantineTableHeadCellProps, arg),
+        ...rest,
+    };
+    const widthStyles = {
+        minWidth: `max(calc(var(--header-${parseCSSVarId(header?.id)}-size) * 1px), ${columnDef.minSize ?? 30}px)`,
+        width: `calc(var(--header-${parseCSSVarId(header.id)}-size) * 1px)`,
+    };
+    if (layoutMode === 'grid') {
+        widthStyles.flex = `${[0, false].includes(columnDef.grow)
+            ? 0
+            : `var(--header-${parseCSSVarId(header.id)}-size)`} 0 auto`;
+    }
+    else if (layoutMode === 'grid-no-grow') {
+        widthStyles.flex = `${+(columnDef.grow || 0)} 0 auto`;
+    }
+    const isColumnPinned = enableColumnPinning &&
+        columnDef.columnDefType !== 'group' &&
+        column.getIsPinned();
+    const isDraggingColumn = draggingColumn?.id === column.id;
+    const isHoveredColumn = hoveredColumn?.id === column.id;
+    const { hovered: isHoveredHeadCell, ref: isHoveredHeadCellRef } = useHover();
+    const [isOpenedColumnActions, setIsOpenedColumnActions] = useState(false);
+    const columnActionsEnabled = (enableColumnActions || columnDef.enableColumnActions) &&
+        columnDef.enableColumnActions !== false;
+    const showColumnButtons = !enableHeaderActionsHoverReveal ||
+        isOpenedColumnActions ||
+        (isHoveredHeadCell &&
+            !table.getVisibleFlatColumns().find((column) => column.getIsResizing()));
+    const showDragHandle = enableColumnDragging !== false &&
+        columnDef.enableColumnDragging !== false &&
+        (enableColumnDragging ||
+            (enableColumnOrdering && columnDef.enableColumnOrdering !== false) ||
+            (enableGrouping &&
+                columnDef.enableGrouping !== false &&
+                !grouping.includes(column.id))) &&
+        showColumnButtons;
+    const headerPL = useMemo(() => {
+        let pl = 0;
+        if (column.getCanSort())
+            pl++;
+        // Only add padding for buttons if they will actually be displayed
+        if (showColumnButtons && (columnActionsEnabled || showDragHandle))
+            pl += 1.75;
+        if (showDragHandle)
+            pl += 1.25;
+        return pl;
+    }, [showColumnButtons, showDragHandle, columnActionsEnabled]);
+    const handleDragEnter = (_e) => {
+        if (enableGrouping && hoveredColumn?.id === 'drop-zone') {
+            setHoveredColumn(null);
+        }
+        if (enableColumnOrdering && draggingColumn && columnDefType !== 'group') {
+            setHoveredColumn(columnDef.enableColumnOrdering !== false ? column : null);
+        }
+    };
+    const headerElement = columnDef?.Header instanceof Function
+        ? columnDef?.Header?.({
+            column,
+            header,
+            table,
+        })
+        : (columnDef?.Header ?? columnDef.header);
+    return (jsxs(TableTh, { colSpan: header.colSpan, "data-column-pinned": isColumnPinned || undefined, "data-dragging-column": isDraggingColumn || undefined, "data-first-end-pinned": (isColumnPinned === 'end' && column.getIsFirstColumn(isColumnPinned)) ||
+            undefined, "data-hovered-column-target": isHoveredColumn || undefined, "data-index": renderedHeaderIndex, "data-last-start-pinned": (isColumnPinned === 'start' &&
+            column.getIsLastColumn(isColumnPinned)) ||
+            undefined, "data-resizing": (columnResizeMode === 'onChange' &&
+            columnResizing?.isResizingColumn === column.id &&
+            columnResizeDirection) ||
+            undefined, ...tableCellProps, __vars: {
+            '--mrt-table-cell-start': isColumnPinned === 'start'
+                ? `${column.getStart(isColumnPinned)}`
+                : undefined,
+            '--mrt-table-cell-end': isColumnPinned === 'end'
+                ? `${column.getAfter(isColumnPinned)}`
+                : undefined,
+        }, align: columnDefType === 'group'
+            ? 'center'
+            : direction.dir === 'rtl'
+                ? 'right'
+                : 'left', className: clsx(classes$c.root, layoutMode?.startsWith('grid') && classes$c['root-grid'], enableMultiSort && column.getCanSort() && classes$c['root-no-select'], columnVirtualizer && classes$c['root-virtualized'], tableCellProps?.className), onDragEnter: handleDragEnter, ref: (node) => {
+            if (node) {
+                tableHeadCellRefs.current[column.id] = node;
+                isHoveredHeadCellRef.current = node;
+                if (columnDefType !== 'group') {
+                    columnVirtualizer?.measureElement?.(node);
+                }
+            }
+        }, style: (theme) => ({
+            ...widthStyles,
+            ...parseFromValuesOrFunc(tableCellProps?.style, theme),
+        }), children: [header.isPlaceholder
+                ? null
+                : (tableCellProps.children ?? (jsxs(Flex, { className: clsx('mrt-table-head-cell-content', classes$c.content, (columnDefType === 'group' ||
+                        tableCellProps?.align === 'center') &&
+                        classes$c['content-center'], tableCellProps?.align === 'right' && classes$c['content-right'], column.getCanResize() && classes$c['content-spaced']), children: [jsxs(Flex, { __vars: {
+                                '--mrt-table-head-cell-labels-padding-left': `${headerPL}`,
+                            }, className: clsx('mrt-table-head-cell-labels', classes$c.labels, column.getCanSort() &&
+                                columnDefType !== 'group' &&
+                                classes$c['labels-sortable'], tableCellProps?.align === 'right'
+                                ? classes$c['labels-right']
+                                : tableCellProps?.align === 'center' &&
+                                    classes$c['labels-center'], columnDefType === 'data' && classes$c['labels-data']), onClick: column.getToggleSortingHandler(), children: [jsx(Flex, { className: clsx('mrt-table-head-cell-content-wrapper', classes$c['content-wrapper'], columnDefType === 'data' &&
+                                        classes$c['content-wrapper-hidden-overflow'], (columnDef.header?.length ?? 0) < 20 &&
+                                        classes$c['content-wrapper-nowrap']), children: headerElement }), column.getCanFilter() &&
+                                    (column.getIsFiltered() || showColumnButtons) && (jsx(MRT_TableHeadCellFilterLabel, { header: header, table: table })), column.getCanSort() &&
+                                    (column.getIsSorted() || showColumnButtons) && (jsx(MRT_TableHeadCellSortLabel, { header: header, table: table }))] }), columnDefType !== 'group' && (jsxs(Flex, { className: clsx('mrt-table-head-cell-content-actions', classes$c['content-actions']), children: [showDragHandle && (jsx(MRT_TableHeadCellGrabHandle, { column: column, table: table, tableHeadCellRef: {
+                                        current: tableHeadCellRefs.current[column.id],
+                                    } })), columnActionsEnabled && showColumnButtons && (jsx(MRT_ColumnActionMenu, { header: header, onChange: setIsOpenedColumnActions, opened: isOpenedColumnActions, table: table }))] })), column.getCanResize() && (jsx(MRT_TableHeadCellResizeHandle, { header: header, table: table }))] }))), columnFilterDisplayMode === 'subheader' && column.getCanFilter() && (jsx(MRT_TableHeadCellFilterContainer, { header: header, table: table }))] }));
+};
+
+var classes$b = {"root":"MRT_TableHeadRow-module_root__hUKv4","layout-mode-grid":"MRT_TableHeadRow-module_layout-mode-grid__4ZGri","sticky":"MRT_TableHeadRow-module_sticky__Ej7Ax"};
+
+const MRT_TableHeadRow = ({ columnVirtualizer, headerGroup, table, ...rest }) => {
+    const { state, options: { enableStickyHeader, layoutMode, mantineTableHeadRowProps }, } = table;
+    const { isFullScreen } = state;
+    const { virtualColumns, virtualPaddingLeft, virtualPaddingRight } = columnVirtualizer ?? {};
+    const tableRowProps = {
+        ...parseFromValuesOrFunc(mantineTableHeadRowProps, {
+            headerGroup,
+            table,
+        }),
+        ...rest,
+    };
+    return (jsxs(TableTr, { ...tableRowProps, className: clsx(classes$b.root, (enableStickyHeader || isFullScreen) && classes$b.sticky, layoutMode?.startsWith('grid') && classes$b['layout-mode-grid'], tableRowProps?.className), children: [virtualPaddingLeft ? (jsx(Box, { component: "th", display: "flex", w: virtualPaddingLeft })) : null, (virtualColumns ?? headerGroup.headers).map((headerOrVirtualHeader, renderedHeaderIndex) => {
+                let header = headerOrVirtualHeader;
+                if (columnVirtualizer) {
+                    renderedHeaderIndex = headerOrVirtualHeader
+                        .index;
+                    header = headerGroup.headers[renderedHeaderIndex];
+                }
+                return (jsx(MRT_TableHeadCell, { columnVirtualizer: columnVirtualizer, header: header, renderedHeaderIndex: renderedHeaderIndex, table: table }, header.id));
+            }), virtualPaddingRight ? (jsx(Box, { component: "th", display: "flex", w: virtualPaddingRight })) : null] }));
+};
+
+var classes$a = {"root":"MRT_TableHead-module_root__j9NkO","root-grid":"MRT_TableHead-module_root-grid__c3aGl","root-table-row-group":"MRT_TableHead-module_root-table-row-group__d9FO4","root-sticky":"MRT_TableHead-module_root-sticky__0kuDE","banner-tr":"MRT_TableHead-module_banner-tr__EhT-x","banner-th":"MRT_TableHead-module_banner-th__KwM5a","grid":"MRT_TableHead-module_grid__OJ-td"};
+
+const MRT_TableHead = ({ columnVirtualizer, table, ...rest }) => {
+    const { getHeaderGroups, getSelectedRowModel, state, options: { enableStickyHeader, layoutMode, mantineTableHeadProps, positionToolbarAlertBanner, }, refs: { tableHeadRef }, } = table;
+    const { isFullScreen, showAlertBanner } = state;
+    const tableHeadProps = {
+        ...parseFromValuesOrFunc(mantineTableHeadProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const stickyHeader = enableStickyHeader || isFullScreen;
+    return (jsx(TableThead, { ...tableHeadProps, className: clsx(classes$a.root, layoutMode?.startsWith('grid')
+            ? classes$a['root-grid']
+            : classes$a['root-table-row-group'], stickyHeader && classes$a['root-sticky'], tableHeadProps?.className), pos: stickyHeader && layoutMode?.startsWith('grid') ? 'sticky' : 'relative', ref: (ref) => {
+            tableHeadRef.current = ref;
+            if (tableHeadProps?.ref) {
+                // @ts-ignore
+                tableHeadProps.ref.current = ref;
+            }
+        }, children: positionToolbarAlertBanner === 'head-overlay' &&
+            (showAlertBanner || getSelectedRowModel().rows.length > 0) ? (jsx(TableTr, { className: clsx(classes$a['banner-tr'], layoutMode?.startsWith('grid') && classes$a.grid), children: jsx(TableTh, { className: clsx(classes$a['banner-th'], layoutMode?.startsWith('grid') && classes$a.grid), colSpan: table.getVisibleLeafColumns().length, children: jsx(MRT_ToolbarAlertBanner, { table: table }) }) })) : (getHeaderGroups().map((headerGroup) => (jsx(MRT_TableHeadRow, { columnVirtualizer: columnVirtualizer, headerGroup: headerGroup, table: table }, headerGroup.id)))) }));
+};
+
+var classes$9 = {"root":"MRT_GlobalFilterTextInput-module_root__Xmcpv","collapse":"MRT_GlobalFilterTextInput-module_collapse__v311d"};
+
+const MRT_GlobalFilterTextInput = ({ table, ...rest }) => {
+    const { state, options: { enableGlobalFilterModes, icons: { IconSearch, IconX }, localization, mantineSearchTextInputProps, manualFiltering, positionGlobalFilter, }, refs: { searchInputRef }, setGlobalFilter, } = table;
+    const { globalFilter, showGlobalFilter } = state;
+    const textFieldProps = {
+        ...parseFromValuesOrFunc(mantineSearchTextInputProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const isMounted = useRef(false);
+    const [searchValue, setSearchValue] = useState(globalFilter ?? '');
+    const [debouncedSearchValue] = useDebouncedValue(searchValue, manualFiltering ? 500 : 250);
+    useEffect(() => {
+        setGlobalFilter(debouncedSearchValue || undefined);
+    }, [debouncedSearchValue]);
+    const handleClear = () => {
+        setSearchValue('');
+        setGlobalFilter(undefined);
+    };
+    useEffect(() => {
+        if (isMounted.current) {
+            if (globalFilter === undefined) {
+                handleClear();
+            }
+            else {
+                setSearchValue(globalFilter);
+            }
+        }
+        isMounted.current = true;
+    }, [globalFilter]);
+    return (jsxs(Collapse, { className: classes$9.collapse, expanded: showGlobalFilter, children: [enableGlobalFilterModes && (jsxs(Menu, { withinPortal: true, children: [jsx(Menu.Target, { children: jsx(ActionIcon, { "aria-label": localization.changeSearchMode, color: "gray", size: "sm", variant: "transparent", children: jsx(IconSearch, {}) }) }), jsx(MRT_FilterOptionMenu, { onSelect: handleClear, table: table })] })), jsx(TextInput, { leftSection: !enableGlobalFilterModes && jsx(IconSearch, {}), mt: 0, mx: positionGlobalFilter !== 'left' ? 'mx' : undefined, onChange: (event) => setSearchValue(event.target.value), placeholder: localization.search, rightSection: jsx(ActionIcon, { "aria-label": localization.clearSearch, color: "gray", disabled: !searchValue?.length, hidden: !searchValue, onClick: handleClear, size: "sm", style: {
+                        visibility: !searchValue ? 'hidden' : undefined,
+                    }, variant: "transparent", children: jsx(Tooltip, { label: localization.clearSearch, withinPortal: true, children: jsx(IconX, {}) }) }), value: searchValue ?? '', variant: "filled", ...textFieldProps, className: clsx('mrt-global-filter-text-input', classes$9.root, textFieldProps?.className), ref: (node) => {
+                    if (node) {
+                        searchInputRef.current = node;
+                        if (textFieldProps?.ref) {
+                            // @ts-ignore
+                            textFieldProps.ref = node;
+                        }
+                    }
+                } })] }));
+};
+
+const flexRender = flexRender$1;
+/**
+ * A helper utility for creating MRT column definitions with type inference
+ * for each individual column's `TValue`. Mirrors v9's `createColumnHelper`
+ * surface (`accessor`, `columns`, `display`, `group`) but bound to MRT's
+ * column-def shape (extra MRT-specific props, `StockFeatures` pre-bound).
+ *
+ * From a JavaScript perspective, `display` / `group` / `columns` are identity
+ * functions — they exist purely to anchor TypeScript inference.
+ *
+ * @example
+ * ```tsx
+ * const helper = createMRTColumnHelper<Person>()
+ * const columns = helper.columns([
+ *   helper.accessor('firstName', { header: 'First' }),
+ *   helper.accessor((row) => row.lastName, { id: 'lastName' }),
+ *   helper.display({ id: 'actions', header: 'Actions' }),
+ * ])
+ * ```
+ */
+function createMRTColumnHelper() {
+    return {
+        accessor: (accessor, column) => {
+            return typeof accessor === 'function'
+                ? {
+                    ...column,
+                    accessorFn: accessor,
+                }
+                : {
+                    ...column,
+                    accessorKey: accessor,
+                };
+        },
+        columns: (columns) => columns,
+        display: (column) => column,
+        group: (column) => column,
+    };
+}
+const createRow = (table, originalRow, rowIndex = -1, depth = 0, subRows, parentId) => constructRow(table, 'mrt-row-create', originalRow ??
+    Object.assign({}, ...getAllLeafColumnDefs(table.options.columns).map((col) => ({
+        [getColumnId(col)]: '',
+    }))), rowIndex, depth, subRows, parentId);
+
+const getMRT_RowActionsColumnDef = (tableOptions) => {
+    return {
+        Cell: ({ cell, row, table }) => (jsx(MRT_ToggleRowActionMenuButton, { cell: cell, row: row, table: table })),
+        ...defaultDisplayColumnProps({
+            header: 'actions',
+            id: 'mrt-row-actions',
+            size: 70,
+            tableOptions,
+        }),
+    };
+};
+
+const getMRT_RowDragColumnDef = (tableOptions) => {
+    return {
+        Cell: ({ row, rowRef, table }) => (jsx(MRT_TableBodyRowGrabHandle, { row: row, rowRef: rowRef, table: table })),
+        grow: false,
+        ...defaultDisplayColumnProps({
+            header: 'move',
+            id: 'mrt-row-drag',
+            size: 60,
+            tableOptions,
+        }),
+    };
+};
+
+const getMRT_RowExpandColumnDef = (tableOptions) => {
+    const { defaultColumn, enableExpandAll, groupedColumnMode, positionExpandColumn, renderDetailPanel, state: { grouping }, } = tableOptions;
+    const alignProps = positionExpandColumn === 'last'
+        ? {
+            align: 'right',
+        }
+        : undefined;
+    return {
+        Cell: ({ cell, column, row, table }) => {
+            const expandButtonProps = { row, table };
+            const subRowsLength = row.subRows?.length;
+            if (tableOptions.groupedColumnMode === 'remove' && row.groupingColumnId) {
+                return (jsxs(Flex, { align: "center", gap: "0.25rem", children: [jsx(MRT_ExpandButton, { ...expandButtonProps }), jsx(Tooltip, { label: table.getColumn(row.groupingColumnId).columnDef.header, openDelay: 1000, position: "right", children: jsx("span", { children: row.groupingValue }) }), !!subRowsLength && jsxs("span", { children: ["(", subRowsLength, ")"] })] }));
+            }
+            else {
+                return (jsxs(Fragment, { children: [jsx(MRT_ExpandButton, { ...expandButtonProps }), column.columnDef.GroupedCell?.({ cell, column, row, table })] }));
+            }
+        },
+        Header: enableExpandAll
+            ? ({ table }) => {
+                return (jsxs(Flex, { align: "center", children: [jsx(MRT_ExpandAllButton, { table: table }), groupedColumnMode === 'remove' &&
+                            grouping
+                                ?.map((groupedColumnId) => table.getColumn(groupedColumnId).columnDef.header)
+                                ?.join(', ')] }));
+            }
+            : undefined,
+        mantineTableBodyCellProps: alignProps,
+        mantineTableHeadCellProps: alignProps,
+        ...defaultDisplayColumnProps({
+            header: 'expand',
+            id: 'mrt-row-expand',
+            size: groupedColumnMode === 'remove'
+                ? (defaultColumn?.size ?? 180)
+                : renderDetailPanel
+                    ? enableExpandAll
+                        ? 60
+                        : 70
+                    : 100,
+            tableOptions,
+        }),
+    };
+};
+
+const getMRT_RowNumbersColumnDef = (tableOptions) => {
+    const { localization, rowNumberDisplayMode } = tableOptions;
+    return {
+        Cell: ({ renderedRowIndex = 0, row, table }) => {
+            const { pageIndex, pageSize } = table.atoms.pagination.get();
+            return (((rowNumberDisplayMode === 'static'
+                ? renderedRowIndex + pageSize * pageIndex
+                : row.index) ?? 0) + 1);
+        },
+        grow: false,
+        Header: () => localization.rowNumber,
+        ...defaultDisplayColumnProps({
+            header: 'rowNumbers',
+            id: 'mrt-row-numbers',
+            size: 50,
+            tableOptions,
+        }),
+    };
+};
+
+const getMRT_RowPinningColumnDef = (tableOptions) => {
+    return {
+        Cell: ({ row, table }) => (jsx(MRT_TableBodyRowPinButton, { row: row, table: table })),
+        grow: false,
+        ...defaultDisplayColumnProps({
+            header: 'pin',
+            id: 'mrt-row-pin',
+            size: 60,
+            tableOptions,
+        }),
+    };
+};
+
+const getMRT_RowSelectColumnDef = (tableOptions) => {
+    const { enableMultiRowSelection, enableSelectAll } = tableOptions;
+    return {
+        Cell: ({ renderedRowIndex, row, table }) => (jsx(MRT_SelectCheckbox, { renderedRowIndex: renderedRowIndex, row: row, table: table })),
+        grow: false,
+        Header: enableSelectAll && enableMultiRowSelection
+            ? ({ table }) => jsx(MRT_SelectCheckbox, { table: table })
+            : undefined,
+        ...defaultDisplayColumnProps({
+            header: 'select',
+            id: 'mrt-row-select',
+            size: enableSelectAll ? 60 : 70,
+            tableOptions,
+        }),
+    };
+};
+
+const MRT_RowAggregationFns = { ...aggregationFns };
+
+const MRT_Default_Icons = {
+    IconArrowAutofitContent,
+    IconArrowsSort,
+    IconBaselineDensityLarge,
+    IconBaselineDensityMedium,
+    IconBaselineDensitySmall,
+    IconBoxMultiple,
+    IconChevronDown,
+    IconChevronLeft,
+    IconChevronLeftPipe,
+    IconChevronRight,
+    IconChevronRightPipe,
+    IconChevronsDown,
+    IconCircleX,
+    IconClearAll,
+    IconColumns,
+    IconDeviceFloppy,
+    IconDots,
+    IconDotsVertical,
+    IconEdit,
+    IconEyeOff,
+    IconFilter,
+    IconFilterCog,
+    IconFilterOff,
+    IconGripHorizontal,
+    IconMaximize,
+    IconMinimize,
+    IconPinned,
+    IconPinnedOff,
+    IconSearch,
+    IconSearchOff,
+    IconSortAscending,
+    IconSortDescending,
+    IconX,
+};
+
+const MRT_Localization_EN = {
+    actions: 'Actions',
+    and: 'and',
+    cancel: 'Cancel',
+    changeFilterMode: 'Change filter mode',
+    changeSearchMode: 'Change search mode',
+    clearFilter: 'Clear filter',
+    clearSearch: 'Clear search',
+    clearSelection: 'Clear selection',
+    clearSort: 'Clear sort',
+    clickToCopy: 'Click to copy',
+    copy: 'Copy',
+    collapse: 'Collapse',
+    collapseAll: 'Collapse all',
+    columnActions: 'Column Actions',
+    copiedToClipboard: 'Copied to clipboard',
+    dropToGroupBy: 'Drop to group by {column}',
+    edit: 'Edit',
+    expand: 'Expand',
+    expandAll: 'Expand all',
+    filterArrIncludes: 'Includes',
+    filterArrIncludesAll: 'Includes all',
+    filterArrIncludesSome: 'Includes',
+    filterBetween: 'Between',
+    filterBetweenInclusive: 'Between Inclusive',
+    filterByColumn: 'Filter by {column}',
+    filterContains: 'Contains',
+    filterEmpty: 'Empty',
+    filterEndsWith: 'Ends With',
+    filterEquals: 'Equals',
+    filterEqualsString: 'Equals',
+    filterFuzzy: 'Fuzzy',
+    filterGreaterThan: 'Greater Than',
+    filterGreaterThanOrEqualTo: 'Greater Than Or Equal To',
+    filterInNumberRange: 'Between',
+    filterIncludesString: 'Contains',
+    filterIncludesStringSensitive: 'Contains',
+    filterLessThan: 'Less Than',
+    filterLessThanOrEqualTo: 'Less Than Or Equal To',
+    filterMode: 'Filter Mode: {filterType}',
+    filterNotEmpty: 'Not Empty',
+    filterNotEquals: 'Not Equals',
+    filterStartsWith: 'Starts With',
+    filterWeakEquals: 'Equals',
+    filteringByColumn: 'Filtering by {column} - {filterType} {filterValue}',
+    goToFirstPage: 'Go to first page',
+    goToLastPage: 'Go to last page',
+    goToNextPage: 'Go to next page',
+    goToPreviousPage: 'Go to previous page',
+    grab: 'Grab',
+    groupByColumn: 'Group by {column}',
+    groupedBy: 'Grouped by ',
+    hideAll: 'Hide all',
+    hideColumn: 'Hide {column} column',
+    max: 'Max',
+    min: 'Min',
+    move: 'Move',
+    noRecordsToDisplay: 'No records to display',
+    noResultsFound: 'No results found',
+    of: 'of',
+    or: 'or',
+    pin: 'Pin',
+    pinToLeft: 'Pin to left',
+    pinToRight: 'Pin to right',
+    resetColumnSize: 'Reset column size',
+    resetOrder: 'Reset order',
+    rowActions: 'Row Actions',
+    rowNumber: '#',
+    rowNumbers: 'Row Numbers',
+    rowsPerPage: 'Rows per page',
+    save: 'Save',
+    search: 'Search',
+    selectedCountOfRowCountRowsSelected: '{selectedCount} of {rowCount} row(s) selected',
+    select: 'Select',
+    showAll: 'Show all',
+    showAllColumns: 'Show all columns',
+    showHideColumns: 'Show/Hide columns',
+    showHideFilters: 'Show/Hide filters',
+    showHideSearch: 'Show/Hide search',
+    sortByColumnAsc: 'Sort by {column} ascending',
+    sortByColumnDesc: 'Sort by {column} descending',
+    sortedByColumnAsc: 'Sorted by {column} ascending',
+    sortedByColumnDesc: 'Sorted by {column} descending',
+    thenBy: ', then by ',
+    toggleDensity: 'Toggle density',
+    toggleFullScreen: 'Toggle full screen',
+    toggleSelectAll: 'Toggle select all',
+    toggleSelectRow: 'Toggle select row',
+    toggleVisibility: 'Toggle visibility',
+    ungroupByColumn: 'Ungroup by {column}',
+    unpin: 'Unpin',
+    unpinAll: 'Unpin all',
+};
+
+const MRT_DefaultColumn = {
+    filterVariant: 'text',
+    maxSize: 1000,
+    minSize: 40,
+    size: 180,
+};
+const MRT_DefaultDisplayColumn = {
+    columnDefType: 'display',
+    enableClickToCopy: false,
+    enableColumnActions: false,
+    enableColumnDragging: false,
+    enableColumnFilter: false,
+    enableColumnOrdering: false,
+    enableEditing: false,
+    enableGlobalFilter: false,
+    enableGrouping: false,
+    enableHiding: false,
+    enableResizing: false,
+    enableSorting: false,
+};
+const useMRT_TableOptions = ({ aggregationFns, autoResetExpanded = false, columnFilterDisplayMode = 'subheader', columnResizeDirection, columnResizeMode = 'onChange', createDisplayMode = 'modal', defaultColumn, defaultDisplayColumn, editDisplayMode = 'modal', enableBatchRowSelection = true, enableBottomToolbar = true, enableColumnActions = true, enableColumnFilters = true, enableColumnOrdering = false, enableColumnPinning = false, enableColumnResizing = false, enableColumnVirtualization, enableDensityToggle = true, enableExpandAll = true, enableExpanding, enableFacetedValues = false, enableFilterMatchHighlighting = true, enableFilters = true, enableFullScreenToggle = true, enableGlobalFilter = true, enableGlobalFilterRankedResults = true, enableGrouping = false, enableHeaderActionsHoverReveal = false, enableHiding = true, enableMultiRowSelection = true, enableMultiSort = true, enablePagination = true, enableRowPinning = false, enableRowSelection = false, enableRowVirtualization, enableSelectAll = true, enableSorting = true, enableStickyHeader = false, enableTableFooter = true, enableTableHead = true, enableToolbarInternalActions = true, enableTopToolbar = true, filterFns, icons, layoutMode, localization, manualFiltering, manualGrouping, manualPagination, manualSorting, paginationDisplayMode = 'default', positionActionsColumn = 'first', positionCreatingRow = 'top', positionExpandColumn = 'first', positionGlobalFilter = 'right', positionPagination = 'bottom', positionToolbarAlertBanner = 'top', positionToolbarDropZone = 'top', rowNumberDisplayMode = 'static', rowPinningDisplayMode = 'sticky', selectAllMode = 'page', sortFns, ...rest }) => {
+    const direction = useDirection();
+    icons = useMemo(() => ({ ...MRT_Default_Icons, ...icons }), [icons]);
+    localization = useMemo(() => ({
+        ...MRT_Localization_EN,
+        ...localization,
+    }), [localization]);
+    aggregationFns = useMemo(() => ({ ...MRT_RowAggregationFns, ...aggregationFns }), []);
+    filterFns = useMemo(() => ({ ...MRT_FilterFns, ...filterFns }), []);
+    sortFns = useMemo(() => ({ ...MRT_SortFns, ...sortFns }), []);
+    defaultColumn = useMemo(() => ({ ...MRT_DefaultColumn, ...defaultColumn }), [defaultColumn]);
+    defaultDisplayColumn = useMemo(() => ({
+        ...MRT_DefaultDisplayColumn,
+        ...defaultDisplayColumn,
+    }), [defaultDisplayColumn]);
+    [enableColumnVirtualization, enableRowVirtualization] = useMemo(() => [enableColumnVirtualization, enableRowVirtualization], []);
+    if (!columnResizeDirection) {
+        columnResizeDirection = direction.dir || 'ltr';
+    }
+    layoutMode =
+        layoutMode || (enableColumnResizing ? 'grid-no-grow' : 'semantic');
+    if (layoutMode === 'semantic' &&
+        (enableRowVirtualization || enableColumnVirtualization)) {
+        layoutMode = 'grid';
+    }
+    if (enableRowVirtualization) {
+        enableStickyHeader = true;
+    }
+    if (enablePagination === false && manualPagination === undefined) {
+        manualPagination = true;
+    }
+    if (!rest.data?.length) {
+        manualFiltering = true;
+        manualGrouping = true;
+        manualPagination = true;
+        manualSorting = true;
+    }
+    return {
+        aggregationFns,
+        autoResetExpanded,
+        columnFilterDisplayMode,
+        columnResizeDirection,
+        columnResizeMode,
+        createDisplayMode,
+        defaultColumn,
+        defaultDisplayColumn,
+        editDisplayMode,
+        enableBatchRowSelection,
+        enableBottomToolbar,
+        enableColumnActions,
+        enableColumnFilters,
+        enableColumnOrdering,
+        enableColumnPinning,
+        enableColumnResizing,
+        enableColumnVirtualization,
+        enableDensityToggle,
+        enableExpandAll,
+        enableExpanding,
+        enableFacetedValues,
+        enableFilterMatchHighlighting,
+        enableFilters,
+        enableFullScreenToggle,
+        enableGlobalFilter,
+        enableGlobalFilterRankedResults,
+        enableGrouping,
+        enableHeaderActionsHoverReveal,
+        enableHiding,
+        enableMultiRowSelection,
+        enableMultiSort,
+        enablePagination,
+        enableRowPinning,
+        enableRowSelection,
+        enableRowVirtualization,
+        enableSelectAll,
+        enableSorting,
+        enableStickyHeader,
+        enableTableFooter,
+        enableTableHead,
+        enableToolbarInternalActions,
+        enableTopToolbar,
+        filterFns,
+        features: {
+            ...stockFeatures,
+            ...((enableColumnFilters || enableGlobalFilter || enableFilters) &&
+                !manualFiltering
+                ? { filteredRowModel: createFilteredRowModel(), filterFns }
+                : {}),
+            ...(enableSorting && !manualSorting
+                ? { sortedRowModel: createSortedRowModel(), sortFns }
+                : {}),
+            ...(enablePagination && !manualPagination
+                ? { paginatedRowModel: createPaginatedRowModel() }
+                : {}),
+            ...(enableExpanding || enableGrouping
+                ? { expandedRowModel: createExpandedRowModel() }
+                : {}),
+            ...(enableGrouping && !manualGrouping
+                ? {
+                    groupedRowModel: createGroupedRowModel(),
+                    aggregationFns,
+                }
+                : {}),
+            ...(enableFacetedValues
+                ? {
+                    facetedRowModel: createFacetedRowModel(),
+                    facetedMinMaxValues: createFacetedMinMaxValues(),
+                    facetedUniqueValues: createFacetedUniqueValues(),
+                }
+                : {}),
+        },
+        getSubRows: (row) => row?.subRows,
+        icons,
+        layoutMode,
+        localization,
+        manualFiltering,
+        manualGrouping,
+        manualPagination,
+        manualSorting,
+        paginationDisplayMode,
+        positionActionsColumn,
+        positionCreatingRow,
+        positionExpandColumn,
+        positionGlobalFilter,
+        positionPagination,
+        positionToolbarAlertBanner,
+        positionToolbarDropZone,
+        rowNumberDisplayMode,
+        rowPinningDisplayMode,
+        selectAllMode,
+        sortFns,
+        ...rest,
+    };
+};
+
+const blankColProps = {
+    children: null,
+    style: {
+        minWidth: 0,
+        padding: 0,
+        width: 0,
+    },
+};
+const getMRT_RowSpacerColumnDef = (tableOptions) => {
+    return {
+        ...defaultDisplayColumnProps({
+            id: 'mrt-row-spacer',
+            size: 0,
+            tableOptions,
+        }),
+        grow: true,
+        ...MRT_DefaultDisplayColumn,
+        mantineTableBodyCellProps: blankColProps,
+        mantineTableFooterCellProps: blankColProps,
+        mantineTableHeadCellProps: blankColProps,
+    };
+};
+
+const useMRT_Effects = (table) => {
+    const { getIsSomeRowsPinned, getPrePaginatedRowModel, state, options: { enablePagination, enableRowPinning, rowCount }, } = table;
+    const { columnOrder, density, globalFilter, isFullScreen, isLoading, pagination, showSkeletons, sorting, } = state;
+    const totalColumnCount = table.options.columns.length;
+    const totalRowCount = rowCount ?? getPrePaginatedRowModel().rows.length;
+    const rerender = useReducer(() => ({}), {})[1];
+    const initialBodyHeight = useRef(undefined);
+    const previousTop = useRef(undefined);
+    useEffect(() => {
+        if (typeof window !== 'undefined') {
+            initialBodyHeight.current = document.body.style.height;
+        }
+    }, []);
+    // hide scrollbars when table is in full screen mode, preserve body scroll position after full screen exit
+    useEffect(() => {
+        if (typeof window !== 'undefined') {
+            if (isFullScreen) {
+                previousTop.current = document.body.getBoundingClientRect().top; // save scroll position
+                document.body.style.height = '100dvh'; // hide page scrollbars when table is in full screen mode
+            }
+            else {
+                document.body.style.height = initialBodyHeight.current;
+                if (!previousTop.current)
+                    return;
+                // restore scroll position
+                window.scrollTo({
+                    behavior: 'instant',
+                    top: -1 * previousTop.current,
+                });
+            }
+        }
+    }, [isFullScreen]);
+    // recalculate column order when columns change or features are toggled on/off
+    useEffect(() => {
+        if (totalColumnCount !== columnOrder.length) {
+            table.setColumnOrder(getDefaultColumnOrderIds({
+                ...table.options,
+                state,
+            }));
+        }
+    }, [totalColumnCount]);
+    // if page index is out of bounds, set it to the last page
+    useEffect(() => {
+        if (!enablePagination || isLoading || showSkeletons)
+            return;
+        const { pageIndex, pageSize } = pagination;
+        const firstVisibleRowIndex = pageIndex * pageSize;
+        if (firstVisibleRowIndex >= totalRowCount && firstVisibleRowIndex > 0) {
+            table.setPageIndex(Math.ceil(totalRowCount / pageSize) - 1);
+        }
+    }, [totalRowCount]);
+    // turn off sort when global filter is looking for ranked results
+    const appliedSort = useRef(sorting);
+    useEffect(() => {
+        if (sorting.length) {
+            appliedSort.current = sorting;
+        }
+    }, [sorting]);
+    useEffect(() => {
+        if (!getCanRankRows(table))
+            return;
+        if (globalFilter) {
+            table.setSorting([]);
+        }
+        else {
+            table.setSorting(() => appliedSort.current || []);
+        }
+    }, [globalFilter]);
+    // fix pinned row top style when density changes
+    useEffect(() => {
+        if (enableRowPinning && getIsSomeRowsPinned()) {
+            setTimeout(() => {
+                rerender();
+            }, 150);
+        }
+    }, [density]);
+};
+
+/**
+ * The MRT hook that wraps the TanStack `useTable` hook and adds MRT-specific
+ * state, refs, and helpers. State management is built on top of TanStack
+ * Store atoms (`useCreateAtom` from `@tanstack/react-store`):
+ *
+ * - **TanStack-aware slices** (`columnOrder`, `columnResizing`, `grouping`,
+ *   `pagination`) are passed via the `atoms` option on `useTable`. Library
+ *   writes (e.g. `table.setSorting(...)`, `table.firstPage()`) flow directly
+ *   through these atoms, and they're automatically tracked in
+ *   `table.state` by the v9 store.
+ * - **MRT-only slices** (`density`, `isFullScreen`, `creatingRow`,
+ *   `editingCell`, `editingRow`, `draggingColumn`, `draggingRow`,
+ *   `hoveredColumn`, `hoveredRow`, `globalFilterFn`, `columnFilterFns`,
+ *   `showAlertBanner`, `showColumnFilters`, `showGlobalFilter`,
+ *   `showToolbarDropZone`) live in atoms outside the v9 store and are
+ *   merged into `table.state` after construction so MRT components can read
+ *   them via the same `state` surface.
+ *
+ * @param definedTableOptions - table options with proper defaults set
+ * @returns the MRT table instance
+ */
+const useMRT_TableInstance = (definedTableOptions) => {
+    const lastSelectedRowId = useRef(null);
+    const bottomToolbarRef = useRef(null);
+    const editInputRefs = useRef({});
+    const filterInputRefs = useRef({});
+    const searchInputRef = useRef(null);
+    const tableContainerRef = useRef(null);
+    const tableHeadCellRefs = useRef({});
+    const tablePaperRef = useRef(null);
+    const topToolbarRef = useRef(null);
+    const tableHeadRef = useRef(null);
+    const tableFooterRef = useRef(null);
+    // transform initial state with proper column order
+    const initialState = useMemo(() => {
+        const initState = definedTableOptions.initialState ?? {};
+        initState.columnOrder =
+            initState.columnOrder ??
+                getDefaultColumnOrderIds({
+                    ...definedTableOptions,
+                    state: {
+                        ...definedTableOptions.initialState,
+                        ...definedTableOptions.state,
+                    },
+                });
+        initState.globalFilterFn = definedTableOptions.globalFilterFn ?? 'fuzzy';
+        return initState;
+    }, []);
+    definedTableOptions.initialState = initialState;
+    // ---------------------------------------------------------------------------
+    // TanStack-aware atoms (passed to `useTable` via `atoms` option). The library
+    // both reads and writes through these.
+    // ---------------------------------------------------------------------------
+    const columnOrderAtom = useCreateAtom(initialState.columnOrder ?? []);
+    const columnResizingAtom = useCreateAtom(initialState.columnResizing ?? {});
+    const groupingAtom = useCreateAtom(initialState.grouping ?? []);
+    const paginationAtom = useCreateAtom(initialState?.pagination ?? { pageIndex: 0, pageSize: 10 });
+    // Subscribe so the consumer re-renders when these slices change. (The library
+    // also reads from these atoms internally; the subscriptions here are for the
+    // MRT component tree.)
+    const columnOrder = useSelector(columnOrderAtom);
+    const columnResizing = useSelector(columnResizingAtom);
+    const grouping = useSelector(groupingAtom);
+    const pagination = useSelector(paginationAtom);
+    // ---------------------------------------------------------------------------
+    // MRT-only atoms — these slices aren't part of v9's `TableState` so they
+    // can't be passed via the `atoms` option. They're maintained as standalone
+    // atoms and merged into `table.state` after construction.
+    // ---------------------------------------------------------------------------
+    // Build the initial columnFilterFns map from each column's `filterFn` (or
+    // the registered default if none set). Constructed as a plain Record so
+    // `useCreateAtom`'s overload resolves to `Atom<T>` (writable) rather than
+    // the function-style `ReadonlyAtom<T>` overload.
+    const initialColumnFilterFns = {};
+    for (const col of getAllLeafColumnDefs(definedTableOptions.columns)) {
+        initialColumnFilterFns[getColumnId(col)] =
+            col.filterFn instanceof Function
+                ? (col.filterFn.name ?? 'custom')
+                : (col.filterFn ??
+                    initialState?.columnFilterFns?.[getColumnId(col)] ??
+                    getDefaultColumnFilterFn(col));
+    }
+    const columnFilterFnsAtom = useCreateAtom(initialColumnFilterFns);
+    const creatingRowAtom = useCreateAtom(initialState.creatingRow ?? null);
+    const densityAtom = useCreateAtom(initialState?.density ?? 'md');
+    const draggingColumnAtom = useCreateAtom(initialState.draggingColumn ?? null);
+    const draggingRowAtom = useCreateAtom(initialState.draggingRow ?? null);
+    const editingCellAtom = useCreateAtom(initialState.editingCell ?? null);
+    const editingRowAtom = useCreateAtom(initialState.editingRow ?? null);
+    const globalFilterFnAtom = useCreateAtom(initialState.globalFilterFn ?? 'fuzzy');
+    const hoveredColumnAtom = useCreateAtom(initialState.hoveredColumn ?? null);
+    const hoveredRowAtom = useCreateAtom(initialState.hoveredRow ?? null);
+    const isFullScreenAtom = useCreateAtom(initialState?.isFullScreen ?? false);
+    const showAlertBannerAtom = useCreateAtom(initialState?.showAlertBanner ?? false);
+    const showColumnFiltersAtom = useCreateAtom(initialState?.showColumnFilters ?? false);
+    const showGlobalFilterAtom = useCreateAtom(initialState?.showGlobalFilter ?? false);
+    const showToolbarDropZoneAtom = useCreateAtom(initialState?.showToolbarDropZone ?? false);
+    const columnFilterFns = useSelector(columnFilterFnsAtom);
+    const creatingRow = useSelector(creatingRowAtom);
+    const density = useSelector(densityAtom);
+    const draggingColumn = useSelector(draggingColumnAtom);
+    const draggingRow = useSelector(draggingRowAtom);
+    const editingCell = useSelector(editingCellAtom);
+    const editingRow = useSelector(editingRowAtom);
+    const globalFilterFn = useSelector(globalFilterFnAtom);
+    const hoveredColumn = useSelector(hoveredColumnAtom);
+    const hoveredRow = useSelector(hoveredRowAtom);
+    const isFullScreen = useSelector(isFullScreenAtom);
+    const showAlertBanner = useSelector(showAlertBannerAtom);
+    const showColumnFilters = useSelector(showColumnFiltersAtom);
+    const showGlobalFilter = useSelector(showGlobalFilterAtom);
+    const showToolbarDropZone = useSelector(showToolbarDropZoneAtom);
+    // Mirror values into options.state so utilities that read
+    // `tableOptions.state.X` (e.g. column prep, display-column factories) keep
+    // working. The user can still override individual slices by setting
+    // `definedTableOptions.state` from outside.
+    definedTableOptions.state = {
+        columnFilterFns,
+        columnOrder,
+        columnResizing,
+        creatingRow,
+        density,
+        draggingColumn,
+        draggingRow,
+        editingCell,
+        editingRow,
+        globalFilterFn,
+        grouping,
+        hoveredColumn,
+        hoveredRow,
+        isFullScreen,
+        pagination,
+        showAlertBanner,
+        showColumnFilters,
+        showGlobalFilter,
+        showToolbarDropZone,
+        ...definedTableOptions.state,
+    };
+    // The table options now include all state needed to help determine column visibility and order logic
+    const statefulTableOptions = definedTableOptions;
+    // Column preparation mutates/augments definitions and must rerun when an
+    // input that affects those definitions changes. Keep the resulting array
+    // stable across unrelated state updates such as pagination.
+    const columnDefsRef = useRef([]);
+    const columnPreparationDepsRef = useRef(undefined);
+    const sourceColumns = statefulTableOptions.columns;
+    const columnPreparationDeps = [
+        sourceColumns,
+        statefulTableOptions.defaultColumn,
+        statefulTableOptions.defaultDisplayColumn,
+        statefulTableOptions.displayColumnDefOptions,
+        statefulTableOptions.filterFns,
+        statefulTableOptions.sortFns,
+        statefulTableOptions.localization,
+        statefulTableOptions.state.columnFilterFns,
+        statefulTableOptions.state.creatingRow,
+        statefulTableOptions.state.grouping,
+        statefulTableOptions.createDisplayMode,
+        statefulTableOptions.editDisplayMode,
+        statefulTableOptions.enableEditing,
+        statefulTableOptions.enableExpandAll,
+        statefulTableOptions.enableExpanding,
+        statefulTableOptions.enableGrouping,
+        statefulTableOptions.enableMultiRowSelection,
+        statefulTableOptions.enableRowActions,
+        statefulTableOptions.enableRowDragging,
+        statefulTableOptions.enableRowNumbers,
+        statefulTableOptions.enableRowOrdering,
+        statefulTableOptions.enableRowPinning,
+        statefulTableOptions.enableRowSelection,
+        statefulTableOptions.enableSelectAll,
+        statefulTableOptions.groupedColumnMode,
+        statefulTableOptions.layoutMode,
+        statefulTableOptions.positionExpandColumn,
+        statefulTableOptions.renderDetailPanel,
+        statefulTableOptions.rowNumberDisplayMode,
+        statefulTableOptions.rowPinningDisplayMode,
+    ];
+    const previousColumnPreparationDeps = columnPreparationDepsRef.current;
+    const columnPreparationChanged = !previousColumnPreparationDeps ||
+        columnPreparationDeps.length !== previousColumnPreparationDeps.length ||
+        columnPreparationDeps.some((dependency, index) => !Object.is(dependency, previousColumnPreparationDeps[index]));
+    const freezePreparedColumns = !!columnDefsRef.current.length &&
+        (statefulTableOptions.state.columnResizing.isResizingColumn ||
+            !!statefulTableOptions.state.draggingColumn ||
+            !!statefulTableOptions.state.draggingRow);
+    if (columnPreparationChanged && !freezePreparedColumns) {
+        columnDefsRef.current = prepareColumns({
+            columnDefs: [
+                ...[
+                    showRowPinningColumn(statefulTableOptions) &&
+                        getMRT_RowPinningColumnDef(statefulTableOptions),
+                    showRowDragColumn(statefulTableOptions) &&
+                        getMRT_RowDragColumnDef(statefulTableOptions),
+                    showRowActionsColumn(statefulTableOptions) &&
+                        getMRT_RowActionsColumnDef(statefulTableOptions),
+                    showRowExpandColumn(statefulTableOptions) &&
+                        getMRT_RowExpandColumnDef(statefulTableOptions),
+                    showRowSelectionColumn(statefulTableOptions) &&
+                        getMRT_RowSelectColumnDef(statefulTableOptions),
+                    showRowNumbersColumn(statefulTableOptions) &&
+                        getMRT_RowNumbersColumnDef(statefulTableOptions),
+                ].filter(Boolean),
+                ...sourceColumns,
+                ...[
+                    showRowSpacerColumn(statefulTableOptions) &&
+                        getMRT_RowSpacerColumnDef(statefulTableOptions),
+                ].filter(Boolean),
+            ],
+            tableOptions: statefulTableOptions,
+        });
+        columnPreparationDepsRef.current = columnPreparationDeps;
+    }
+    statefulTableOptions.columns = columnDefsRef.current;
+    // if loading, generate blank rows to show skeleton loaders
+    statefulTableOptions.data = useMemo(() => (statefulTableOptions.state.isLoading ||
+        statefulTableOptions.state.showSkeletons) &&
+        !statefulTableOptions.data.length
+        ? [
+            ...Array(Math.min(statefulTableOptions.state.pagination.pageSize, 20)).fill(null),
+        ].map(() => Object.assign({}, ...getAllLeafColumnDefs(statefulTableOptions.columns).map((col) => ({
+            [getColumnId(col)]: null,
+        }))))
+        : statefulTableOptions.data, [
+        statefulTableOptions.data,
+        statefulTableOptions.state.isLoading,
+        statefulTableOptions.state.showSkeletons,
+    ]);
+    const table = useTable({
+        ...statefulTableOptions,
+        globalFilterFn: (globalFilterFn ?? 'fuzzy'),
+        // Hand TanStack-aware slices over to our external atoms — library writes
+        // (e.g. `table.setPageIndex(...)`, drag-resize) flow straight into them.
+        atoms: {
+            columnOrder: columnOrderAtom,
+            columnResizing: columnResizingAtom,
+            grouping: groupingAtom,
+            pagination: paginationAtom,
+        },
+    }, (state) => state);
+    // v9 spells the resize setter `setcolumnResizing` (lowercase 'c') because
+    // it's auto-generated from the state-key name. Expose a camelCase alias so
+    // MRT consumers don't need to know about that quirk; route writes through
+    // our owned atom directly.
+    table.setColumnResizing = columnResizingAtom.set;
+    // The v9 store doesn't track MRT-only slices, so `table.state` is missing
+    // them after `useTable` returns. Patch them in here so all MRT components
+    // can read `table.state.density`, `table.state.isFullScreen`, etc.
+    table.state = {
+        ...table.state,
+        columnFilterFns,
+        creatingRow,
+        density,
+        draggingColumn,
+        draggingRow,
+        editingCell,
+        editingRow,
+        globalFilterFn,
+        hoveredColumn,
+        hoveredRow,
+        isFullScreen,
+        showAlertBanner,
+        showColumnFilters,
+        showGlobalFilter,
+        showToolbarDropZone,
+    };
+    // v8-style `getState()` alias for any consumer that still calls it.
+    table.getState = () => table.state;
+    table.refs = {
+        bottomToolbarRef,
+        editInputRefs,
+        filterInputRefs,
+        lastSelectedRowId,
+        searchInputRef,
+        tableContainerRef,
+        tableFooterRef,
+        tableHeadCellRefs,
+        tableHeadRef,
+        tablePaperRef,
+        topToolbarRef,
+    };
+    // Setters write through atom.set (or call the user-supplied on*Change
+    // handler if one was provided so external state ownership still works).
+    // The `as any` casts bridge atom.set's overloaded signature with React's
+    // `Dispatch<SetStateAction<T>>` shape — the runtime contract is identical
+    // (both accept a value or an updater function).
+    table.setCreatingRow = (row) => {
+        let _row = row;
+        if (row === true) {
+            _row = createRow(table);
+        }
+        if (statefulTableOptions?.onCreatingRowChange) {
+            statefulTableOptions.onCreatingRowChange(_row);
+        }
+        else {
+            creatingRowAtom.set(_row);
+        }
+    };
+    table.setColumnFilterFns = (statefulTableOptions.onColumnFilterFnsChange ??
+        columnFilterFnsAtom.set);
+    table.setDensity = (statefulTableOptions.onDensityChange ??
+        densityAtom.set);
+    table.setDraggingColumn = (statefulTableOptions.onDraggingColumnChange ??
+        draggingColumnAtom.set);
+    table.setDraggingRow = (statefulTableOptions.onDraggingRowChange ??
+        draggingRowAtom.set);
+    table.setEditingCell = (statefulTableOptions.onEditingCellChange ??
+        editingCellAtom.set);
+    table.setEditingRow = (statefulTableOptions.onEditingRowChange ??
+        editingRowAtom.set);
+    table.setGlobalFilterFn = (statefulTableOptions.onGlobalFilterFnChange ??
+        globalFilterFnAtom.set);
+    table.setHoveredColumn = (statefulTableOptions.onHoveredColumnChange ??
+        hoveredColumnAtom.set);
+    table.setHoveredRow = (statefulTableOptions.onHoveredRowChange ??
+        hoveredRowAtom.set);
+    table.setIsFullScreen = (statefulTableOptions.onIsFullScreenChange ??
+        isFullScreenAtom.set);
+    table.setShowAlertBanner = (statefulTableOptions.onShowAlertBannerChange ??
+        showAlertBannerAtom.set);
+    table.setShowColumnFilters =
+        (statefulTableOptions.onShowColumnFiltersChange ??
+            showColumnFiltersAtom.set);
+    table.setShowGlobalFilter = (statefulTableOptions.onShowGlobalFilterChange ??
+        showGlobalFilterAtom.set);
+    table.setShowToolbarDropZone =
+        (statefulTableOptions.onShowToolbarDropZoneChange ??
+            showToolbarDropZoneAtom.set);
+    useMRT_Effects(table);
+    return table;
+};
+
+const useMantineReactTable = (tableOptions) => useMRT_TableInstance(useMRT_TableOptions(tableOptions));
+
+var commonClasses = {"common-toolbar-styles":"common-styles-module_common-toolbar-styles__DnjR8"};
+
+var classes$8 = {"root":"MRT_BottomToolbar-module_root__VDeWo","root-fullscreen":"MRT_BottomToolbar-module_root-fullscreen__esE15","custom-toolbar-container":"MRT_BottomToolbar-module_custom-toolbar-container__XcDRF","paginator-container":"MRT_BottomToolbar-module_paginator-container__A3eWY","paginator-container-alert-banner":"MRT_BottomToolbar-module_paginator-container-alert-banner__gyqtO"};
+
+var classes$7 = {"collapse":"MRT_ProgressBar-module_collapse__rOLJH","collapse-top":"MRT_ProgressBar-module_collapse-top__oCi0h"};
+
+const MRT_ProgressBar = ({ isTopToolbar, table, ...rest }) => {
+    const { state, options: { mantineProgressProps }, } = table;
+    const { isSaving, showProgressBars } = state;
+    const linearProgressProps = {
+        ...parseFromValuesOrFunc(mantineProgressProps, {
+            isTopToolbar,
+            table,
+        }),
+        ...rest,
+    };
+    return (jsx(Collapse, { className: clsx(classes$7.collapse, isTopToolbar && classes$7['collapse-top']), expanded: isSaving || showProgressBars, children: jsx(Progress, { animated: true, "aria-busy": "true", "aria-label": "Loading", radius: 0, value: 100, ...linearProgressProps }) }));
+};
+
+var classes$6 = {"root":"MRT_TablePagination-module_root__yZ8pm","pagesize":"MRT_TablePagination-module_pagesize__-vmTn","with-top-margin":"MRT_TablePagination-module_with-top-margin__aM5-m"};
+
+const defaultRowsPerPage = [5, 10, 15, 20, 25, 30, 50, 100].map((x) => x.toString());
+const MRT_TablePagination = ({ position = 'bottom', table, ...props }) => {
+    const { getPrePaginatedRowModel, state, options: { enableToolbarInternalActions, icons: { IconChevronLeft, IconChevronLeftPipe, IconChevronRight, IconChevronRightPipe, }, localization, mantinePaginationProps, paginationDisplayMode, rowCount, }, setPageIndex, setPageSize, } = table;
+    const { pagination: { pageIndex = 0, pageSize = 10 }, showGlobalFilter, } = state;
+    const paginationProps = {
+        ...parseFromValuesOrFunc(mantinePaginationProps, {
+            table,
+        }),
+        ...props,
+    };
+    const totalRowCount = rowCount ?? getPrePaginatedRowModel().rows.length;
+    const numberOfPages = Math.ceil(totalRowCount / pageSize);
+    const showFirstLastPageButtons = numberOfPages > 2;
+    const firstRowIndex = pageIndex * pageSize;
+    const lastRowIndex = Math.min(pageIndex * pageSize + pageSize, totalRowCount);
+    const { rowsPerPageOptions = defaultRowsPerPage, showRowsPerPage = true, withEdges = showFirstLastPageButtons, ...rest } = paginationProps ?? {};
+    const needsTopMargin = position === 'top' && enableToolbarInternalActions && !showGlobalFilter;
+    return (jsxs(Box, { className: clsx('mrt-table-pagination', classes$6.root, needsTopMargin && classes$6['with-top-margin']), children: [paginationProps?.showRowsPerPage !== false && (jsxs(Group, { gap: "xs", children: [jsx(Text, { id: "rpp-label", children: localization.rowsPerPage }), jsx(Select, { allowDeselect: false, "aria-labelledby": "rpp-label", className: classes$6.pagesize, data: paginationProps?.rowsPerPageOptions ?? defaultRowsPerPage, onChange: (value) => setPageSize(+value), value: pageSize.toString() })] })), paginationDisplayMode === 'pages' ? (jsx(Pagination, { firstIcon: IconChevronLeftPipe, lastIcon: IconChevronRightPipe, nextIcon: IconChevronRight, onChange: (newPageIndex) => setPageIndex(newPageIndex - 1), previousIcon: IconChevronLeft, total: numberOfPages, value: pageIndex + 1, withEdges: withEdges, ...rest })) : paginationDisplayMode === 'default' ? (jsxs(Fragment, { children: [jsx(Text, { children: `${lastRowIndex === 0 ? 0 : (firstRowIndex + 1).toLocaleString()}-${lastRowIndex.toLocaleString()} ${localization.of} ${totalRowCount.toLocaleString()}` }), jsxs(Group, { gap: 6, children: [withEdges && (jsx(ActionIcon, { "aria-label": localization.goToFirstPage, color: "gray", disabled: pageIndex <= 0, onClick: () => setPageIndex(0), variant: "subtle", children: jsx(IconChevronLeftPipe, {}) })), jsx(ActionIcon, { "aria-label": localization.goToPreviousPage, color: "gray", disabled: pageIndex <= 0, onClick: () => setPageIndex(pageIndex - 1), variant: "subtle", children: jsx(IconChevronLeft, {}) }), jsx(ActionIcon, { "aria-label": localization.goToNextPage, color: "gray", disabled: lastRowIndex >= totalRowCount, onClick: () => setPageIndex(pageIndex + 1), variant: "subtle", children: jsx(IconChevronRight, {}) }), withEdges && (jsx(ActionIcon, { "aria-label": localization.goToLastPage, color: "gray", disabled: lastRowIndex >= totalRowCount, onClick: () => setPageIndex(numberOfPages - 1), variant: "subtle", children: jsx(IconChevronRightPipe, {}) }))] })] })) : null] }));
+};
+
+var classes$5 = {"root":"MRT_ToolbarDropZone-module_root__eGTXb","hovered":"MRT_ToolbarDropZone-module_hovered__g7PeJ"};
+
+const MRT_ToolbarDropZone = ({ table, ...rest }) => {
+    const { state, options: { enableGrouping, localization }, setHoveredColumn, setShowToolbarDropZone, } = table;
+    const { draggingColumn, grouping, hoveredColumn, showToolbarDropZone } = state;
+    const handleDragEnter = (_event) => {
+        setHoveredColumn({ id: 'drop-zone' });
+    };
+    useEffect(() => {
+        if (table.options.state?.showToolbarDropZone !== undefined) {
+            setShowToolbarDropZone(!!enableGrouping &&
+                !!draggingColumn &&
+                draggingColumn.columnDef.enableGrouping !== false &&
+                !grouping.includes(draggingColumn.id));
+        }
+    }, [enableGrouping, draggingColumn, grouping]);
+    return (jsx(Transition, { mounted: showToolbarDropZone, transition: "fade", children: () => (jsx(Flex, { className: clsx('mrt-toolbar-dropzone', classes$5.root, hoveredColumn?.id === 'drop-zone' && classes$5.hovered), onDragEnter: handleDragEnter, ...rest, children: jsx(Text, { children: localization.dropToGroupBy.replace('{column}', draggingColumn?.columnDef?.header ?? '') }) })) }));
+};
+
+const MRT_BottomToolbar = ({ table, ...rest }) => {
+    const { state, options: { enablePagination, mantineBottomToolbarProps, positionPagination, positionToolbarAlertBanner, positionToolbarDropZone, renderBottomToolbarCustomActions, }, refs: { bottomToolbarRef }, } = table;
+    const { isFullScreen } = state;
+    const isMobile = useMediaQuery('(max-width: 720px)');
+    const toolbarProps = {
+        ...parseFromValuesOrFunc(mantineBottomToolbarProps, {
+            table,
+        }),
+        ...rest,
+    };
+    const stackAlertBanner = isMobile || !!renderBottomToolbarCustomActions;
+    return (jsxs(Box, { ...toolbarProps, className: clsx('mrt-bottom-toolbar', classes$8.root, commonClasses['common-toolbar-styles'], isFullScreen && classes$8['root-fullscreen'], toolbarProps?.className), ref: (node) => {
+            if (node) {
+                bottomToolbarRef.current = node;
+                if (toolbarProps?.ref) {
+                    toolbarProps.ref.current = node;
+                }
+            }
+        }, children: [jsx(MRT_ProgressBar, { isTopToolbar: false, table: table }), positionToolbarAlertBanner === 'bottom' && (jsx(MRT_ToolbarAlertBanner, { stackAlertBanner: stackAlertBanner, table: table })), ['both', 'bottom'].includes(positionToolbarDropZone ?? '') && (jsx(MRT_ToolbarDropZone, { table: table })), jsxs(Box, { className: classes$8['custom-toolbar-container'], children: [renderBottomToolbarCustomActions ? (renderBottomToolbarCustomActions({ table })) : (jsx("span", {})), jsx(Box, { className: clsx(classes$8['paginator-container'], stackAlertBanner && classes$8['paginator-container-alert-banner']), children: enablePagination &&
+                            ['both', 'bottom'].includes(positionPagination ?? '') && (jsx(MRT_TablePagination, { position: "bottom", table: table })) })] })] }));
+};
+
+var classes$4 = {"root":"MRT_TopToolbar-module_root__r4-V9","root-fullscreen":"MRT_TopToolbar-module_root-fullscreen__3itT8","actions-container":"MRT_TopToolbar-module_actions-container__-uL0u","actions-container-stack-alert":"MRT_TopToolbar-module_actions-container-stack-alert__OYDL6"};
+
+var classes$3 = {"root":"MRT_ToolbarInternalButtons-module_root__NKoUG"};
+
+const MRT_ToolbarInternalButtons = ({ table, ...rest }) => {
+    const { options: { columnFilterDisplayMode, enableColumnFilters, enableColumnOrdering, enableColumnPinning, enableDensityToggle, enableFilters, enableFullScreenToggle, enableGlobalFilter, enableHiding, initialState, renderToolbarInternalActions, }, } = table;
+    return (jsx(Flex, { ...rest, className: clsx('mrt-toolbar-internal-buttons', classes$3.root, rest?.className), children: renderToolbarInternalActions?.({ table }) ?? (jsxs(Fragment, { children: [enableFilters &&
+                    enableGlobalFilter &&
+                    !initialState?.showGlobalFilter && (jsx(MRT_ToggleGlobalFilterButton, { table: table })), enableFilters &&
+                    enableColumnFilters &&
+                    columnFilterDisplayMode !== 'popover' && (jsx(MRT_ToggleFiltersButton, { table: table })), (enableHiding || enableColumnOrdering || enableColumnPinning) && (jsx(MRT_ShowHideColumnsButton, { table: table })), enableDensityToggle && (jsx(MRT_ToggleDensePaddingButton, { table: table })), enableFullScreenToggle && (jsx(MRT_ToggleFullScreenButton, { table: table }))] })) }));
+};
+
+const MRT_TopToolbar = ({ table, ...rest }) => {
+    const { state, options: { enableGlobalFilter, enablePagination, enableToolbarInternalActions, mantineTopToolbarProps, positionGlobalFilter, positionPagination, positionToolbarAlertBanner, positionToolbarDropZone, renderTopToolbarCustomActions, }, refs: { topToolbarRef }, } = table;
+    const { isFullScreen, showGlobalFilter } = state;
+    const isMobile = useMediaQuery('(max-width:720px)');
+    const isTablet = useMediaQuery('(max-width:1024px)');
+    const toolbarProps = {
+        ...parseFromValuesOrFunc(mantineTopToolbarProps, { table }),
+        ...rest,
+    };
+    const stackAlertBanner = isMobile ||
+        !!renderTopToolbarCustomActions ||
+        (showGlobalFilter && isTablet);
+    const globalFilterProps = {
+        style: !isTablet
+            ? {
+                zIndex: 3,
+            }
+            : undefined,
+        table,
+    };
+    return (jsxs(Box, { ...toolbarProps, className: clsx(commonClasses['common-toolbar-styles'], classes$4['root'], isFullScreen && classes$4['root-fullscreen'], toolbarProps?.className), ref: (node) => {
+            if (node) {
+                topToolbarRef.current = node;
+                if (toolbarProps?.ref) {
+                    toolbarProps.ref.current = node;
+                }
+            }
+        }, children: [positionToolbarAlertBanner === 'top' && (jsx(MRT_ToolbarAlertBanner, { stackAlertBanner: stackAlertBanner, table: table })), ['both', 'top'].includes(positionToolbarDropZone ?? '') && (jsx(MRT_ToolbarDropZone, { table: table })), jsxs(Flex, { className: clsx(classes$4['actions-container'], stackAlertBanner && classes$4['actions-container-stack-alert']), children: [enableGlobalFilter && positionGlobalFilter === 'left' && (jsx(MRT_GlobalFilterTextInput, { ...globalFilterProps })), renderTopToolbarCustomActions?.({ table }) ?? jsx("span", {}), enableToolbarInternalActions ? (jsxs(Flex, { justify: 'end', wrap: 'wrap-reverse', children: [enableGlobalFilter && positionGlobalFilter === 'right' && (jsx(MRT_GlobalFilterTextInput, { ...globalFilterProps })), jsx(MRT_ToolbarInternalButtons, { table: table })] })) : (enableGlobalFilter &&
+                        positionGlobalFilter === 'right' && (jsx(MRT_GlobalFilterTextInput, { ...globalFilterProps })))] }), enablePagination &&
+                ['both', 'top'].includes(positionPagination ?? '') && (jsx(Flex, { justify: "end", children: jsx(MRT_TablePagination, { position: "top", table: table }) })), jsx(MRT_ProgressBar, { isTopToolbar: true, table: table })] }));
+};
+
+const MRT_EditRowModal = ({ open, table, ...rest }) => {
+    const { state, options: { mantineCreateRowModalProps, mantineEditRowModalProps, onCreatingRowCancel, onEditingRowCancel, renderCreateRowModalContent, renderEditRowModalContent, }, setCreatingRow, setEditingRow, } = table;
+    const { creatingRow, editingRow } = state;
+    const row = (creatingRow ?? editingRow);
+    const arg = { row, table };
+    const modalProps = {
+        ...parseFromValuesOrFunc(mantineEditRowModalProps, arg),
+        ...(creatingRow && parseFromValuesOrFunc(mantineCreateRowModalProps, arg)),
+        ...rest,
+    };
+    const internalEditComponents = row
+        .getAllCells()
+        .filter((cell) => cell.column.columnDef.columnDefType === 'data')
+        .map((cell) => (jsx(MRT_EditCellTextInput, { cell: cell, table: table }, cell.id)));
+    const handleCancel = () => {
+        if (creatingRow) {
+            onCreatingRowCancel?.({ row, table });
+            setCreatingRow(null);
+        }
+        else {
+            onEditingRowCancel?.({ row, table });
+            setEditingRow(null);
+        }
+        row._valuesCache = {}; // reset values cache
+        modalProps.onClose?.();
+    };
+    return (createElement(Modal, { opened: open, withCloseButton: false, ...modalProps, key: row.id, onClose: handleCancel }, ((creatingRow &&
+        renderCreateRowModalContent?.({
+            internalEditComponents,
+            row,
+            table,
+        })) ||
+        renderEditRowModalContent?.({
+            internalEditComponents,
+            row,
+            table,
+        })) ?? (jsxs(Fragment, { children: [jsx("form", { onSubmit: (e) => e.preventDefault(), children: jsx(Stack, { gap: "lg", pb: 24, pt: 16, children: internalEditComponents }) }), jsx(Flex, { justify: "flex-end", children: jsx(MRT_EditActionButtons, { row: row, table: table, variant: "text" }) })] }))));
+};
+
+const useMRT_ColumnVirtualizer = (table) => {
+    const { getStartLeafColumns, getEndLeafColumns, state, getVisibleLeafColumns, options: { columnVirtualizerInstanceRef, columnVirtualizerOptions, enableColumnPinning, enableColumnVirtualization, }, refs: { tableContainerRef }, } = table;
+    const { columnPinning, draggingColumn } = state;
+    if (!enableColumnVirtualization)
+        return undefined;
+    const columnVirtualizerProps = parseFromValuesOrFunc(columnVirtualizerOptions, {
+        table,
+    });
+    const visibleColumns = getVisibleLeafColumns();
+    const [leftPinnedIndexes, rightPinnedIndexes] = useMemo(() => enableColumnPinning
+        ? [
+            getStartLeafColumns().map((c) => c.getPinnedIndex()),
+            getEndLeafColumns()
+                .map((column) => visibleColumns.length - column.getPinnedIndex() - 1)
+                .sort((a, b) => a - b),
+        ]
+        : [[], []], [visibleColumns.length, columnPinning, enableColumnPinning]);
+    const numPinnedLeft = leftPinnedIndexes.length;
+    const numPinnedRight = rightPinnedIndexes.length;
+    const draggingColumnIndex = useMemo(() => draggingColumn?.id
+        ? visibleColumns.findIndex((c) => c.id === draggingColumn?.id)
+        : undefined, [draggingColumn?.id]);
+    const columnVirtualizer = useVirtualizer({
+        count: visibleColumns.length,
+        estimateSize: (index) => visibleColumns[index].getSize(),
+        getScrollElement: () => tableContainerRef.current,
+        horizontal: true,
+        overscan: 3,
+        rangeExtractor: useCallback((range) => {
+            const newIndexes = extraIndexRangeExtractor(range, draggingColumnIndex);
+            if (!numPinnedLeft && !numPinnedRight) {
+                return newIndexes;
+            }
+            return [
+                ...new Set([
+                    ...leftPinnedIndexes,
+                    ...newIndexes,
+                    ...rightPinnedIndexes,
+                ]),
+            ];
+        }, [leftPinnedIndexes, rightPinnedIndexes, draggingColumnIndex]),
+        ...columnVirtualizerProps,
+    });
+    const virtualColumns = columnVirtualizer.getVirtualItems();
+    columnVirtualizer.virtualColumns = virtualColumns;
+    const numColumns = virtualColumns.length;
+    if (numColumns) {
+        const totalSize = columnVirtualizer.getTotalSize();
+        const leftNonPinnedStart = virtualColumns[numPinnedLeft]?.start || 0;
+        const leftNonPinnedEnd = virtualColumns[leftPinnedIndexes.length - 1]?.end || 0;
+        const rightNonPinnedStart = virtualColumns[numColumns - numPinnedRight]?.start || 0;
+        const rightNonPinnedEnd = virtualColumns[numColumns - numPinnedRight - 1]?.end || 0;
+        columnVirtualizer.virtualPaddingLeft = leftNonPinnedStart - leftNonPinnedEnd;
+        columnVirtualizer.virtualPaddingRight =
+            totalSize -
+                rightNonPinnedEnd -
+                (numPinnedRight ? totalSize - rightNonPinnedStart : 0);
+    }
+    if (columnVirtualizerInstanceRef) {
+        // @ts-ignore - TODO: fix this
+        columnVirtualizerInstanceRef.current = columnVirtualizer;
+    }
+    return columnVirtualizer;
+};
+
+var classes$2 = {"root":"MRT_Table-module_root__ms2uS","root-grid":"MRT_Table-module_root-grid__2Pynz"};
+
+const MRT_Table = ({ table, ...rest }) => {
+    const { getFlatHeaders, state, options: { columns, enableTableFooter, enableTableHead, layoutMode, mantineTableProps, memoMode, }, } = table;
+    const { columnSizing, columnResizing, columnVisibility, density } = state;
+    const tableProps = {
+        highlightOnHover: true,
+        horizontalSpacing: density,
+        verticalSpacing: density,
+        ...parseFromValuesOrFunc(mantineTableProps, { table }),
+        ...rest,
+    };
+    const columnSizeVars = useMemo(() => {
+        const headers = getFlatHeaders();
+        const colSizes = {};
+        for (let i = 0; i < headers.length; i++) {
+            const header = headers[i];
+            const colSize = header.getSize();
+            colSizes[`--header-${parseCSSVarId(header.id)}-size`] = colSize;
+            colSizes[`--col-${parseCSSVarId(header.column.id)}-size`] = colSize;
+        }
+        return colSizes;
+    }, [columns, columnSizing, columnResizing, columnVisibility]);
+    const columnVirtualizer = useMRT_ColumnVirtualizer(table);
+    const commonTableGroupProps = {
+        columnVirtualizer,
+        table,
+    };
+    const { colorScheme } = useMantineColorScheme();
+    const { stripedColor } = tableProps;
+    return (jsxs(Table, { className: clsx('mrt-table', classes$2.root, layoutMode?.startsWith('grid') && classes$2['root-grid'], tableProps.className), ...tableProps, __vars: {
+            ...columnSizeVars,
+            '--mrt-striped-row-background-color': stripedColor,
+            '--mrt-striped-row-hover-background-color': stripedColor
+                ? colorScheme === 'dark'
+                    ? lighten(stripedColor, 0.08)
+                    : darken(stripedColor, 0.12)
+                : undefined,
+            ...tableProps.__vars,
+        }, children: [enableTableHead && jsx(MRT_TableHead, { ...commonTableGroupProps }), memoMode === 'table-body' || columnResizing.isResizingColumn ? (jsx(Memo_MRT_TableBody, { ...commonTableGroupProps, tableProps: tableProps })) : (jsx(MRT_TableBody, { ...commonTableGroupProps, tableProps: tableProps })), enableTableFooter && jsx(MRT_TableFooter, { ...commonTableGroupProps })] }));
+};
+
+var classes$1 = {"root":"MRT_TableContainer-module_root__JIsGB","root-sticky":"MRT_TableContainer-module_root-sticky__uC4qx","root-fullscreen":"MRT_TableContainer-module_root-fullscreen__aM8Jg"};
+
+const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+const MRT_TableContainer = ({ table, ...rest }) => {
+    const { state, options: { createDisplayMode, editDisplayMode, enableStickyHeader, mantineLoadingOverlayProps, mantineTableContainerProps, }, refs: { bottomToolbarRef, tableContainerRef, topToolbarRef }, } = table;
+    const { creatingRow, editingRow, isFullScreen, isLoading, showLoadingOverlay, } = state;
+    const [totalToolbarHeight, setTotalToolbarHeight] = useState(0);
+    const tableContainerProps = {
+        ...parseFromValuesOrFunc(mantineTableContainerProps, { table }),
+        ...rest,
+    };
+    const loadingOverlayProps = parseFromValuesOrFunc(mantineLoadingOverlayProps, { table });
+    useIsomorphicLayoutEffect(() => {
+        const topToolbarHeight = typeof document !== 'undefined'
+            ? (topToolbarRef.current?.offsetHeight ?? 0)
+            : 0;
+        const bottomToolbarHeight = typeof document !== 'undefined'
+            ? (bottomToolbarRef?.current?.offsetHeight ?? 0)
+            : 0;
+        setTotalToolbarHeight(topToolbarHeight + bottomToolbarHeight);
+    });
+    const createModalOpen = createDisplayMode === 'modal' && creatingRow;
+    const editModalOpen = editDisplayMode === 'modal' && editingRow;
+    return (jsxs(Box, { ...tableContainerProps, __vars: {
+            '--mrt-top-toolbar-height': `${totalToolbarHeight}`,
+            ...tableContainerProps?.__vars,
+        }, className: clsx('mrt-table-container', classes$1.root, enableStickyHeader && classes$1['root-sticky'], isFullScreen && classes$1['root-fullscreen'], tableContainerProps?.className), ref: (node) => {
+            if (node) {
+                tableContainerRef.current = node;
+                if (tableContainerProps?.ref) {
+                    // @ts-ignore
+                    tableContainerProps.ref.current = node;
+                }
+            }
+        }, children: [jsx(LoadingOverlay, { visible: isLoading || showLoadingOverlay, zIndex: 2, ...loadingOverlayProps }), jsx(MRT_Table, { table: table }), (createModalOpen || editModalOpen) && (jsx(MRT_EditRowModal, { open: true, table: table }))] }));
+};
+
+var classes = {"root":"MRT_TablePaper-module_root__q0v5L"};
+
+const MRT_TablePaper = ({ table, ...rest }) => {
+    const { state, options: { enableBottomToolbar, enableTopToolbar, mantinePaperProps, renderBottomToolbar, renderTopToolbar, }, refs: { tablePaperRef }, } = table;
+    const { isFullScreen } = state;
+    const tablePaperProps = {
+        ...parseFromValuesOrFunc(mantinePaperProps, { table }),
+        ...rest,
+    };
+    return (jsxs(Paper, { shadow: "xs", withBorder: true, ...tablePaperProps, className: clsx('mrt-table-paper', classes.root, isFullScreen && 'mrt-table-paper-fullscreen', tablePaperProps?.className), ref: (ref) => {
+            tablePaperRef.current = ref;
+            if (tablePaperProps?.ref) {
+                tablePaperProps.ref.current = ref;
+            }
+        }, 
+        // rare case where we should use inline styles to guarantee highest specificity
+        style: (theme) => ({
+            zIndex: isFullScreen ? 200 : undefined,
+            ...parseFromValuesOrFunc(tablePaperProps?.style, theme),
+            ...(isFullScreen
+                ? {
+                    border: 0,
+                    borderRadius: 0,
+                    bottom: 0,
+                    height: '100vh',
+                    left: 0,
+                    margin: 0,
+                    maxHeight: '100vh',
+                    maxWidth: '100vw',
+                    padding: 0,
+                    position: 'fixed',
+                    right: 0,
+                    top: 0,
+                    width: '100vw',
+                }
+                : null),
+        }), children: [enableTopToolbar &&
+                (parseFromValuesOrFunc(renderTopToolbar, { table }) ?? (jsx(MRT_TopToolbar, { table: table }))), jsx(MRT_TableContainer, { table: table }), enableBottomToolbar &&
+                (parseFromValuesOrFunc(renderBottomToolbar, { table }) ?? (jsx(MRT_BottomToolbar, { table: table })))] }));
+};
+
+const isTableInstanceProp = (props) => props.table !== undefined;
+const MantineReactTable = (props) => {
+    let table;
+    if (isTableInstanceProp(props)) {
+        table = props.table;
+    }
+    else {
+        table = useMantineReactTable(props);
+    }
+    return jsx(MRT_TablePaper, { table: table });
+};
+
+export { MRT_BottomToolbar, MRT_ColumnActionMenu, MRT_ColumnPinningButtons, MRT_CopyButton, MRT_DefaultColumn, MRT_DefaultDisplayColumn, MRT_EditActionButtons, MRT_EditCellTextInput, MRT_EditRowModal, MRT_ExpandAllButton, MRT_ExpandButton, MRT_FilterCheckbox, MRT_FilterFns, MRT_FilterOptionMenu, MRT_FilterRangeFields, MRT_FilterRangeSlider, MRT_FilterTextInput, MRT_GlobalFilterTextInput, MRT_GrabHandleButton, MRT_ProgressBar, MRT_RowActionMenu, MRT_RowAggregationFns, MRT_RowPinButton, MRT_SelectCheckbox, MRT_ShowHideColumnsButton, MRT_ShowHideColumnsMenu, MRT_ShowHideColumnsMenuItems, MRT_SortFns, MRT_Table, MRT_TableBody, MRT_TableBodyCell, MRT_TableBodyCellValue, MRT_TableBodyEmptyRow, MRT_TableBodyRow, MRT_TableBodyRowGrabHandle, MRT_TableBodyRowPinButton, MRT_TableContainer, MRT_TableDetailPanel, MRT_TableFooter, MRT_TableFooterCell, MRT_TableFooterRow, MRT_TableHead, MRT_TableHeadCell, MRT_TableHeadCellFilterContainer, MRT_TableHeadCellFilterLabel, MRT_TableHeadCellGrabHandle, MRT_TableHeadCellResizeHandle, MRT_TableHeadCellSortLabel, MRT_TableHeadRow, MRT_TablePagination, MRT_TablePaper, MRT_ToggleDensePaddingButton, MRT_ToggleFiltersButton, MRT_ToggleFullScreenButton, MRT_ToggleGlobalFilterButton, MRT_ToggleRowActionMenuButton, MRT_ToolbarAlertBanner, MRT_ToolbarDropZone, MRT_ToolbarInternalButtons, MRT_TopToolbar, MantineReactTable, Memo_MRT_TableBody, Memo_MRT_TableBodyCell, Memo_MRT_TableBodyRow, createMRTColumnHelper, createRow, dataVariable, defaultDisplayColumnProps, flexRender, getAllLeafColumnDefs, getCanRankRows, getColumnId, getDefaultColumnFilterFn, getDefaultColumnOrderIds, getIsRankingRows, getIsRowSelected, getLeadingDisplayColumnIds, getMRT_RowSelectionHandler, getMRT_Rows, getMRT_SelectAllHandler, getPrimaryColor, getPrimaryShade, getTrailingDisplayColumnIds, localizedFilterOption, mrtFilterOptions, parseCSSVarId, parseFromValuesOrFunc, prepareColumns, rankGlobalFuzzy, reorderColumn, showRowActionsColumn, showRowDragColumn, showRowExpandColumn, showRowNumbersColumn, showRowPinningColumn, showRowSelectionColumn, showRowSpacerColumn, useMRT_ColumnVirtualizer, useMRT_Effects, useMRT_RowVirtualizer, useMRT_Rows, useMRT_TableInstance, useMRT_TableOptions, useMantineReactTable };
+//# sourceMappingURL=index.js.map