@gridkitjs/core 0.10.0 → 0.11.0

package/dist/index.js

@@ -63,13 +63,23 @@ function getColumnId(column) {
 function resolveRowId(row, index, getRowId) {
   return getRowId?.(row, index) ?? String(index);
 }
+function labelFromField(field) {
+  return field.split(".").join(" ");
+}
 function resolveColumnLabel(column) {
   const { headerTemplate } = column;
   if (headerTemplate === void 0) {
-    return column.field.split(".").join(" ");
+    return column.header ?? labelFromField(column.field);
   }
   return typeof headerTemplate === "function" ? headerTemplate() : headerTemplate;
 }
+function resolveColumnHeaderText(column) {
+  if (column.header !== void 0) {
+    return column.header;
+  }
+  const label = resolveColumnLabel(column);
+  return typeof label === "string" ? label : labelFromField(column.field);
+}
 function buildKeyShortcuts(capabilities) {
   return [
     capabilities.reorderable ? "Control+ArrowLeft Control+ArrowRight" : "",
@@ -87,341 +97,675 @@ function accessDotted(obj, path) {
   return path.split(".").reduce((value, key) => isNested(value) ? value[key] : void 0, obj);
 }
 
-// src/util/navigation.ts
-var HEADER_ROW = -1;
-function clampFocus(focus, rowCount, columnCount) {
-  return {
-    rowIndex: Math.min(Math.max(focus.rowIndex, HEADER_ROW), rowCount - 1),
-    columnIndex: Math.min(
-      Math.max(focus.columnIndex, 0),
-      Math.max(columnCount - 1, 0)
-    )
-  };
+// src/util/sorting.ts
+function isEmpty(value) {
+  return value === null || value === void 0;
 }
-function noRowsSkippable() {
-  return false;
+function toTime(value) {
+  return value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
 }
-function skipSkippableRows(rowIndex, direction, rowCount, isSkippableRow, fallback) {
-  let next = rowIndex;
-  while (next >= 0 && next < rowCount && isSkippableRow(next)) {
-    const stepped = next + direction;
-    if (stepped < HEADER_ROW || stepped >= rowCount) {
-      return fallback;
-    }
-    next = stepped;
+function compareValues(a, b, type) {
+  if (isEmpty(a)) {
+    return isEmpty(b) ? 0 : 1;
   }
-  return next;
-}
-function nextFocusForKey(key, modifiers, focus, rowCount, columnCount, pageSize, isSkippableRow = noRowsSkippable) {
-  if (modifiers.altKey) {
-    return null;
+  if (isEmpty(b)) {
+    return -1;
   }
-  const { rowIndex, columnIndex } = focus;
-  switch (key) {
-    case "ArrowLeft":
-      if (modifiers.ctrlKey) return null;
-      return { rowIndex, columnIndex: columnIndex - 1 };
-    case "ArrowRight":
-      if (modifiers.ctrlKey) return null;
-      return { rowIndex, columnIndex: columnIndex + 1 };
-    case "ArrowUp":
-      return {
-        rowIndex: skipSkippableRows(
-          rowIndex - 1,
-          -1,
-          rowCount,
-          isSkippableRow,
-          rowIndex
-        ),
-        columnIndex
-      };
-    case "ArrowDown":
-      return {
-        rowIndex: skipSkippableRows(
-          rowIndex + 1,
-          1,
-          rowCount,
-          isSkippableRow,
-          rowIndex
-        ),
-        columnIndex
-      };
-    // Ctrl takes Home and End to the grid's ends rather than the row's, which
-    // is the one place Ctrl is navigation rather than reorder.
-    case "Home":
-      return modifiers.ctrlKey ? { rowIndex: HEADER_ROW, columnIndex: 0 } : { rowIndex, columnIndex: 0 };
-    case "End":
-      return modifiers.ctrlKey ? {
-        rowIndex: skipSkippableRows(
-          rowCount - 1,
-          -1,
-          rowCount,
-          isSkippableRow,
-          rowIndex
-        ),
-        columnIndex: columnCount - 1
-      } : { rowIndex, columnIndex: columnCount - 1 };
-    case "PageUp":
-      return {
-        rowIndex: skipSkippableRows(
-          rowIndex - pageSize,
-          -1,
-          rowCount,
-          isSkippableRow,
-          rowIndex
-        ),
-        columnIndex
-      };
-    case "PageDown":
-      return {
-        rowIndex: skipSkippableRows(
-          rowIndex + pageSize,
-          1,
-          rowCount,
-          isSkippableRow,
-          rowIndex
-        ),
-        columnIndex
-      };
+  switch (type) {
+    case "number":
+    case "decimal":
+    case "currency":
+    case "percent":
+      return Number(a) - Number(b);
+    case "boolean":
+      return Number(Boolean(a)) - Number(Boolean(b));
+    case "date":
+    case "dateTime":
+    case "time":
+      return toTime(a) - toTime(b);
     default:
-      return null;
+      return String(a).localeCompare(String(b));
   }
 }
-
-// src/util/ordering.ts
-function applyColumnOrder(columns, order) {
-  if (order.length === 0) {
-    return columns;
-  }
-  const byId = new Map(columns.map((column) => [getColumnId(column), column]));
-  const listed = order.map((id) => byId.get(id)).filter((column) => column !== void 0);
-  const taken = new Set(listed.map((column) => getColumnId(column)));
-  return [
-    ...listed,
-    ...columns.filter((column) => !taken.has(getColumnId(column)))
-  ];
+function sortDirectionFor(sort, columnId) {
+  return sort.find((entry) => entry.columnId === columnId)?.direction ?? null;
 }
-function moveColumnBefore(orderedIds, movedId, beforeId) {
-  if (movedId === beforeId || !orderedIds.includes(movedId)) {
-    return orderedIds;
+function sortPriorityFor(sort, columnId) {
+  const index = sort.findIndex((entry) => entry.columnId === columnId);
+  return index === -1 ? null : index + 1;
+}
+function toggleColumnSort(sort, columnId, options) {
+  const index = sort.findIndex((entry) => entry.columnId === columnId);
+  const isSoleEntry = sort.length === 1 && index === 0;
+  if (!options.stack && !isSoleEntry) {
+    return [{ columnId, direction: "asc" }];
   }
-  const without = orderedIds.filter((id) => id !== movedId);
-  const target = beforeId === null ? without.length : without.indexOf(beforeId);
-  if (target === -1) {
-    return orderedIds;
+  const current = index === -1 ? void 0 : sort[index]?.direction;
+  const next = current === void 0 ? "asc" : current === "asc" ? "desc" : null;
+  if (next === null) {
+    return sort.filter((entry) => entry.columnId !== columnId);
   }
-  const next = [...without];
-  next.splice(target, 0, movedId);
-  return next.every((id, index) => id === orderedIds[index]) ? orderedIds : next;
-}
-function movesColumn(orderedIds, movedId, beforeId) {
-  return moveColumnBefore(orderedIds, movedId, beforeId) !== orderedIds;
-}
-function resolveDropBefore(orderedIds, targetId, side) {
-  if (side === "before") {
-    return targetId;
+  if (index === -1) {
+    return [...sort, { columnId, direction: next }];
   }
-  const index = orderedIds.indexOf(targetId);
-  return index === -1 ? null : orderedIds[index + 1] ?? null;
+  return sort.map(
+    (entry, i) => i === index ? { columnId, direction: next } : entry
+  );
 }
-function resolveKeyboardDropTarget(orderedIds, columnId, direction) {
-  const index = orderedIds.indexOf(columnId);
-  if (index === -1) {
-    return void 0;
+function sortRows(rows, sort, columns) {
+  if (sort.length === 0) {
+    return rows;
   }
-  const targetIndex = direction === -1 ? index - 1 : index + 2;
-  if (targetIndex < 0) {
-    return void 0;
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const active = sort.filter((entry) => byId.has(entry.columnId));
+  if (active.length === 0) {
+    return rows;
   }
-  return orderedIds[targetIndex] ?? null;
+  const sorted = [...rows].sort((a, b) => {
+    for (const { columnId, direction } of active) {
+      const column = byId.get(columnId);
+      if (column === void 0) {
+        continue;
+      }
+      const left = accessDotted(a.row, column.field);
+      const right = accessDotted(b.row, column.field);
+      const leftEmpty = isEmpty(left);
+      const rightEmpty = isEmpty(right);
+      if (leftEmpty || rightEmpty) {
+        if (leftEmpty && rightEmpty) {
+          continue;
+        }
+        return leftEmpty ? 1 : -1;
+      }
+      const result = compareValues(left, right, column.type);
+      if (result !== 0) {
+        return direction === "asc" ? result : -result;
+      }
+    }
+    return 0;
+  });
+  return sorted.map(
+    (row, index) => row.rowIndex === index ? row : { ...row, rowIndex: index }
+  );
 }
 
-// src/util/selection.ts
-var NO_CHANGE = { added: [], removed: [] };
-function sameSelection(a, b) {
-  return a.length === b.length && a.every((id, index) => id === b[index]);
+// src/util/grouping.ts
+function groupRowId(path) {
+  return JSON.stringify(path);
 }
-function toggleSelection(selection, id, mode) {
-  if (mode === false) {
-    return selection;
+function bucketKey(value) {
+  if (value === null || value === void 0) {
+    return "\0empty";
   }
-  if (selection.includes(id)) {
-    return selection.filter((selectedId) => selectedId !== id);
+  if (value instanceof Date) {
+    return `\0date:${String(value.getTime())}`;
   }
-  return mode === "single" ? [id] : [...selection, id];
-}
-function selectOnly(selection, id, mode) {
-  if (mode === false) {
-    return selection;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return `\0${typeof value}:${String(value)}`;
+    case "function":
+      return "\0function";
+    default:
+      return `\0object:${JSON.stringify(value)}`;
   }
-  return selection.length === 1 && selection[0] === id ? selection : [id];
 }
-function selectRange(selection, orderedIds, anchorId, focusId, mode) {
-  if (mode !== "multiple") {
-    return selectOnly(selection, focusId, mode);
-  }
-  const anchor = orderedIds.indexOf(anchorId);
-  const focus = orderedIds.indexOf(focusId);
-  if (anchor === -1 || focus === -1) {
-    return selection;
-  }
-  const next = orderedIds.slice(
-    Math.min(anchor, focus),
-    Math.max(anchor, focus) + 1
-  );
-  return sameSelection(selection, next) ? selection : next;
-}
-function selectAll(selection, orderedIds, mode) {
-  if (mode !== "multiple") {
-    return selection;
-  }
-  return sameSelection(selection, orderedIds) ? selection : orderedIds;
-}
-function clearSelection(selection) {
-  return selection.length === 0 ? selection : [];
-}
-function diffSelection(previous, next) {
-  if (previous === next) {
-    return NO_CHANGE;
+function partitionByValue(rows, column, direction) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = accessDotted(row.row, column.field);
+    const key = bucketKey(value);
+    const bucket = buckets.get(key);
+    if (bucket === void 0) {
+      buckets.set(key, { value, rows: [row] });
+    } else {
+      bucket.rows.push(row);
+    }
   }
-  const before = new Set(previous);
-  const after = new Set(next);
-  return {
-    added: next.filter((id) => !before.has(id)),
-    removed: previous.filter((id) => !after.has(id))
-  };
+  const groups = [...buckets.values()];
+  groups.sort((a, b) => {
+    const result = compareValues(a.value, b.value, column.type);
+    return direction === "asc" ? result : -result;
+  });
+  return groups;
 }
-function isSameCell(a, b) {
-  if (a === null || b === null) {
-    return a === b;
+function buildLevel(rows, levels, parentPath, expansion, byId, out) {
+  const level = levels[0];
+  if (level === void 0) {
+    out.push(...rows);
+    return;
   }
-  return a.rowId === b.rowId && a.columnId === b.columnId;
-}
-function selectCell(selection, cell, mode) {
-  if (mode === false || isSameCell(selection, cell)) {
-    return selection;
+  const column = byId.get(level.columnId);
+  if (column === void 0) {
+    out.push(...rows);
+    return;
   }
-  return cell;
-}
-function toggleCellSelection(selection, cell, mode) {
-  if (mode === false) {
-    return selection;
+  const rest = levels.slice(1);
+  const groups = partitionByValue(rows, column, level.direction ?? "asc");
+  for (const group of groups) {
+    const path = [...parentPath, group.value];
+    const groupId = groupRowId(path);
+    const expanded = !expansion.includes(groupId);
+    const header = {
+      kind: "group",
+      groupId,
+      level: parentPath.length,
+      columnId: level.columnId,
+      value: group.value,
+      path,
+      expanded,
+      count: group.rows.length,
+      // Renumbered globally once `groupRows` has the whole flattened array —
+      // a header has no row of its own to carry a dataset position, so
+      // `datasetIndex` takes the same renumbered value `rowIndex` does.
+      rowIndex: -1,
+      datasetIndex: -1,
+      // Set by `withGroupAggregates`, downstream of grouping — empty here
+      // since `groupRows` itself never knows about `AggregateState`.
+      aggregates: /* @__PURE__ */ new Map()
+    };
+    out.push(header);
+    if (expanded) {
+      buildLevel(group.rows, rest, path, expansion, byId, out);
+    }
   }
-  return isSameCell(selection, cell) ? null : cell;
 }
-function intentOf(event) {
-  if (event.shiftKey) {
-    return "range";
+function groupRows(rows, groupBy, expansion, columns) {
+  if (groupBy.length === 0) {
+    return rows;
   }
-  return event.ctrlKey || event.metaKey ? "toggle" : "replace";
-}
-function applySelectionIntent(selection, orderedIds, anchorId, id, intent, mode) {
-  switch (intent) {
-    case "toggle":
-      return toggleSelection(selection, id, mode);
-    // A range with no anchor yet spans from the id to itself, which is the
-    // plain click a first Shift-click may as well be.
-    case "range":
-      return selectRange(selection, orderedIds, anchorId ?? id, id, mode);
-    default:
-      return selectOnly(selection, id, mode);
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const active = groupBy.filter((entry) => byId.has(entry.columnId));
+  if (active.length === 0) {
+    return rows;
   }
+  const out = [];
+  buildLevel(rows, active, [], expansion, byId, out);
+  return out.map((entry, index) => {
+    if ("kind" in entry) {
+      return entry.rowIndex === index && entry.datasetIndex === index ? entry : { ...entry, rowIndex: index, datasetIndex: index };
+    }
+    return entry.rowIndex === index ? entry : { ...entry, rowIndex: index };
+  });
 }
-
-// src/util/sizing.ts
-var DEFAULT_COLUMN_SIZES = {
-  width: 150,
-  minWidth: 40,
-  maxWidth: Number.POSITIVE_INFINITY
-};
-var KEYBOARD_STEP = 10;
-function withDefaults(defaults) {
-  return { ...DEFAULT_COLUMN_SIZES, ...defaults };
+function toggleGroupExpansion(expansion, groupId) {
+  return expansion.includes(groupId) ? expansion.filter((id) => id !== groupId) : [...expansion, groupId];
 }
-function resolveColumnConstraints(column, defaults) {
-  const resolved = withDefaults(defaults);
-  return {
-    minWidth: column.minWidth ?? resolved.minWidth,
-    maxWidth: column.maxWidth ?? resolved.maxWidth
-  };
+function expandAllGroups(expansion) {
+  return expansion.length === 0 ? expansion : [];
 }
-function clampColumnWidth(width, constraints) {
-  return Math.min(Math.max(width, constraints.minWidth), constraints.maxWidth);
+function collapseAllGroups(rows) {
+  return rows.filter(
+    (entry) => "kind" in entry && entry.kind === "group"
+  ).map((entry) => entry.groupId);
 }
-function resolveColumnWidths(columns, sizing, options) {
-  const resolved = withDefaults(options?.sizes);
-  return columns.map((column) => {
-    const id = getColumnId(column);
-    const stored = sizing[id];
-    return {
-      column,
-      id,
-      sized: stored !== void 0,
-      width: clampColumnWidth(
-        stored ?? column.width ?? resolved.width,
-        resolveColumnConstraints(column, resolved)
-      ),
-      label: resolveColumnLabel(column),
-      resizable: column.resizable ?? options?.resizable ?? false,
-      reorderable: column.reorderable ?? options?.reorderable ?? false,
-      groupByDraggable: column.groupByDraggable ?? options?.groupByDraggable ?? false,
-      alignment: column.alignment ?? alignmentForType(column.type ?? "string")
-    };
-  });
+function moveGroupByBefore(groupBy, columnId, beforeColumnId) {
+  if (columnId === beforeColumnId) {
+    return groupBy;
+  }
+  const without = groupBy.filter((entry) => entry.columnId !== columnId);
+  const moved = groupBy.find((entry) => entry.columnId === columnId) ?? {
+    columnId
+  };
+  const target = beforeColumnId === null ? without.length : without.findIndex((entry) => entry.columnId === beforeColumnId);
+  if (target === -1) {
+    return groupBy;
+  }
+  const next = [...without];
+  next.splice(target, 0, moved);
+  return next.length === groupBy.length && next.every((entry, index) => entry === groupBy[index]) ? groupBy : next;
 }
-function totalColumnWidth(resolved) {
-  return resolved.reduce((total, entry) => total + entry.width, 0);
+function movesGroupBy(groupBy, columnId, beforeColumnId) {
+  return moveGroupByBefore(groupBy, columnId, beforeColumnId) !== groupBy;
 }
-function beginColumnResize(column, startWidth, startPosition, defaults) {
-  return {
-    columnId: getColumnId(column),
-    startWidth,
-    startPosition,
-    constraints: resolveColumnConstraints(column, defaults)
+
+// src/util/memoize.ts
+function memoizeLast(compute) {
+  let last;
+  return (...args) => {
+    const previous = last;
+    if (previous !== void 0 && args.every((arg, index) => Object.is(arg, previous.args[index]))) {
+      return previous.result;
+    }
+    const result = compute(...args);
+    last = { args, result };
+    return result;
   };
 }
-function applyColumnResize(session, position) {
-  return clampColumnWidth(
-    session.startWidth + (position - session.startPosition),
-    session.constraints
-  );
+
+// src/util/ordering.ts
+function applyColumnOrder(columns, order) {
+  if (order.length === 0) {
+    return columns;
+  }
+  const byId = new Map(columns.map((column) => [getColumnId(column), column]));
+  const listed = order.map((id) => byId.get(id)).filter((column) => column !== void 0);
+  const taken = new Set(listed.map((column) => getColumnId(column)));
+  return [
+    ...listed,
+    ...columns.filter((column) => !taken.has(getColumnId(column)))
+  ];
 }
-function reachedBound(width, item) {
-  return item.bound > item.width ? width >= item.bound : width <= item.bound;
+function resolveDataColumns(columns, order) {
+  return applyColumnOrder(columns, order).map((column) => ({
+    id: getColumnId(column),
+    column
+  }));
 }
-function redistribute(entries, remaining) {
-  for (; ; ) {
-    const movable = entries.filter(
-      (item) => item.adjustable && !reachedBound(item.width, item)
-    );
-    const left = remaining(entries.reduce((t, i) => t + i.width, 0));
-    if (left <= 0 || movable.length === 0) {
-      break;
-    }
-    const base = movable.reduce((total, item) => total + item.width, 0);
-    let clamped = false;
-    for (const item of movable) {
-      const share = base === 0 ? left / movable.length : left * item.width / base;
-      const next = item.width + (item.bound > item.width ? share : -share);
-      if (reachedBound(next, item)) {
-        item.width = item.bound;
-        clamped = true;
-      } else {
-        item.width = next;
-      }
-    }
-    if (!clamped) {
-      break;
-    }
+function moveColumnBefore(orderedIds, movedId, beforeId) {
+  if (movedId === beforeId || !orderedIds.includes(movedId)) {
+    return orderedIds;
+  }
+  const without = orderedIds.filter((id) => id !== movedId);
+  const target = beforeId === null ? without.length : without.indexOf(beforeId);
+  if (target === -1) {
+    return orderedIds;
   }
+  const next = [...without];
+  next.splice(target, 0, movedId);
+  return next.every((id, index) => id === orderedIds[index]) ? orderedIds : next;
 }
-function fitColumnsToWidth(resolved, availableWidth, defaults) {
-  const target = Math.floor(availableWidth);
-  const total = totalColumnWidth(resolved);
-  if (resolved.length === 0 || total === target) {
-    return resolved;
+function movesColumn(orderedIds, movedId, beforeId) {
+  return moveColumnBefore(orderedIds, movedId, beforeId) !== orderedIds;
+}
+function resolveDropBefore(orderedIds, targetId, side) {
+  if (side === "before") {
+    return targetId;
   }
-  const growing = total < target;
+  const index = orderedIds.indexOf(targetId);
+  return index === -1 ? null : orderedIds[index + 1] ?? null;
+}
+function resolveKeyboardDropTarget(orderedIds, columnId, direction) {
+  const index = orderedIds.indexOf(columnId);
+  if (index === -1) {
+    return void 0;
+  }
+  const targetIndex = direction === -1 ? index - 1 : index + 2;
+  if (targetIndex < 0) {
+    return void 0;
+  }
+  return orderedIds[targetIndex] ?? null;
+}
+
+// src/util/paging.ts
+function unitsOf(rows) {
+  const units = [];
+  let start = 0;
+  let openedByGroup = false;
+  for (let index = 0; index < rows.length; index++) {
+    const entry = rows[index];
+    if (entry === void 0) {
+      continue;
+    }
+    const isTopLevelHeader = "kind" in entry && entry.kind === "group" && entry.level === 0;
+    const isBoundary = index !== start && (isTopLevelHeader || !openedByGroup);
+    if (isBoundary) {
+      units.push({ start, end: index });
+      start = index;
+      openedByGroup = isTopLevelHeader;
+    } else if (index === start) {
+      openedByGroup = isTopLevelHeader;
+    }
+  }
+  if (start < rows.length) {
+    units.push({ start, end: rows.length });
+  }
+  return units;
+}
+function paginateRows(rows, pagination) {
+  const pageSize = Math.max(1, pagination.pageSize);
+  const units = unitsOf(rows);
+  const pageCount = Math.ceil(units.length / pageSize);
+  if (pageCount === 0) {
+    return { rows: [], pageCount: 0, pageIndex: 0 };
+  }
+  const pageIndex = Math.min(Math.max(pagination.pageIndex, 0), pageCount - 1);
+  const firstUnit = units[pageIndex * pageSize];
+  const lastUnit = units[Math.min(pageIndex * pageSize + pageSize, units.length) - 1];
+  if (firstUnit === void 0 || lastUnit === void 0) {
+    return { rows: [], pageCount, pageIndex };
+  }
+  const page = rows.slice(firstUnit.start, lastUnit.end);
+  const renumbered = page.map(
+    (entry, index) => entry.rowIndex === index ? entry : { ...entry, rowIndex: index }
+  );
+  return { rows: renumbered, pageCount, pageIndex };
+}
+
+// src/util/report.ts
+function reportError(message) {
+  console.error(`GridKit: ${message}`);
+}
+
+// src/util/filterOperators.ts
+var matchNothing = () => false;
+function kindOf(type) {
+  switch (type) {
+    case "number":
+    case "decimal":
+    case "currency":
+    case "percent":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "dateTime":
+    case "time":
+      return "date";
+    default:
+      return "text";
+  }
+}
+function isDateType(type) {
+  return kindOf(type) === "date";
+}
+function isEmptyCell(value) {
+  return value === null || value === void 0 || value === "";
+}
+function toDate(value) {
+  const date = value instanceof Date ? value : typeof value === "string" ? new Date(value) : void 0;
+  return date === void 0 || Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function comparable(value, kind) {
+  switch (kind) {
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value) ? value : void 0;
+    case "boolean":
+      return typeof value === "boolean" ? value : void 0;
+    case "date":
+      return toDate(value);
+    case "text":
+      return String(value).toLowerCase();
+  }
+}
+function isOperandOfKind(operand, kind) {
+  if (kind !== "text") {
+    return comparable(operand, kind) !== void 0;
+  }
+  return typeof operand === "string" || typeof operand === "number" || typeof operand === "boolean";
+}
+function compileComparison(operand, type) {
+  const kind = kindOf(type);
+  if (!isOperandOfKind(operand, kind)) {
+    return void 0;
+  }
+  const target = comparable(operand, kind);
+  return (value) => {
+    if (isEmptyCell(value)) {
+      return void 0;
+    }
+    const cell = comparable(value, kind);
+    return cell === void 0 ? void 0 : compareValues(cell, target, type);
+  };
+}
+function isScalarList(operand) {
+  return Array.isArray(operand);
+}
+function compileOrdering(operator, operand, type) {
+  const compare = compileComparison(operand, type);
+  if (compare === void 0) {
+    return matchNothing;
+  }
+  const where = (holds) => (value) => {
+    const result = compare(value);
+    return result !== void 0 && holds(result);
+  };
+  switch (operator) {
+    case "eq":
+      return where((result) => result === 0);
+    case "ne": {
+      const equals = where((result) => result === 0);
+      return (value) => !equals(value);
+    }
+    case "gt":
+      return where((result) => result > 0);
+    case "gte":
+      return where((result) => result >= 0);
+    case "lt":
+      return where((result) => result < 0);
+    case "lte":
+      return where((result) => result <= 0);
+  }
+}
+function compileBetween(operand, type) {
+  if (!isScalarList(operand) || operand.length !== 2) {
+    return matchNothing;
+  }
+  const [low, high] = operand;
+  const fromLow = compileComparison(low, type);
+  const fromHigh = compileComparison(high, type);
+  if (fromLow === void 0 || fromHigh === void 0) {
+    return matchNothing;
+  }
+  return (value) => {
+    const aboveLow = fromLow(value);
+    const belowHigh = fromHigh(value);
+    return aboveLow !== void 0 && belowHigh !== void 0 && aboveLow >= 0 && belowHigh <= 0;
+  };
+}
+function filterValueKey(value, type) {
+  return bucketKey(isDateType(type) ? toDate(value) ?? value : value);
+}
+function compileIn(operand, type) {
+  if (!isScalarList(operand)) {
+    return matchNothing;
+  }
+  const keys = new Set(
+    operand.filter((scalar) => !isEmptyCell(scalar)).map((scalar) => filterValueKey(scalar, type))
+  );
+  return (value) => !isEmptyCell(value) && keys.has(filterValueKey(value, type));
+}
+function compileText(operator, operand) {
+  if (!isOperandOfKind(operand, "text")) {
+    return matchNothing;
+  }
+  const text = String(operand).toLowerCase();
+  const read = (value) => String(value).toLowerCase();
+  switch (operator) {
+    case "contains":
+      return (value) => !isEmptyCell(value) && read(value).includes(text);
+    case "notContains":
+      return (value) => isEmptyCell(value) || !read(value).includes(text);
+    case "startsWith":
+      return (value) => !isEmptyCell(value) && read(value).startsWith(text);
+    case "endsWith":
+      return (value) => !isEmptyCell(value) && read(value).endsWith(text);
+  }
+}
+function compileOperatorEntry(entry, type) {
+  const { operator, value } = entry;
+  switch (operator) {
+    case "isEmpty":
+      return isEmptyCell;
+    case "isNotEmpty":
+      return (cell) => !isEmptyCell(cell);
+    case "contains":
+    case "notContains":
+    case "startsWith":
+    case "endsWith":
+      return compileText(operator, value);
+    case "between":
+      return compileBetween(value, type);
+    case "in":
+      return compileIn(value, type);
+    case "eq":
+    case "ne":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return compileOrdering(operator, value, type);
+  }
+}
+
+// src/util/serialize.ts
+function serializeScalar(scalar) {
+  return scalar instanceof Date ? scalar.toISOString() : scalar;
+}
+function serializeOperand(operand) {
+  return isScalarList(operand) ? operand.map(serializeScalar) : serializeScalar(operand);
+}
+function serializeEntry(entry) {
+  if ("combinator" in entry) {
+    const entries = serializeFilter(entry.entries);
+    return entries.length === 0 && entry.entries.length > 0 ? void 0 : { combinator: entry.combinator, entries };
+  }
+  if ("predicate" in entry) {
+    reportError(
+      entry.columnId === void 0 ? "a predicate filter entry across every column cannot be serialised, so it is left out of the saved state." : `a predicate filter entry on \`${entry.columnId}\` cannot be serialised, so it is left out of the saved state.`
+    );
+    return void 0;
+  }
+  if ("operator" in entry) {
+    const { value, ...rest } = entry;
+    return value === void 0 ? rest : { ...rest, value: serializeOperand(value) };
+  }
+  if ("value" in entry) {
+    const { value, ...rest } = entry;
+    return {
+      ...rest,
+      value: value instanceof Date ? value.toISOString() : value
+    };
+  }
+  return entry;
+}
+function serializeFilter(filter) {
+  return filter.map((entry) => serializeEntry(entry)).filter((entry) => entry !== void 0);
+}
+function serializeGridState(state) {
+  return { ...state, filter: serializeFilter(state.filter) };
+}
+function reviveScalar(scalar, type) {
+  return isDateType(type) && typeof scalar === "string" ? toDate(scalar) ?? scalar : scalar;
+}
+function reviveOperand(operand, type) {
+  return isScalarList(operand) ? operand.map((scalar) => reviveScalar(scalar, type)) : reviveScalar(operand, type);
+}
+function reviveEntry(entry, typeOf) {
+  if ("combinator" in entry) {
+    return {
+      combinator: entry.combinator,
+      entries: reviveEntries(entry.entries, typeOf)
+    };
+  }
+  if ("operator" in entry) {
+    const { value, ...rest } = entry;
+    return value === void 0 ? rest : { ...rest, value: reviveOperand(value, typeOf(entry.columnId)) };
+  }
+  if ("value" in entry) {
+    const { value, ...rest } = entry;
+    return {
+      ...rest,
+      value: typeof value === "string" ? new Date(value) : value
+    };
+  }
+  return entry;
+}
+function reviveEntries(filter, typeOf) {
+  return filter.map((entry) => reviveEntry(entry, typeOf));
+}
+function reviveFilter(filter, columns) {
+  const types = new Map(columns.map((entry) => [entry.id, entry.column.type]));
+  return reviveEntries(filter, (columnId) => types.get(columnId));
+}
+
+// src/util/sizing.ts
+var DEFAULT_COLUMN_SIZES = {
+  width: 150,
+  minWidth: 40,
+  maxWidth: Number.POSITIVE_INFINITY
+};
+var KEYBOARD_STEP = 10;
+function withDefaults(defaults) {
+  return { ...DEFAULT_COLUMN_SIZES, ...defaults };
+}
+function resolveColumnConstraints(column, defaults) {
+  const resolved = withDefaults(defaults);
+  return {
+    minWidth: column.minWidth ?? resolved.minWidth,
+    maxWidth: column.maxWidth ?? resolved.maxWidth
+  };
+}
+function clampColumnWidth(width, constraints) {
+  return Math.min(Math.max(width, constraints.minWidth), constraints.maxWidth);
+}
+function resolveColumnWidths(columns, sizing, options) {
+  const resolved = withDefaults(options?.sizes);
+  return columns.map((column) => {
+    const id = getColumnId(column);
+    const stored = sizing[id];
+    return {
+      column,
+      id,
+      sized: stored !== void 0,
+      width: clampColumnWidth(
+        stored ?? column.width ?? resolved.width,
+        resolveColumnConstraints(column, resolved)
+      ),
+      label: resolveColumnLabel(column),
+      resizable: column.resizable ?? options?.resizable ?? false,
+      reorderable: column.reorderable ?? options?.reorderable ?? false,
+      groupByDraggable: column.groupByDraggable ?? options?.groupByDraggable ?? false,
+      alignment: column.alignment ?? alignmentForType(column.type ?? "string")
+    };
+  });
+}
+function totalColumnWidth(resolved) {
+  return resolved.reduce((total, entry) => total + entry.width, 0);
+}
+function beginColumnResize(column, startWidth, startPosition, defaults) {
+  return {
+    columnId: getColumnId(column),
+    startWidth,
+    startPosition,
+    constraints: resolveColumnConstraints(column, defaults)
+  };
+}
+function applyColumnResize(session, position) {
+  return clampColumnWidth(
+    session.startWidth + (position - session.startPosition),
+    session.constraints
+  );
+}
+function reachedBound(width, item) {
+  return item.bound > item.width ? width >= item.bound : width <= item.bound;
+}
+function redistribute(entries, remaining) {
+  for (; ; ) {
+    const movable = entries.filter(
+      (item) => item.adjustable && !reachedBound(item.width, item)
+    );
+    const left = remaining(entries.reduce((t, i) => t + i.width, 0));
+    if (left <= 0 || movable.length === 0) {
+      break;
+    }
+    const base = movable.reduce((total, item) => total + item.width, 0);
+    let clamped = false;
+    for (const item of movable) {
+      const share = base === 0 ? left / movable.length : left * item.width / base;
+      const next = item.width + (item.bound > item.width ? share : -share);
+      if (reachedBound(next, item)) {
+        item.width = item.bound;
+        clamped = true;
+      } else {
+        item.width = next;
+      }
+    }
+    if (!clamped) {
+      break;
+    }
+  }
+}
+function fitColumnsToWidth(resolved, availableWidth, defaults) {
+  const target = Math.floor(availableWidth);
+  const total = totalColumnWidth(resolved);
+  if (resolved.length === 0 || total === target) {
+    return resolved;
+  }
+  const growing = total < target;
   const entries = resolved.map((entry) => {
     const constraints = resolveColumnConstraints(entry.column, defaults);
     return {
@@ -468,96 +812,180 @@ function revertColumnSize(current, base, columnId) {
   return next;
 }
 
-// src/util/sorting.ts
-function isEmpty(value) {
+// src/util/aggregation.ts
+function isEmpty2(value) {
   return value === null || value === void 0;
 }
-function toTime(value) {
-  return value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
+function toNumber(value) {
+  return Number(value);
 }
-function compareValues(a, b, type) {
-  if (isEmpty(a)) {
-    return isEmpty(b) ? 0 : 1;
+function distinctKey(value) {
+  if (isEmpty2(value)) {
+    return "\0empty";
   }
-  if (isEmpty(b)) {
-    return -1;
+  if (value instanceof Date) {
+    return `\0date:${String(value.getTime())}`;
   }
-  switch (type) {
+  switch (typeof value) {
+    case "string":
     case "number":
-    case "decimal":
-    case "currency":
-    case "percent":
-      return Number(a) - Number(b);
     case "boolean":
-      return Number(Boolean(a)) - Number(Boolean(b));
-    case "date":
-    case "dateTime":
-    case "time":
-      return toTime(a) - toTime(b);
+    case "bigint":
+    case "symbol":
+      return `\0${typeof value}:${String(value)}`;
+    case "function":
+      return "\0function";
     default:
-      return String(a).localeCompare(String(b));
+      return `\0object:${JSON.stringify(value)}`;
   }
 }
-function sortDirectionFor(sort, columnId) {
-  return sort.find((entry) => entry.columnId === columnId)?.direction ?? null;
+function reduceBuiltIn(rows, fn, column) {
+  if (fn === "count") {
+    return rows.length;
+  }
+  const field = column?.column.field;
+  const values = field === void 0 ? [] : rows.map((row) => accessDotted(row, field));
+  switch (fn) {
+    case "sum": {
+      let total = 0;
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        total += toNumber(value);
+      }
+      return total;
+    }
+    case "avg": {
+      const present = values.filter((value) => !isEmpty2(value));
+      if (present.length === 0) return void 0;
+      const total = present.reduce(
+        (acc, value) => acc + toNumber(value),
+        0
+      );
+      return total / present.length;
+    }
+    case "min":
+    case "max": {
+      const type = column?.column.type;
+      let result;
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        if (result === void 0) {
+          result = value;
+          continue;
+        }
+        const comparison = compareValues(value, result, type);
+        if (fn === "min" ? comparison < 0 : comparison > 0) {
+          result = value;
+        }
+      }
+      return result;
+    }
+    case "countDistinct": {
+      const seen = /* @__PURE__ */ new Set();
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        seen.add(distinctKey(value));
+      }
+      return seen.size;
+    }
+  }
 }
-function sortPriorityFor(sort, columnId) {
-  const index = sort.findIndex((entry) => entry.columnId === columnId);
-  return index === -1 ? null : index + 1;
+function keyOf(spec) {
+  return spec.id ?? spec.columnId;
 }
-function toggleColumnSort(sort, columnId, options) {
-  const index = sort.findIndex((entry) => entry.columnId === columnId);
-  const isSoleEntry = sort.length === 1 && index === 0;
-  if (!options.stack && !isSoleEntry) {
-    return [{ columnId, direction: "asc" }];
+function computeAggregates(rows, specs, columns) {
+  const results = /* @__PURE__ */ new Map();
+  if (specs.length === 0) {
+    return results;
   }
-  const current = index === -1 ? void 0 : sort[index]?.direction;
-  const next = current === void 0 ? "asc" : current === "asc" ? "desc" : null;
-  if (next === null) {
-    return sort.filter((entry) => entry.columnId !== columnId);
+  const byId = new Map(columns.map((entry) => [entry.id, entry]));
+  for (const spec of specs) {
+    const value = typeof spec.fn === "function" ? spec.fn(rows) : reduceBuiltIn(rows, spec.fn, byId.get(spec.columnId));
+    results.set(keyOf(spec), value);
   }
-  if (index === -1) {
-    return [...sort, { columnId, direction: next }];
+  return results;
+}
+function leafDescendantsOf(flatRows, path, groupBy, byId) {
+  const keys = path.map((value) => bucketKey(value));
+  return flatRows.filter(
+    (row) => keys.every((key, level) => {
+      const columnId = groupBy[level]?.columnId;
+      const column = columnId === void 0 ? void 0 : byId.get(columnId);
+      if (column === void 0) return false;
+      return bucketKey(accessDotted(row.row, column.field)) === key;
+    })
+  ).map((row) => row.row);
+}
+function appendAggregatedSpan(displayRows, start, levelFloor, flatRows, groupBy, byId, specs, columns, display, out) {
+  let index = start;
+  while (index < displayRows.length) {
+    const entry = displayRows[index];
+    if (entry === void 0) {
+      index++;
+      continue;
+    }
+    if (levelFloor !== null && "kind" in entry && entry.kind === "group" && entry.level <= levelFloor) {
+      break;
+    }
+    index++;
+    if (!("kind" in entry) || entry.kind !== "group") {
+      out.push(entry);
+      continue;
+    }
+    const leaves = leafDescendantsOf(flatRows, entry.path, groupBy, byId);
+    const aggregates = computeAggregates(leaves, specs, columns);
+    const withAggregates = { ...entry, aggregates };
+    out.push(withAggregates);
+    index = appendAggregatedSpan(
+      displayRows,
+      index,
+      entry.level,
+      flatRows,
+      groupBy,
+      byId,
+      specs,
+      columns,
+      display,
+      out
+    );
+    if (display === "row") {
+      const summary = {
+        kind: "group-summary",
+        groupId: entry.groupId,
+        level: entry.level,
+        rowIndex: -1,
+        datasetIndex: -1,
+        aggregates
+      };
+      out.push(summary);
+    }
   }
-  return sort.map(
-    (entry, i) => i === index ? { columnId, direction: next } : entry
-  );
+  return index;
 }
-function sortRows(rows, sort, columns) {
-  if (sort.length === 0) {
-    return rows;
+function withGroupAggregates(displayRows, flatRows, groupBy, specs, columns, display = "inline") {
+  if (specs.length === 0) {
+    return displayRows;
   }
   const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
-  const active = sort.filter((entry) => byId.has(entry.columnId));
-  if (active.length === 0) {
-    return rows;
-  }
-  const sorted = [...rows].sort((a, b) => {
-    for (const { columnId, direction } of active) {
-      const column = byId.get(columnId);
-      if (column === void 0) {
-        continue;
-      }
-      const left = accessDotted(a.row, column.field);
-      const right = accessDotted(b.row, column.field);
-      const leftEmpty = isEmpty(left);
-      const rightEmpty = isEmpty(right);
-      if (leftEmpty || rightEmpty) {
-        if (leftEmpty && rightEmpty) {
-          continue;
-        }
-        return leftEmpty ? 1 : -1;
-      }
-      const result = compareValues(left, right, column.type);
-      if (result !== 0) {
-        return direction === "asc" ? result : -result;
-      }
+  const out = [];
+  appendAggregatedSpan(
+    displayRows,
+    0,
+    null,
+    flatRows,
+    groupBy,
+    byId,
+    specs,
+    columns,
+    display,
+    out
+  );
+  return out.map((entry, position) => {
+    if ("kind" in entry) {
+      return entry.rowIndex === position && entry.datasetIndex === position ? entry : { ...entry, rowIndex: position, datasetIndex: position };
     }
-    return 0;
+    return entry.rowIndex === position ? entry : { ...entry, rowIndex: position };
   });
-  return sorted.map(
-    (row, index) => row.rowIndex === index ? row : { ...row, rowIndex: index }
-  );
 }
 
 // src/util/filtering.ts
@@ -635,10 +1063,18 @@ function compileFilterEntry(entry, byId, columns) {
     const { columnId: columnId2, predicate } = entry;
     const column = columnId2 === void 0 ? void 0 : byId.get(columnId2);
     return (row) => predicate(
-      column === void 0 ? void 0 : accessDotted(row.row, column.field),
-      row.row
+      column === void 0 ? void 0 : accessDotted(row, column.field),
+      row
     );
   }
+  if ("operator" in entry) {
+    const column = byId.get(entry.columnId);
+    if (column === void 0) {
+      return () => false;
+    }
+    const test2 = compileOperatorEntry(entry, column.type);
+    return (row) => test2(accessDotted(row, column.field));
+  }
   if ("value" in entry) {
     const { columnId: columnId2, value } = entry;
     if (columnId2 !== void 0) {
@@ -646,15 +1082,11 @@ function compileFilterEntry(entry, byId, columns) {
       if (column === void 0) {
         return () => false;
       }
-      return (row) => matchesTypedValue(
-        accessDotted(row.row, column.field),
-        value,
-        column.type
-      );
+      return (row) => matchesTypedValue(accessDotted(row, column.field), value, column.type);
     }
     return (row) => columns.some(
       (entry2) => matchesTypedValue(
-        accessDotted(row.row, entry2.column.field),
+        accessDotted(row, entry2.column.field),
         value,
         entry2.column.type
       )
@@ -667,9 +1099,14 @@ function compileFilterEntry(entry, byId, columns) {
     if (column === void 0) {
       return () => false;
     }
-    return (row) => test(accessDotted(row.row, column.field));
+    return (row) => test(accessDotted(row, column.field));
   }
-  return (row) => columns.some((entry2) => test(accessDotted(row.row, entry2.column.field)));
+  return (row) => columns.some((entry2) => test(accessDotted(row, entry2.column.field)));
+}
+function compileFilter(filter, columns) {
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const compiled = filter.filter((entry) => isEntryUsable(entry, byId)).map((entry) => compileFilterEntry(entry, byId, columns));
+  return compiled.length === 0 ? void 0 : (row) => compiled.every((test) => test(row));
 }
 function matchesQuery(value, query) {
   return compileFilterQuery(query)(value);
@@ -704,231 +1141,1106 @@ function filterRows(rows, filter, columns) {
   if (filter.length === 0) {
     return rows;
   }
-  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
-  const active = filter.filter((entry) => isEntryUsable(entry, byId));
-  if (active.length === 0) {
+  const test = compileFilter(filter, columns);
+  if (test === void 0) {
     return rows;
   }
-  const compiled = active.map(
-    (entry) => compileFilterEntry(entry, byId, columns)
-  );
-  const filtered = rows.filter((row) => compiled.every((test) => test(row)));
+  const filtered = rows.filter((row) => test(row.row));
   return filtered.map(
     (row, index) => row.rowIndex === index ? row : { ...row, rowIndex: index }
   );
 }
 
-// src/util/grouping.ts
-function groupRowId(path) {
-  return JSON.stringify(path);
+// src/util/rows.ts
+function resolveShownRows(rows, filter, sort, columns) {
+  return sortRows(filterRows(rows, filter, columns), sort, columns);
 }
-function bucketKey(value) {
-  if (value === null || value === void 0) {
-    return "\0empty";
-  }
-  if (value instanceof Date) {
-    return `\0date:${String(value.getTime())}`;
-  }
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "symbol":
-      return `\0${typeof value}:${String(value)}`;
-    case "function":
-      return "\0function";
-    default:
-      return `\0object:${JSON.stringify(value)}`;
-  }
+function resolveRows(rowsById, ids) {
+  return ids.map((id) => rowsById.get(id)).filter((row) => row !== void 0);
 }
-function partitionByValue(rows, column, direction) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const value = accessDotted(row.row, column.field);
-    const key = bucketKey(value);
-    const bucket = buckets.get(key);
-    if (bucket === void 0) {
-      buckets.set(key, { value, rows: [row] });
-    } else {
-      bucket.rows.push(row);
-    }
+function resolveColumns(columns, ids) {
+  return ids.map((id) => {
+    const columnIndex = columns.findIndex((entry) => entry.id === id);
+    const column = columns[columnIndex];
+    return column === void 0 ? void 0 : { columnId: id, column, columnIndex };
+  }).filter((column) => column !== void 0);
+}
+function resolveCell(rowsById, columns, cell) {
+  if (cell === null) {
+    return null;
   }
-  const groups = [...buckets.values()];
-  groups.sort((a, b) => {
-    const result = compareValues(a.value, b.value, column.type);
-    return direction === "asc" ? result : -result;
-  });
-  return groups;
+  const entry = rowsById.get(cell.rowId);
+  const columnIndex = columns.findIndex(
+    (candidate) => candidate.id === cell.columnId
+  );
+  const column = columns[columnIndex];
+  if (entry === void 0 || column === void 0) {
+    return null;
+  }
+  return {
+    rowId: cell.rowId,
+    columnId: cell.columnId,
+    row: entry.row,
+    column,
+    rowIndex: entry.rowIndex,
+    columnIndex,
+    value: accessDotted(entry.row, column.column.field)
+  };
 }
-function buildLevel(rows, levels, parentPath, expansion, byId, out) {
-  const level = levels[0];
-  if (level === void 0) {
-    out.push(...rows);
-    return;
+
+// src/util/visibility.ts
+function isColumnVisible(column, visibility) {
+  return visibility[getColumnId(column)] ?? column.hidden !== true;
+}
+function applyColumnVisibility(columns, visibility) {
+  const visible = columns.filter(
+    (entry) => isColumnVisible(entry.column, visibility)
+  );
+  return visible.length === columns.length ? columns : visible;
+}
+function setColumnVisibility(columns, visibility, columnIds, visible) {
+  const requested = new Set(columnIds);
+  const changed = columns.filter(
+    (entry) => requested.has(entry.id) && isColumnVisible(entry.column, visibility) !== visible
+  );
+  if (changed.length === 0) {
+    return visibility;
   }
-  const column = byId.get(level.columnId);
-  if (column === void 0) {
-    out.push(...rows);
-    return;
+  return {
+    ...visibility,
+    ...Object.fromEntries(changed.map((entry) => [entry.id, visible]))
+  };
+}
+
+// src/util/view.ts
+var NO_AGGREGATES = [];
+function identifyRows(rows, getRowId) {
+  return rows.map((row, rowIndex) => ({
+    rowId: resolveRowId(row, rowIndex, getRowId),
+    row,
+    rowIndex,
+    datasetIndex: rowIndex
+  }));
+}
+function sizeColumns(visibleColumns, sizing, sizes, resizable, reorderable, groupByDraggable, resizeMode, viewportWidth) {
+  const widths = resolveColumnWidths(
+    visibleColumns.map((entry) => entry.column),
+    sizing,
+    { sizes, resizable, reorderable, groupByDraggable }
+  );
+  return resizeMode === "fit" && viewportWidth !== null ? fitColumnsToWidth(widths, viewportWidth, sizes) : widths;
+}
+function totalAggregates(rows, aggregates, dataColumns) {
+  return computeAggregates(
+    rows.map((entry) => entry.row),
+    aggregates,
+    dataColumns
+  );
+}
+function paginate(displayRows, paginated, pagination) {
+  return paginated ? paginateRows(displayRows, pagination) : { rows: displayRows, pageCount: 1, pageIndex: 0 };
+}
+function narrowToDataRows(pageRows, rows, reshaped) {
+  return reshaped ? pageRows.filter((entry) => !("kind" in entry)) : rows;
+}
+function createGridViewResolver() {
+  const identify = memoizeLast(identifyRows);
+  const orderColumns = memoizeLast(resolveDataColumns);
+  const showColumns = memoizeLast(applyColumnVisibility);
+  const size = memoizeLast(sizeColumns);
+  const filterAndSort = memoizeLast(resolveShownRows);
+  const group = memoizeLast(groupRows);
+  const aggregate = memoizeLast(withGroupAggregates);
+  const total = memoizeLast(totalAggregates);
+  const page = memoizeLast(paginate);
+  const narrow = memoizeLast(narrowToDataRows);
+  const assemble = memoizeLast(
+    (dataColumns, columns, rows, displayRows, pageRows, displayDataRows, pageCount, pageIndex, grandTotal) => ({
+      dataColumns,
+      columns,
+      rows,
+      displayRows,
+      pageRows,
+      displayDataRows,
+      pageCount,
+      pageIndex,
+      grandTotal
+    })
+  );
+  return ({ rows: data, getRowId, columns: definitions, state, options }) => {
+    const paginated = options.paginated ?? false;
+    const aggregates = options.aggregates ?? NO_AGGREGATES;
+    const dataColumns = orderColumns(definitions, state.columnOrder);
+    const columns = size(
+      showColumns(dataColumns, state.columnVisibility),
+      state.columnSizing,
+      options.columnSizeDefaults,
+      options.resizableColumns,
+      options.reorderableColumns,
+      options.groupByDraggableColumns,
+      options.resizeMode ?? "fit",
+      options.viewportWidth ?? null
+    );
+    const rows = filterAndSort(
+      identify(data, getRowId),
+      state.filter,
+      state.columnSort,
+      dataColumns
+    );
+    const displayRows = aggregate(
+      group(rows, state.groupBy, state.groupExpansion, dataColumns),
+      rows,
+      state.groupBy,
+      aggregates,
+      dataColumns,
+      options.groupAggregateDisplay ?? "inline"
+    );
+    const {
+      rows: pageRows,
+      pageCount,
+      pageIndex
+    } = page(displayRows, paginated, state.pagination);
+    return assemble(
+      dataColumns,
+      columns,
+      rows,
+      displayRows,
+      pageRows,
+      narrow(pageRows, rows, state.groupBy.length > 0 || paginated),
+      pageCount,
+      pageIndex,
+      total(rows, aggregates, dataColumns)
+    );
+  };
+}
+function resolveGridView(input) {
+  return createGridViewResolver()(input);
+}
+
+// src/controller/changes.ts
+function changedEntryColumnId(previous, next) {
+  const length = Math.max(previous.length, next.length);
+  for (let index = 0; index < length; index++) {
+    const before = previous[index];
+    const after = next[index];
+    if (before?.columnId !== after?.columnId || before?.direction !== after?.direction) {
+      return (after ?? before)?.columnId;
+    }
   }
-  const rest = levels.slice(1);
-  const groups = partitionByValue(rows, column, level.direction ?? "asc");
-  for (const group of groups) {
-    const path = [...parentPath, group.value];
-    const groupId = groupRowId(path);
-    const expanded = !expansion.includes(groupId);
-    const header = {
-      kind: "group",
-      groupId,
-      level: parentPath.length,
-      columnId: level.columnId,
-      value: group.value,
-      path,
-      expanded,
-      count: group.rows.length,
-      // Renumbered globally once `groupRows` has the whole flattened array —
-      // a header has no row of its own to carry a dataset position, so
-      // `datasetIndex` takes the same renumbered value `rowIndex` does.
-      rowIndex: -1,
-      datasetIndex: -1,
-      // Set by `withGroupAggregates`, downstream of grouping — empty here
-      // since `groupRows` itself never knows about `AggregateState`.
-      aggregates: /* @__PURE__ */ new Map()
-    };
-    out.push(header);
-    if (expanded) {
-      buildLevel(group.rows, rest, path, expansion, byId, out);
+  return void 0;
+}
+function changedId(previous, next) {
+  const length = Math.max(previous.length, next.length);
+  for (let index = 0; index < length; index++) {
+    if (previous[index] !== next[index]) {
+      return next[index] ?? previous[index];
     }
   }
+  return void 0;
 }
-function groupRows(rows, groupBy, expansion, columns) {
-  if (groupBy.length === 0) {
-    return rows;
+function changedKeys(previous, next) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(next), ...Object.keys(previous)]);
+  return [...keys].filter((key) => previous[key] !== next[key]);
+}
+function sameItems(previous, next) {
+  return previous.length === next.length && previous.every((item, index) => item === next[index]);
+}
+function samePagination(previous, next) {
+  return previous.pageIndex === next.pageIndex && previous.pageSize === next.pageSize;
+}
+function sameValue(previous, next) {
+  return previous instanceof Date && next instanceof Date ? previous.getTime() === next.getTime() : previous === next;
+}
+function sameOperand(previous, next) {
+  if (isScalarList(previous) || isScalarList(next)) {
+    return isScalarList(previous) && isScalarList(next) && previous.length === next.length && previous.every((scalar, index) => sameValue(scalar, next[index]));
   }
-  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
-  const active = groupBy.filter((entry) => byId.has(entry.columnId));
-  if (active.length === 0) {
-    return rows;
+  return sameValue(previous, next);
+}
+function sameEntry(previous, next) {
+  if ("combinator" in previous || "combinator" in next) {
+    return "combinator" in previous && "combinator" in next && previous.combinator === next.combinator && sameFilter(previous.entries, next.entries);
   }
-  const out = [];
-  buildLevel(rows, active, [], expansion, byId, out);
-  return out.map((entry, index) => {
-    if ("kind" in entry) {
-      return entry.rowIndex === index && entry.datasetIndex === index ? entry : { ...entry, rowIndex: index, datasetIndex: index };
-    }
-    return entry.rowIndex === index ? entry : { ...entry, rowIndex: index };
+  if (previous.columnId !== next.columnId) {
+    return false;
+  }
+  if ("predicate" in previous || "predicate" in next) {
+    return "predicate" in previous && "predicate" in next && previous.predicate === next.predicate;
+  }
+  if ("operator" in previous || "operator" in next) {
+    return "operator" in previous && "operator" in next && previous.operator === next.operator && sameOperand(previous.value, next.value);
+  }
+  if ("value" in previous || "value" in next) {
+    return "value" in previous && "value" in next && sameValue(previous.value, next.value);
+  }
+  return previous.query === next.query;
+}
+function sameFilter(previous, next) {
+  return previous.length === next.length && previous.every((entry, index) => {
+    const other = next[index];
+    return other !== void 0 && sameEntry(entry, other);
   });
 }
-function toggleGroupExpansion(expansion, groupId) {
-  return expansion.includes(groupId) ? expansion.filter((id) => id !== groupId) : [...expansion, groupId];
+
+// src/util/selection.ts
+var NO_CHANGE = { added: [], removed: [] };
+function sameSelection(a, b) {
+  return a.length === b.length && a.every((id, index) => id === b[index]);
 }
-function expandAllGroups(expansion) {
-  return expansion.length === 0 ? expansion : [];
+function toggleSelection(selection, id, mode) {
+  if (mode === false) {
+    return selection;
+  }
+  if (selection.includes(id)) {
+    return selection.filter((selectedId) => selectedId !== id);
+  }
+  return mode === "single" ? [id] : [...selection, id];
 }
-function collapseAllGroups(rows) {
-  return rows.filter((entry) => "kind" in entry).map((entry) => entry.groupId);
+function selectOnly(selection, id, mode) {
+  if (mode === false) {
+    return selection;
+  }
+  return selection.length === 1 && selection[0] === id ? selection : [id];
 }
-function moveGroupByBefore(groupBy, columnId, beforeColumnId) {
-  if (columnId === beforeColumnId) {
-    return groupBy;
+function selectRange(selection, orderedIds, anchorId, focusId, mode) {
+  if (mode !== "multiple") {
+    return selectOnly(selection, focusId, mode);
   }
-  const without = groupBy.filter((entry) => entry.columnId !== columnId);
-  const moved = groupBy.find((entry) => entry.columnId === columnId) ?? {
-    columnId
+  const anchor = orderedIds.indexOf(anchorId);
+  const focus = orderedIds.indexOf(focusId);
+  if (anchor === -1 || focus === -1) {
+    return selection;
+  }
+  const next = orderedIds.slice(
+    Math.min(anchor, focus),
+    Math.max(anchor, focus) + 1
+  );
+  return sameSelection(selection, next) ? selection : next;
+}
+function selectAll(selection, orderedIds, mode) {
+  if (mode !== "multiple") {
+    return selection;
+  }
+  return sameSelection(selection, orderedIds) ? selection : orderedIds;
+}
+function clearSelection(selection) {
+  return selection.length === 0 ? selection : [];
+}
+function diffSelection(previous, next) {
+  if (previous === next) {
+    return NO_CHANGE;
+  }
+  const before = new Set(previous);
+  const after = new Set(next);
+  return {
+    added: next.filter((id) => !before.has(id)),
+    removed: previous.filter((id) => !after.has(id))
   };
-  const target = beforeColumnId === null ? without.length : without.findIndex((entry) => entry.columnId === beforeColumnId);
-  if (target === -1) {
-    return groupBy;
+}
+function isSameCell(a, b) {
+  if (a === null || b === null) {
+    return a === b;
   }
-  const next = [...without];
-  next.splice(target, 0, moved);
-  return next.length === groupBy.length && next.every((entry, index) => entry === groupBy[index]) ? groupBy : next;
+  return a.rowId === b.rowId && a.columnId === b.columnId;
 }
-function movesGroupBy(groupBy, columnId, beforeColumnId) {
-  return moveGroupByBefore(groupBy, columnId, beforeColumnId) !== groupBy;
+function selectCell(selection, cell, mode) {
+  if (mode === false || isSameCell(selection, cell)) {
+    return selection;
+  }
+  return cell;
+}
+function toggleCellSelection(selection, cell, mode) {
+  if (mode === false) {
+    return selection;
+  }
+  return isSameCell(selection, cell) ? null : cell;
+}
+function intentOf(event, options) {
+  if (event.shiftKey) {
+    return "range";
+  }
+  if (event.ctrlKey || event.metaKey) {
+    return "toggle";
+  }
+  return options?.toggleOnClick === true ? "toggle" : "replace";
+}
+function applySelectionIntent(selection, orderedIds, anchorId, id, intent, mode) {
+  switch (intent) {
+    case "toggle":
+      return toggleSelection(selection, id, mode);
+    // A range with no anchor yet spans from the id to itself, which is the
+    // plain click a first Shift-click may as well be.
+    case "range":
+      return selectRange(selection, orderedIds, anchorId ?? id, id, mode);
+    default:
+      return selectOnly(selection, id, mode);
+  }
 }
 
-// src/util/rows.ts
-function resolveShownRows(rows, filter, sort, columns) {
-  return sortRows(filterRows(rows, filter, columns), sort, columns);
+// src/controller/selectionEvents.ts
+function reportRowSelection(previous, next, rowsById, callbacks) {
+  const diff = diffSelection(previous, next);
+  const added = resolveRows(rowsById, diff.added);
+  const removed = resolveRows(rowsById, diff.removed);
+  for (const row of added) {
+    callbacks.onRowSelect?.({ row, selection: next });
+  }
+  if (added.length > 0) {
+    callbacks.onRowsSelect?.({ rows: added, selection: next });
+  }
+  for (const row of removed) {
+    callbacks.onRowDeselect?.({ row, selection: next });
+  }
+  if (removed.length > 0) {
+    callbacks.onRowsDeselect?.({ rows: removed, selection: next });
+  }
+  callbacks.onRowSelectionChange?.({
+    added,
+    removed,
+    selected: resolveRows(rowsById, next),
+    selection: next
+  });
+  return diff;
 }
-function resolveRows(rowsById, ids) {
-  return ids.map((id) => rowsById.get(id)).filter((row) => row !== void 0);
+function reportColumnSelection(previous, next, columns, callbacks) {
+  const diff = diffSelection(previous, next);
+  const added = resolveColumns(columns, diff.added);
+  const removed = resolveColumns(columns, diff.removed);
+  for (const column of added) {
+    callbacks.onColumnSelect?.({ column, selection: next });
+  }
+  if (added.length > 0) {
+    callbacks.onColumnsSelect?.({ columns: added, selection: next });
+  }
+  for (const column of removed) {
+    callbacks.onColumnDeselect?.({ column, selection: next });
+  }
+  if (removed.length > 0) {
+    callbacks.onColumnsDeselect?.({ columns: removed, selection: next });
+  }
+  callbacks.onColumnSelectionChange?.({
+    added,
+    removed,
+    selected: resolveColumns(columns, next),
+    selection: next
+  });
+  return diff;
 }
-function resolveColumns(columns, ids) {
-  return ids.map((id) => {
-    const columnIndex = columns.findIndex((entry) => entry.id === id);
-    const column = columns[columnIndex];
-    return column === void 0 ? void 0 : { columnId: id, column, columnIndex };
-  }).filter((column) => column !== void 0);
+function reportCellSelection(previous, next, rowsById, columns, callbacks) {
+  const selected = resolveCell(rowsById, columns, next);
+  const deselected = resolveCell(rowsById, columns, previous);
+  if (deselected !== null) {
+    callbacks.onCellDeselect?.({ cell: deselected, selection: next });
+  }
+  if (selected !== null) {
+    callbacks.onCellSelect?.({ cell: selected, selection: next });
+  }
+  callbacks.onCellSelectionChange?.({
+    selected,
+    deselected,
+    selection: next
+  });
 }
-function resolveCell(rowsById, columns, cell) {
-  if (cell === null) {
-    return null;
+
+// src/controller/selectionActions.ts
+function indexRows(rows) {
+  return new Map(rows.map((entry) => [entry.rowId, entry]));
+}
+function distinct(ids) {
+  return [...new Set(ids)];
+}
+function createSelectionActions(grid) {
+  let rowAnchor = null;
+  let columnAnchor = null;
+  const rowsById = memoizeLast(indexRows);
+  function modes() {
+    const selectable = grid.getOptions().selectable;
+    return {
+      rows: selectable?.rows ?? false,
+      columns: selectable?.columns ?? false,
+      cells: selectable?.cells ?? false
+    };
   }
-  const entry = rowsById.get(cell.rowId);
-  const columnIndex = columns.findIndex(
-    (candidate) => candidate.id === cell.columnId
-  );
-  const column = columns[columnIndex];
-  if (entry === void 0 || column === void 0) {
-    return null;
+  function rowIds() {
+    return grid.getView().displayDataRows.map((entry) => entry.rowId);
+  }
+  function columnIds() {
+    return grid.getView().columns.map((entry) => entry.id);
+  }
+  function commitRows(next) {
+    const previous = grid.getState().rowSelection;
+    grid.commit("rowSelection", next, () => {
+      const options = grid.getOptions();
+      const diff = reportRowSelection(
+        previous,
+        next,
+        rowsById(grid.getView().displayDataRows),
+        options
+      );
+      options.onSelectionDiff?.({ target: "rows", ...diff, selection: next });
+    });
+  }
+  function commitColumns(next) {
+    const previous = grid.getState().columnSelection;
+    grid.commit("columnSelection", next, () => {
+      const options = grid.getOptions();
+      const diff = reportColumnSelection(
+        previous,
+        next,
+        grid.getView().columns,
+        options
+      );
+      options.onSelectionDiff?.({
+        target: "columns",
+        ...diff,
+        selection: next
+      });
+    });
+  }
+  function commitCell(next) {
+    const previous = grid.getState().cellSelection;
+    grid.commit("cellSelection", next, () => {
+      const view = grid.getView();
+      reportCellSelection(
+        previous,
+        next,
+        rowsById(view.displayDataRows),
+        view.columns,
+        grid.getOptions()
+      );
+    });
   }
   return {
-    rowId: cell.rowId,
-    columnId: cell.columnId,
-    row: entry.row,
-    column,
-    rowIndex: entry.rowIndex,
-    columnIndex,
-    value: accessDotted(entry.row, column.column.field)
+    setRowSelection(selection) {
+      if (!sameItems(grid.getState().rowSelection, selection)) {
+        commitRows(selection);
+      }
+    },
+    selectRows(ids, intent = "replace") {
+      const mode = modes().rows;
+      const current = grid.getState().rowSelection;
+      if (mode === false || ids.length === 0) {
+        return;
+      }
+      const next = intent === "toggle" ? ids.reduce(
+        (selection, id) => toggleSelection(selection, id, mode),
+        current
+      ) : mode === "single" ? ids.slice(-1) : distinct(ids);
+      rowAnchor = ids.at(-1) ?? null;
+      if (!sameItems(current, next)) {
+        commitRows(next);
+      }
+    },
+    selectRow(rowId, intent) {
+      const next = applySelectionIntent(
+        grid.getState().rowSelection,
+        rowIds(),
+        rowAnchor,
+        rowId,
+        intent,
+        modes().rows
+      );
+      if (intent !== "range") {
+        rowAnchor = rowId;
+      }
+      commitRows(next);
+    },
+    selectAllRows() {
+      commitRows(
+        selectAll(grid.getState().rowSelection, rowIds(), modes().rows)
+      );
+    },
+    clearSelection() {
+      commitRows(clearSelection(grid.getState().rowSelection));
+      commitColumns(clearSelection(grid.getState().columnSelection));
+      commitCell(null);
+    },
+    setColumnSelection(selection) {
+      if (!sameItems(grid.getState().columnSelection, selection)) {
+        commitColumns(selection);
+      }
+    },
+    selectColumn(columnId, intent) {
+      const next = applySelectionIntent(
+        grid.getState().columnSelection,
+        columnIds(),
+        columnAnchor,
+        columnId,
+        intent,
+        modes().columns
+      );
+      if (intent !== "range") {
+        columnAnchor = columnId;
+      }
+      commitColumns(next);
+    },
+    setCellSelection(selection) {
+      if (!isSameCell(grid.getState().cellSelection, selection)) {
+        commitCell(selection);
+      }
+    },
+    selectCell(cell, intent) {
+      const current = grid.getState().cellSelection;
+      const mode = modes().cells;
+      commitCell(
+        intent === "toggle" ? toggleCellSelection(current, cell, mode) : selectCell(current, cell, mode)
+      );
+    }
   };
 }
 
-// src/util/paging.ts
-function unitsOf(rows) {
-  const units = [];
-  let start = 0;
-  let openedByGroup = false;
-  for (let index = 0; index < rows.length; index++) {
-    const entry = rows[index];
-    if (entry === void 0) {
-      continue;
+// src/controller/createGridController.ts
+var DEFAULT_PAGE_SIZE = 25;
+var NO_ROWS = [];
+var NO_COLUMNS = [];
+var SLICE_KEYS = [
+  "columnSizing",
+  "columnOrder",
+  "columnVisibility",
+  "columnSort",
+  "filter",
+  "groupBy",
+  "groupExpansion",
+  "pagination",
+  "rowSelection",
+  "columnSelection",
+  "cellSelection"
+];
+var DEFAULT_OPTION = {
+  columnSizing: "defaultColumnSizing",
+  columnOrder: "defaultColumnOrder",
+  columnVisibility: "defaultColumnVisibility",
+  columnSort: "defaultColumnSort",
+  filter: "defaultFilter",
+  groupBy: "defaultGroupBy",
+  groupExpansion: "defaultGroupExpansion",
+  pagination: "defaultPagination",
+  rowSelection: "defaultRowSelection",
+  columnSelection: "defaultColumnSelection",
+  cellSelection: "defaultCellSelection"
+};
+function startingState(options) {
+  return {
+    columnSizing: options.defaultColumnSizing ?? {},
+    columnOrder: options.defaultColumnOrder ?? [],
+    columnVisibility: options.defaultColumnVisibility ?? {},
+    columnSort: options.defaultColumnSort ?? [],
+    filter: options.defaultFilter ?? [],
+    groupBy: options.defaultGroupBy ?? [],
+    groupExpansion: options.defaultGroupExpansion ?? [],
+    pagination: options.defaultPagination ?? {
+      pageIndex: 0,
+      pageSize: DEFAULT_PAGE_SIZE
+    },
+    rowSelection: options.defaultRowSelection ?? [],
+    columnSelection: options.defaultColumnSelection ?? [],
+    cellSelection: options.defaultCellSelection ?? null
+  };
+}
+function definedColumns(columns, rows) {
+  if (columns !== void 0 && columns.length > 0) {
+    return columns;
+  }
+  if (rows !== void 0 && rows.length > 0) {
+    return defineColumnsFromRows(rows);
+  }
+  return NO_COLUMNS;
+}
+function pagingInputsOf(state) {
+  return {
+    filter: state.filter,
+    columnSort: state.columnSort,
+    groupBy: state.groupBy
+  };
+}
+function createGridController(initial) {
+  let options = initial;
+  const own = startingState(initial);
+  const resolveView = createGridViewResolver();
+  const resolveColumns2 = memoizeLast(definedColumns);
+  const listeners = /* @__PURE__ */ new Set();
+  const reportedConflicts = /* @__PURE__ */ new Set();
+  let heldReports;
+  let state = resolveSlices();
+  let pagingInputs = pagingInputsOf(state);
+  reportConflicts();
+  function controlledValue(key) {
+    const controlled = options;
+    return controlled[key];
+  }
+  function isControlled(key) {
+    return controlledValue(key) !== void 0;
+  }
+  function resolveSlice(key) {
+    const controlled = controlledValue(key);
+    return controlled === void 0 ? own[key] : controlled;
+  }
+  function resolveSlices() {
+    return {
+      columnSizing: resolveSlice("columnSizing"),
+      columnOrder: resolveSlice("columnOrder"),
+      columnVisibility: resolveSlice("columnVisibility"),
+      columnSort: resolveSlice("columnSort"),
+      filter: resolveSlice("filter"),
+      groupBy: resolveSlice("groupBy"),
+      groupExpansion: resolveSlice("groupExpansion"),
+      pagination: resolveSlice("pagination"),
+      rowSelection: resolveSlice("rowSelection"),
+      columnSelection: resolveSlice("columnSelection"),
+      cellSelection: resolveSlice("cellSelection")
+    };
+  }
+  function reportConflicts() {
+    for (const key of SLICE_KEYS) {
+      const defaultKey = DEFAULT_OPTION[key];
+      if (reportedConflicts.has(key) || !isControlled(key) || options[defaultKey] === void 0) {
+        continue;
+      }
+      reportedConflicts.add(key);
+      reportError(
+        `\`${key}\` and \`${defaultKey}\` are both set \u2014 \`${key}\` is controlled, so \`${defaultKey}\` is ignored.`
+      );
     }
-    const isTopLevelHeader = "kind" in entry && entry.kind === "group" && entry.level === 0;
-    const isBoundary = index !== start && (isTopLevelHeader || !openedByGroup);
-    if (isBoundary) {
-      units.push({ start, end: index });
-      start = index;
-      openedByGroup = isTopLevelHeader;
-    } else if (index === start) {
-      openedByGroup = isTopLevelHeader;
+  }
+  function refresh() {
+    let next = resolveSlices();
+    if (next.filter !== pagingInputs.filter || next.columnSort !== pagingInputs.columnSort || next.groupBy !== pagingInputs.groupBy) {
+      pagingInputs = pagingInputsOf(next);
+      if (!isControlled("pagination") && own.pagination.pageIndex !== 0) {
+        own.pagination = { ...own.pagination, pageIndex: 0 };
+        next = { ...next, pagination: own.pagination };
+      }
     }
+    state = SLICE_KEYS.every((key) => next[key] === state[key]) ? state : next;
   }
-  if (start < rows.length) {
-    units.push({ start, end: rows.length });
+  function notify() {
+    for (const listener of [...listeners]) {
+      listener();
+    }
   }
-  return units;
+  function commit(key, next, report) {
+    if (next === state[key]) {
+      return;
+    }
+    if (!isControlled(key)) {
+      own[key] = next;
+    }
+    if (heldReports !== void 0) {
+      heldReports.push(report);
+      return;
+    }
+    refresh();
+    report();
+    notify();
+  }
+  function getView() {
+    return resolveView({
+      rows: options.dataSource ?? NO_ROWS,
+      getRowId: options.getRowId,
+      columns: resolveColumns2(options.columns, options.dataSource),
+      state,
+      options: {
+        paginated: options.paginated,
+        aggregates: options.aggregates,
+        groupAggregateDisplay: options.groupAggregateDisplay,
+        columnSizeDefaults: options.columnSizeDefaults,
+        resizableColumns: options.resizableColumns,
+        reorderableColumns: options.reorderableColumns,
+        groupByDraggableColumns: options.groupByDraggableColumns,
+        resizeMode: options.resizeMode,
+        viewportWidth: options.viewportWidth
+      }
+    });
+  }
+  function commitColumnSizing(next, columnId, width, phase) {
+    commit("columnSizing", next, () => {
+      options.onColumnResize?.({ columnId, width, sizing: next, phase });
+    });
+  }
+  function definedWidth(columnId) {
+    const entry = getView().dataColumns.find(
+      (candidate) => candidate.id === columnId
+    );
+    const [resolved] = entry === void 0 ? [] : resolveColumnWidths(
+      [entry.column],
+      {},
+      {
+        sizes: options.columnSizeDefaults
+      }
+    );
+    return resolved?.width ?? 0;
+  }
+  function commitColumnVisibility(next) {
+    const previous = state.columnVisibility;
+    commit("columnVisibility", next, () => {
+      const changed = new Set(changedKeys(previous, next));
+      const shown = getView().dataColumns.map((entry) => entry.id).filter((id) => changed.delete(id));
+      options.onColumnVisibilityChange?.({
+        columnIds: [...shown, ...changed],
+        visibility: next
+      });
+    });
+  }
+  function changeColumnVisibility(columnIds, visible) {
+    commitColumnVisibility(
+      setColumnVisibility(
+        getView().dataColumns,
+        state.columnVisibility,
+        columnIds,
+        visible
+      )
+    );
+  }
+  function commitGroupBy(next, columnId) {
+    commit("groupBy", next, () => {
+      options.onGroupByChange?.({ columnId, groupBy: next });
+    });
+  }
+  function commitGroupExpansion(next, groupId) {
+    commit("groupExpansion", next, () => {
+      options.onGroupExpansionChange?.({ groupId, expansion: next });
+    });
+  }
+  function commitPagination(next) {
+    commit("pagination", next, () => {
+      options.onPaginationChange?.({
+        pagination: next,
+        pageCount: paginateRows(getView().displayRows, next).pageCount
+      });
+    });
+  }
+  function goToPage(pageIndex) {
+    const current = state.pagination;
+    const clamped = paginateRows(getView().displayRows, {
+      ...current,
+      pageIndex
+    }).pageIndex;
+    commitPagination({ ...current, pageIndex: clamped });
+  }
+  function shownPageIndex() {
+    return paginateRows(getView().displayRows, state.pagination).pageIndex;
+  }
+  const selection = createSelectionActions({
+    getState: () => state,
+    getOptions: () => options,
+    getView,
+    commit
+  });
+  const controller = {
+    ...selection,
+    getOptions: () => options,
+    setOptions(next) {
+      options = next;
+      reportConflicts();
+      refresh();
+    },
+    getState: () => state,
+    getView,
+    restoreState(saved) {
+      const reports = [];
+      heldReports = reports;
+      try {
+        restoreSlices(saved);
+      } finally {
+        heldReports = void 0;
+      }
+      if (saved.pagination !== void 0) {
+        pagingInputs = pagingInputsOf(resolveSlices());
+      }
+      refresh();
+      for (const report of reports) {
+        report();
+      }
+      if (reports.length > 0) {
+        notify();
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setColumnSizing(sizing) {
+      const [columnId] = changedKeys(state.columnSizing, sizing);
+      if (columnId !== void 0) {
+        commitColumnSizing(
+          sizing,
+          columnId,
+          sizing[columnId] ?? definedWidth(columnId),
+          "end"
+        );
+      }
+    },
+    resizeColumn(columnId, width, phase) {
+      commitColumnSizing(
+        { ...state.columnSizing, [columnId]: width },
+        columnId,
+        width,
+        phase
+      );
+    },
+    cancelColumnResize(columnId, startSizing, startWidth) {
+      commitColumnSizing(
+        revertColumnSize(state.columnSizing, startSizing, columnId),
+        columnId,
+        startWidth,
+        "end"
+      );
+    },
+    setColumnOrder(order) {
+      const columnId = changedId(state.columnOrder, order);
+      if (columnId === void 0) {
+        return;
+      }
+      commit("columnOrder", order, () => {
+        options.onColumnOrderChange?.({ columnId, order });
+      });
+    },
+    /**
+     * Applied to every id in display order rather than to the stored order,
+     * which starts empty and may name only some columns, so would have
+     * nothing to rearrange.
+     */
+    moveColumn(columnId, beforeId) {
+      const orderedIds = getView().dataColumns.map((entry) => entry.id);
+      const next = moveColumnBefore(orderedIds, columnId, beforeId);
+      if (next === orderedIds) {
+        return;
+      }
+      commit("columnOrder", next, () => {
+        options.onColumnOrderChange?.({ columnId, order: next });
+      });
+    },
+    setColumnVisibility(visibility) {
+      if (changedKeys(state.columnVisibility, visibility).length > 0) {
+        commitColumnVisibility(visibility);
+      }
+    },
+    showColumns(columnIds) {
+      changeColumnVisibility(columnIds, true);
+    },
+    hideColumns(columnIds) {
+      changeColumnVisibility(columnIds, false);
+    },
+    setFilter(filter) {
+      if (sameFilter(state.filter, filter)) {
+        return;
+      }
+      commit("filter", filter, () => {
+        options.onFilterChange?.({ filter });
+      });
+    },
+    setColumnSort(sort) {
+      const columnId = changedEntryColumnId(state.columnSort, sort);
+      if (columnId === void 0) {
+        return;
+      }
+      commit("columnSort", sort, () => {
+        options.onColumnSortChange?.({ columnId, sort });
+      });
+    },
+    toggleColumnSort(columnId, { stack = false } = {}) {
+      const next = toggleColumnSort(state.columnSort, columnId, { stack });
+      commit("columnSort", next, () => {
+        options.onColumnSortChange?.({ columnId, sort: next });
+      });
+    },
+    setGroupBy(groupBy) {
+      const columnId = changedEntryColumnId(state.groupBy, groupBy);
+      if (columnId !== void 0) {
+        commitGroupBy(groupBy, columnId);
+      }
+    },
+    toggleGroupBy(columnId) {
+      const grouped = state.groupBy.some(
+        (entry) => entry.columnId === columnId
+      );
+      commitGroupBy(
+        grouped ? state.groupBy.filter((entry) => entry.columnId !== columnId) : [...state.groupBy, { columnId }],
+        columnId
+      );
+    },
+    moveGroupBy(columnId, beforeColumnId) {
+      commitGroupBy(
+        moveGroupByBefore(state.groupBy, columnId, beforeColumnId),
+        columnId
+      );
+    },
+    setGroupExpansion(expansion) {
+      if (!sameItems(state.groupExpansion, expansion)) {
+        commitGroupExpansion(expansion, null);
+      }
+    },
+    toggleGroupExpansion(groupId) {
+      commitGroupExpansion(
+        toggleGroupExpansion(state.groupExpansion, groupId),
+        groupId
+      );
+    },
+    expandAllGroups() {
+      commitGroupExpansion(expandAllGroups(state.groupExpansion), null);
+    },
+    collapseAllGroups() {
+      commitGroupExpansion(collapseAllGroups(getView().displayRows), null);
+    },
+    setPagination(pagination) {
+      if (!samePagination(state.pagination, pagination)) {
+        commitPagination(pagination);
+      }
+    },
+    goToPage,
+    nextPage() {
+      goToPage(shownPageIndex() + 1);
+    },
+    previousPage() {
+      goToPage(shownPageIndex() - 1);
+    },
+    setPageSize(pageSize) {
+      const first = { pageIndex: 0, pageSize };
+      commitPagination({
+        ...first,
+        pageIndex: paginateRows(getView().displayRows, first).pageIndex
+      });
+    }
+  };
+  function restoreSlices(saved) {
+    if (saved.columnSizing !== void 0) {
+      controller.setColumnSizing(saved.columnSizing);
+    }
+    if (saved.columnOrder !== void 0) {
+      controller.setColumnOrder(saved.columnOrder);
+    }
+    if (saved.columnVisibility !== void 0) {
+      controller.setColumnVisibility(saved.columnVisibility);
+    }
+    if (saved.columnSort !== void 0) {
+      controller.setColumnSort(saved.columnSort);
+    }
+    if (saved.filter !== void 0) {
+      controller.setFilter(reviveFilter(saved.filter, getView().dataColumns));
+    }
+    if (saved.groupBy !== void 0) {
+      controller.setGroupBy(saved.groupBy);
+    }
+    if (saved.groupExpansion !== void 0) {
+      controller.setGroupExpansion(saved.groupExpansion);
+    }
+    if (saved.pagination !== void 0) {
+      controller.setPagination(saved.pagination);
+    }
+    if (saved.rowSelection !== void 0) {
+      controller.setRowSelection(saved.rowSelection);
+    }
+    if (saved.columnSelection !== void 0) {
+      controller.setColumnSelection(saved.columnSelection);
+    }
+    if (saved.cellSelection !== void 0) {
+      controller.setCellSelection(saved.cellSelection);
+    }
+  }
+  return controller;
 }
-function paginateRows(rows, pagination) {
-  const pageSize = Math.max(1, pagination.pageSize);
-  const units = unitsOf(rows);
-  const pageCount = Math.ceil(units.length / pageSize);
-  if (pageCount === 0) {
-    return { rows: [], pageCount: 0, pageIndex: 0 };
+
+// src/util/navigation.ts
+var HEADER_ROW = -1;
+function clampFocus(focus, rowCount, columnCount) {
+  return {
+    rowIndex: Math.min(Math.max(focus.rowIndex, HEADER_ROW), rowCount - 1),
+    columnIndex: Math.min(
+      Math.max(focus.columnIndex, 0),
+      Math.max(columnCount - 1, 0)
+    )
+  };
+}
+function noRowsSkippable() {
+  return false;
+}
+function skipSkippableRows(rowIndex, direction, rowCount, isSkippableRow, fallback) {
+  let next = rowIndex;
+  while (next >= 0 && next < rowCount && isSkippableRow(next)) {
+    const stepped = next + direction;
+    if (stepped < HEADER_ROW || stepped >= rowCount) {
+      return fallback;
+    }
+    next = stepped;
   }
-  const pageIndex = Math.min(Math.max(pagination.pageIndex, 0), pageCount - 1);
-  const firstUnit = units[pageIndex * pageSize];
-  const lastUnit = units[Math.min(pageIndex * pageSize + pageSize, units.length) - 1];
-  if (firstUnit === void 0 || lastUnit === void 0) {
-    return { rows: [], pageCount, pageIndex };
+  return next;
+}
+function nextFocusForKey(key, modifiers, focus, rowCount, columnCount, pageSize, isSkippableRow = noRowsSkippable) {
+  if (modifiers.altKey) {
+    return null;
+  }
+  const { rowIndex, columnIndex } = focus;
+  switch (key) {
+    case "ArrowLeft":
+      if (modifiers.ctrlKey) return null;
+      return { rowIndex, columnIndex: columnIndex - 1 };
+    case "ArrowRight":
+      if (modifiers.ctrlKey) return null;
+      return { rowIndex, columnIndex: columnIndex + 1 };
+    case "ArrowUp":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    case "ArrowDown":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex + 1,
+          1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    // Ctrl takes Home and End to the grid's ends rather than the row's, which
+    // is the one place Ctrl is navigation rather than reorder.
+    case "Home":
+      return modifiers.ctrlKey ? { rowIndex: HEADER_ROW, columnIndex: 0 } : { rowIndex, columnIndex: 0 };
+    case "End":
+      return modifiers.ctrlKey ? {
+        rowIndex: skipSkippableRows(
+          rowCount - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex: columnCount - 1
+      } : { rowIndex, columnIndex: columnCount - 1 };
+    case "PageUp":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex - pageSize,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    case "PageDown":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex + pageSize,
+          1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    default:
+      return null;
   }
-  const page = rows.slice(firstUnit.start, lastUnit.end);
-  const renumbered = page.map(
-    (entry, index) => entry.rowIndex === index ? entry : { ...entry, rowIndex: index }
-  );
-  return { rows: renumbered, pageCount, pageIndex };
 }
 
 // src/util/paginationWindow.ts
@@ -966,180 +2278,426 @@ function paginationWindow(currentPage, pageCount, options) {
   return entries;
 }
 
-// src/util/aggregation.ts
-function isEmpty2(value) {
-  return value === null || value === void 0;
+// src/util/format.ts
+var DATE_FIELDS = {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric"
+};
+var TIME_FIELDS = {
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+};
+var DATE_TIME_FIELDS = {
+  ...DATE_FIELDS,
+  ...TIME_FIELDS
+};
+var CURRENCY_DIGITS = {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+};
+var NO_FORMAT = {};
+var formatters = /* @__PURE__ */ new WeakMap();
+function cached(format, key, create) {
+  const owner = format ?? NO_FORMAT;
+  let byKey = formatters.get(owner);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    formatters.set(owner, byKey);
+  }
+  const existing = byKey.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const formatter = create();
+  byKey.set(key, formatter);
+  return formatter;
+}
+function localeKey(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
+}
+function isNumericType(type) {
+  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
+}
+function numberOptions(type, format) {
+  switch (type) {
+    case "currency":
+      return format?.currency === void 0 ? { ...CURRENCY_DIGITS, ...format } : { style: "currency", ...format };
+    case "percent":
+      return { style: "percent", ...format };
+    default:
+      return format ?? {};
+  }
 }
-function toNumber(value) {
-  return Number(value);
+function dateOptions(type, format) {
+  if (format !== void 0) {
+    return format;
+  }
+  if (type === "date") return DATE_FIELDS;
+  if (type === "time") return TIME_FIELDS;
+  return DATE_TIME_FIELDS;
 }
-function distinctKey(value) {
-  if (isEmpty2(value)) {
-    return "\0empty";
+function formatNumber(value, type, format, locale) {
+  const formatter = cached(
+    format,
+    `number|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.NumberFormat(
+      locale,
+      numberOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatDate(value, type, format, locale) {
+  if (Number.isNaN(value.getTime())) {
+    return String(value);
+  }
+  const formatter = cached(
+    format,
+    `date|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.DateTimeFormat(
+      locale,
+      dateOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatOther(value) {
+  if (typeof value === "function") {
+    return "(function)";
+  }
+  if (typeof value === "object" && value !== null) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return Object.prototype.toString.call(value);
+    }
   }
+  return String(value);
+}
+function formatCellValue(value, column, locale, row, messages) {
+  if (column.valueFormatter !== void 0) {
+    return column.valueFormatter(value, row);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "boolean" && messages !== void 0) {
+    return value ? messages.booleanTrue : messages.booleanFalse;
+  }
+  const { type, format } = column;
+  const formatted = format !== void 0 || locale !== void 0;
   if (value instanceof Date) {
-    return `\0date:${String(value.getTime())}`;
+    return formatted ? formatDate(value, type, format, locale) : value.toLocaleString();
   }
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "symbol":
-      return `\0${typeof value}:${String(value)}`;
-    case "function":
-      return "\0function";
-    default:
-      return `\0object:${JSON.stringify(value)}`;
+  if (formatted && (typeof value === "number" || typeof value === "bigint") && isNumericType(type)) {
+    return formatNumber(value, type, format, locale);
+  }
+  if (typeof value === "string") {
+    return value;
   }
+  return formatOther(value);
 }
-function reduceBuiltIn(rows, fn, column) {
-  if (fn === "count") {
-    return rows.length;
+function aggregateFormatColumn(value, spec, column) {
+  const plain = {
+    field: spec.columnId,
+    type: "number"
+  };
+  if (column === void 0 || spec.fn === "count" || spec.fn === "countDistinct") {
+    return plain;
   }
-  const field = column?.column.field;
-  const values = field === void 0 ? [] : rows.map((row) => accessDotted(row, field));
-  switch (fn) {
-    case "sum": {
-      let total = 0;
-      for (const value of values) {
-        if (isEmpty2(value)) continue;
-        total += toNumber(value);
-      }
-      return total;
-    }
-    case "avg": {
-      const present = values.filter((value) => !isEmpty2(value));
-      if (present.length === 0) return void 0;
-      const total = present.reduce(
-        (acc, value) => acc + toNumber(value),
-        0
-      );
-      return total / present.length;
-    }
-    case "min":
-    case "max": {
-      const type = column?.column.type;
-      let result;
-      for (const value of values) {
-        if (isEmpty2(value)) continue;
-        if (result === void 0) {
-          result = value;
-          continue;
-        }
-        const comparison = compareValues(value, result, type);
-        if (fn === "min" ? comparison < 0 : comparison > 0) {
-          result = value;
-        }
-      }
-      return result;
-    }
-    case "countDistinct": {
-      const seen = /* @__PURE__ */ new Set();
-      for (const value of values) {
-        if (isEmpty2(value)) continue;
-        seen.add(distinctKey(value));
-      }
-      return seen.size;
-    }
+  const numeric = typeof value === "number" || typeof value === "bigint";
+  return column.valueFormatter === void 0 && numeric && !isNumericType(column.type) ? plain : column;
+}
+function formatAggregateValue(value, spec, column, locale) {
+  const target = aggregateFormatColumn(value, spec, column);
+  if (typeof value === "number" && target.valueFormatter === void 0 && target.format === void 0 && locale === void 0) {
+    return value.toLocaleString();
   }
+  return formatCellValue(value, target, locale);
 }
-function keyOf(spec) {
-  return spec.id ?? spec.columnId;
+
+// src/util/filterEditor.ts
+function touchesColumn(entry, columnId) {
+  return "combinator" in entry ? entry.entries.some((nested) => touchesColumn(nested, columnId)) : entry.columnId === columnId;
 }
-function computeAggregates(rows, specs, columns) {
-  const results = /* @__PURE__ */ new Map();
-  if (specs.length === 0) {
-    return results;
+function isOperatorOn(entry, columnId) {
+  return "operator" in entry && entry.columnId === columnId;
+}
+function isConditionOn(entry, columnId) {
+  return isOperatorOn(entry, columnId) && entry.operator !== "in";
+}
+function valuesShape(entry, columnId) {
+  const values = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "in" && isScalarList(candidate.value) ? candidate.value : void 0;
+  const blanks = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "isEmpty";
+  const alone = values(entry);
+  if (alone !== void 0) {
+    return { kind: "values", values: alone, includeBlanks: false };
   }
-  const byId = new Map(columns.map((entry) => [entry.id, entry]));
-  for (const spec of specs) {
-    const value = typeof spec.fn === "function" ? spec.fn(rows) : reduceBuiltIn(rows, spec.fn, byId.get(spec.columnId));
-    results.set(keyOf(spec), value);
+  if (!("combinator" in entry) || entry.combinator !== "or" || entry.entries.length !== 2) {
+    return void 0;
   }
-  return results;
+  const [first, second] = entry.entries;
+  const listed = blanks(first) ? values(second) : values(first);
+  return listed !== void 0 && (blanks(first) || blanks(second)) ? { kind: "values", values: listed, includeBlanks: true } : void 0;
 }
-function leafDescendantsOf(flatRows, path, groupBy, byId) {
-  const keys = path.map((value) => bucketKey(value));
-  return flatRows.filter(
-    (row) => keys.every((key, level) => {
-      const columnId = groupBy[level]?.columnId;
-      const column = columnId === void 0 ? void 0 : byId.get(columnId);
-      if (column === void 0) return false;
-      return bucketKey(accessDotted(row.row, column.field)) === key;
-    })
-  ).map((row) => row.row);
+function conditionsShape(touching, columnId) {
+  const [only] = touching;
+  const grouped = touching.length === 1 && only !== void 0 && "combinator" in only;
+  const entries = grouped ? only.entries : touching;
+  const combinator = grouped ? only.combinator : "and";
+  if (entries.length === 0 || entries.length > 2) {
+    return void 0;
+  }
+  const conditions = entries.filter((entry) => isConditionOn(entry, columnId));
+  return conditions.length === entries.length ? { kind: "conditions", conditions, combinator } : void 0;
 }
-function appendAggregatedSpan(displayRows, start, levelFloor, flatRows, groupBy, byId, specs, columns, display, out) {
-  let index = start;
-  while (index < displayRows.length) {
-    const entry = displayRows[index];
-    if (entry === void 0) {
-      index++;
+function describeColumnFilter(filter, columnId) {
+  const touching = filter.filter((entry) => touchesColumn(entry, columnId));
+  const [only] = touching;
+  if (only === void 0) {
+    return { kind: "none" };
+  }
+  return (touching.length === 1 ? valuesShape(only, columnId) : void 0) ?? conditionsShape(touching, columnId) ?? { kind: "custom" };
+}
+function isOfferable(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date;
+}
+function matchesSearch(label, search) {
+  return label.toLowerCase().includes(search.toLowerCase());
+}
+function columnValueOptions(rows, dataColumns, filter, columnId, query = {}) {
+  const column = dataColumns.find((entry) => entry.id === columnId)?.column;
+  if (column === void 0) {
+    return { options: [], total: 0, truncated: false, blanks: 0 };
+  }
+  const keep = compileFilter(
+    filter.filter((entry) => !touchesColumn(entry, columnId)),
+    dataColumns
+  );
+  const buckets = /* @__PURE__ */ new Map();
+  let blanks = 0;
+  for (const row of rows) {
+    if (keep !== void 0 && !keep(row)) {
       continue;
     }
-    if (levelFloor !== null && "kind" in entry && entry.kind === "group" && entry.level <= levelFloor) {
-      break;
-    }
-    index++;
-    if (!("kind" in entry) || entry.kind !== "group") {
-      out.push(entry);
-      continue;
+    const value = accessDotted(row, column.field);
+    if (isEmptyCell(value)) {
+      blanks++;
+    } else if (isOfferable(value)) {
+      const key = bucketKey(value);
+      const bucket = buckets.get(key);
+      if (bucket === void 0) {
+        buckets.set(key, { value, row, count: 1 });
+      } else {
+        bucket.count++;
+      }
     }
-    const leaves = leafDescendantsOf(flatRows, entry.path, groupBy, byId);
-    const aggregates = computeAggregates(leaves, specs, columns);
-    const withAggregates = { ...entry, aggregates };
-    out.push(withAggregates);
-    index = appendAggregatedSpan(
-      displayRows,
-      index,
-      entry.level,
-      flatRows,
-      groupBy,
-      byId,
-      specs,
-      columns,
-      display,
-      out
-    );
-    if (display === "row") {
-      const summary = {
-        kind: "group-summary",
-        groupId: entry.groupId,
-        level: entry.level,
-        rowIndex: -1,
-        datasetIndex: -1,
-        aggregates
+  }
+  const { search = "", limit, locale } = query;
+  const options = [...buckets.values()].sort((a, b) => compareValues(a.value, b.value, column.type)).map(({ value, row, count }) => ({
+    value,
+    label: formatCellValue(value, column, locale, row),
+    count
+  })).filter((option) => matchesSearch(option.label, search));
+  const shown = limit === void 0 ? options : options.slice(0, limit);
+  return {
+    options: shown,
+    total: options.length,
+    truncated: shown.length < options.length,
+    blanks
+  };
+}
+function everyOption(options) {
+  return new Map(
+    options.map((option) => [bucketKey(option.value), option.value])
+  );
+}
+function initialFilterEditorDraft(shape, values) {
+  const draft = {
+    mode: "values",
+    options: values.options,
+    blanks: values.blanks,
+    search: "",
+    checked: everyOption(values.options),
+    includeBlanks: values.blanks > 0,
+    conditions: [],
+    combinator: "and"
+  };
+  switch (shape.kind) {
+    case "values":
+      return {
+        ...draft,
+        checked: new Map(
+          shape.values.filter((value) => !isEmptyCell(value)).map((value) => [bucketKey(value), value])
+        ),
+        includeBlanks: shape.includeBlanks
       };
-      out.push(summary);
+    case "conditions":
+      return {
+        ...draft,
+        mode: "conditions",
+        conditions: shape.conditions,
+        combinator: shape.combinator
+      };
+    case "none":
+    case "custom":
+      return draft;
+  }
+}
+function visibleFilterOptions(draft) {
+  return draft.search === "" ? draft.options : draft.options.filter(
+    (option) => matchesSearch(option.label, draft.search)
+  );
+}
+function selectAllCoversBlanks(draft) {
+  return draft.search === "" && draft.blanks > 0;
+}
+function selectAllState(draft) {
+  const states = visibleFilterOptions(draft).map(
+    (option) => draft.checked.has(bucketKey(option.value))
+  );
+  if (selectAllCoversBlanks(draft)) {
+    states.push(draft.includeBlanks);
+  }
+  if (states.length > 0 && states.every(Boolean)) {
+    return "checked";
+  }
+  return states.some(Boolean) ? "mixed" : "unchecked";
+}
+function toggleAll(draft) {
+  const check = selectAllState(draft) !== "checked";
+  const checked = new Map(draft.checked);
+  for (const option of visibleFilterOptions(draft)) {
+    const key = bucketKey(option.value);
+    if (check) {
+      checked.set(key, option.value);
+    } else {
+      checked.delete(key);
     }
   }
-  return index;
+  return {
+    ...draft,
+    mode: "values",
+    checked,
+    includeBlanks: selectAllCoversBlanks(draft) ? check : draft.includeBlanks
+  };
 }
-function withGroupAggregates(displayRows, flatRows, groupBy, specs, columns, display = "inline") {
-  if (specs.length === 0) {
-    return displayRows;
+function filterEditorReducer(draft, action) {
+  switch (action.type) {
+    case "search":
+      return { ...draft, search: action.search };
+    case "toggleValue": {
+      const key = bucketKey(action.value);
+      const checked = new Map(draft.checked);
+      if (checked.has(key)) {
+        checked.delete(key);
+      } else {
+        checked.set(key, action.value);
+      }
+      return { ...draft, mode: "values", checked };
+    }
+    case "toggleAll":
+      return toggleAll(draft);
+    case "setIncludeBlanks":
+      return { ...draft, mode: "values", includeBlanks: action.includeBlanks };
+    case "setConditions":
+      return {
+        ...draft,
+        mode: "conditions",
+        conditions: action.conditions,
+        combinator: action.combinator ?? draft.combinator
+      };
+    case "clear":
+      return {
+        ...draft,
+        search: "",
+        checked: everyOption(draft.options),
+        includeBlanks: draft.blanks > 0,
+        conditions: []
+      };
   }
-  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
-  const out = [];
-  appendAggregatedSpan(
-    displayRows,
-    0,
-    null,
-    flatRows,
-    groupBy,
-    byId,
-    specs,
-    columns,
-    display,
-    out
-  );
-  return out.map((entry, position) => {
-    if ("kind" in entry) {
-      return entry.rowIndex === position && entry.datasetIndex === position ? entry : { ...entry, rowIndex: position, datasetIndex: position };
+}
+function checksEverything(draft) {
+  return draft.options.every(
+    (option) => draft.checked.has(bucketKey(option.value))
+  ) && (draft.includeBlanks || draft.blanks === 0);
+}
+function draftEntries(draft, columnId) {
+  if (draft.mode === "conditions") {
+    const conditions = draft.conditions.map((condition) => ({
+      ...condition,
+      columnId
+    }));
+    return conditions.length > 1 ? [{ combinator: draft.combinator, entries: conditions }] : conditions;
+  }
+  if (checksEverything(draft)) {
+    return [];
+  }
+  const picked = {
+    columnId,
+    operator: "in",
+    value: [...draft.checked.values()]
+  };
+  return draft.includeBlanks ? [
+    {
+      combinator: "or",
+      entries: [picked, { columnId, operator: "isEmpty" }]
     }
-    return entry.rowIndex === position ? entry : { ...entry, rowIndex: position };
-  });
+  ] : [picked];
+}
+function draftToFilter(draft, columnId, current) {
+  const replacement = draftEntries(draft, columnId);
+  const first = current.findIndex((entry) => touchesColumn(entry, columnId));
+  if (first === -1) {
+    return replacement.length === 0 ? current : [...current, ...replacement];
+  }
+  const kept = current.filter((entry) => !touchesColumn(entry, columnId));
+  return [...kept.slice(0, first), ...replacement, ...kept.slice(first)];
+}
+
+// src/messages.ts
+function selectedCount(count, target) {
+  const noun = target === "rows" ? "row" : "column";
+  if (count === 0) {
+    return `No ${noun}s selected`;
+  }
+  return count === 1 ? `1 ${noun} selected` : `${String(count)} ${noun}s selected`;
+}
+var defaultMessages = {
+  pagerLabel: "Pagination",
+  previousPage: "Previous",
+  nextPage: "Next",
+  pageSizeLabel: "Rows per page",
+  pageButtonLabel: (page) => `Page ${String(page)}`,
+  pageStatus: (page, pageCount) => `Page ${String(page)} of ${String(pageCount)}`,
+  loadingMore: "Loading more\u2026",
+  booleanTrue: "true",
+  booleanFalse: "false",
+  blankGroupValue: "(blank)",
+  groupByBarLabel: "Grouped by",
+  groupByBarPlaceholder: "Drag a column here to group by it",
+  groupByChipLabel: (columnName, level, levelCount) => levelCount > 1 ? `${columnName}, level ${String(level)} of ${String(levelCount)}` : columnName,
+  removeGroupBy: (columnName) => `Stop grouping by ${columnName}`,
+  columnResized: (columnName, width) => `${columnName}, ${String(width)} pixels wide`,
+  columnMoved: (columnName, position, columnCount) => `${columnName}, column ${String(position)} of ${String(columnCount)}`,
+  columnSorted: (columnName, direction, key, keyCount) => {
+    const sorted = `${columnName} sorted ${direction === "asc" ? "ascending" : "descending"}`;
+    return keyCount > 1 ? `${sorted}, key ${String(key)} of ${String(keyCount)}` : sorted;
+  },
+  sortCleared: (columnName) => `${columnName}, sort cleared`,
+  groupedBy: (columnName, level, levelCount) => levelCount > 1 ? `Grouped by ${columnName}, level ${String(level)} of ${String(levelCount)}` : `Grouped by ${columnName}`,
+  groupingRemoved: (columnName) => `${columnName}, grouping removed`,
+  groupExpanded: "Group expanded",
+  groupCollapsed: "Group collapsed",
+  allGroupsExpanded: "All groups expanded",
+  allGroupsCollapsed: "All groups collapsed",
+  selectedCount,
+  cellSelected: (columnName, rowNumber) => `${columnName}, row ${String(rowNumber)}, selected`
+};
+function resolveMessages(messages) {
+  return messages === void 0 ? defaultMessages : { ...defaultMessages, ...messages };
 }
 
 // src/util/virtualization.ts
@@ -1190,6 +2748,7 @@ export {
   alignmentForType,
   applyColumnOrder,
   applyColumnResize,
+  applyColumnVisibility,
   applySelectionIntent,
   beginColumnResize,
   buildKeyShortcuts,
@@ -1198,18 +2757,29 @@ export {
   clearAllFilters,
   clearSelection,
   collapseAllGroups,
+  columnValueOptions,
   compareValues,
   computeAggregates,
+  createGridController,
+  createGridViewResolver,
+  defaultMessages,
   defineColumnsFromRows,
+  describeColumnFilter,
   diffSelection,
+  draftToFilter,
   expandAllGroups,
+  filterEditorReducer,
   filterQueryFor,
   filterRows,
   fitColumnsToWidth,
+  formatAggregateValue,
+  formatCellValue,
   getColumnId,
   groupRowId,
   groupRows,
+  initialFilterEditorDraft,
   intentOf,
+  isColumnVisible,
   isSameCell,
   matchesQuery,
   moveColumnBefore,
@@ -1221,20 +2791,27 @@ export {
   paginationWindow,
   resolveCell,
   resolveColumnConstraints,
+  resolveColumnHeaderText,
   resolveColumnLabel,
   resolveColumnWidths,
   resolveColumns,
+  resolveDataColumns,
   resolveDropBefore,
+  resolveGridView,
   resolveKeyboardDropTarget,
+  resolveMessages,
   resolveRowId,
   resolveRows,
   resolveShownRows,
   revertColumnSize,
   selectAll,
+  selectAllState,
   selectCell,
   selectOnly,
   selectRange,
+  serializeGridState,
   setColumnFilter,
+  setColumnVisibility,
   sizeColumnToContent,
   sortDirectionFor,
   sortPriorityFor,
@@ -1244,6 +2821,7 @@ export {
   toggleGroupExpansion,
   toggleSelection,
   totalColumnWidth,
+  visibleFilterOptions,
   visibleRange,
   withGroupAggregates
 };