@gridkitjs/core 0.10.0 → 0.12.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" : "",
@@ -80,855 +90,2808 @@ function buildKeyShortcuts(capabilities) {
     capabilities.sortable ? "Alt+ArrowUp" : "",
     // Down rather than reusing Up: it reads as "drill into groups", and Up is
     // already sort's own mnemonic on the same header.
-    capabilities.groupable ? "Alt+ArrowDown" : ""
+    capabilities.groupable ? "Alt+ArrowDown" : "",
+    // The ContextMenu key needs no mention: it says what it does on its face.
+    capabilities.contextMenu === true ? "Shift+F10" : ""
   ].filter(Boolean).join(" ");
 }
 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);
+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 anchor = orderedIds.indexOf(anchorId);
-  const focus = orderedIds.indexOf(focusId);
-  if (anchor === -1 || focus === -1) {
-    return selection;
+  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 buildLevel(rows, levels, parentPath, expansion, byId, out) {
+  const level = levels[0];
+  if (level === void 0) {
+    out.push(...rows);
+    return;
+  }
+  const column = byId.get(level.columnId);
+  if (column === void 0) {
+    out.push(...rows);
+    return;
+  }
+  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);
+    }
+  }
+}
+function groupRows(rows, groupBy, expansion, columns) {
+  if (groupBy.length === 0) {
+    return rows;
+  }
+  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 };
+  });
+}
+function toggleGroupExpansion(expansion, groupId) {
+  return expansion.includes(groupId) ? expansion.filter((id) => id !== groupId) : [...expansion, groupId];
+}
+function expandAllGroups(expansion) {
+  return expansion.length === 0 ? expansion : [];
+}
+function collapseAllGroups(rows) {
+  return rows.filter(
+    (entry) => "kind" in entry && entry.kind === "group"
+  ).map((entry) => entry.groupId);
+}
+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 movesGroupBy(groupBy, columnId, beforeColumnId) {
+  return moveGroupByBefore(groupBy, columnId, beforeColumnId) !== groupBy;
+}
+
+// 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;
+  };
+}
+
+// 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 resolveDataColumns(columns, order) {
+  return applyColumnOrder(columns, order).map((column) => ({
+    id: getColumnId(column),
+    column
+  }));
+}
+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 movesColumn(orderedIds, movedId, beforeId) {
+  return moveColumnBefore(orderedIds, movedId, beforeId) !== orderedIds;
+}
+function resolveDropBefore(orderedIds, targetId, side) {
+  if (side === "before") {
+    return targetId;
+  }
+  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 {
+      entry,
+      width: entry.width,
+      bound: growing ? constraints.maxWidth : constraints.minWidth,
+      adjustable: !entry.sized
+    };
+  });
+  if (!growing) {
+    const floor = entries.reduce(
+      (sum, item) => sum + (item.adjustable ? item.bound : item.width),
+      0
+    );
+    if (floor > target) {
+      return resolved;
+    }
+  }
+  redistribute(entries, (sum) => growing ? target - sum : sum - target);
+  const rounded = entries.map(
+    (item) => growing ? Math.floor(item.width) : Math.ceil(item.width)
+  );
+  let remainder = target - rounded.reduce((total2, width) => total2 + width, 0);
+  return entries.map((item, index) => {
+    let width = rounded[index] ?? item.width;
+    const hasRoom = growing ? width < item.bound : width > item.bound;
+    if (remainder !== 0 && item.adjustable && hasRoom) {
+      width += growing ? 1 : -1;
+      remainder += growing ? -1 : 1;
+    }
+    return { ...item.entry, width };
+  });
+}
+function sizeColumnToContent(measuredWidth, constraints, padding = 2) {
+  return clampColumnWidth(Math.ceil(measuredWidth + padding), constraints);
+}
+function revertColumnSize(current, base, columnId) {
+  const next = Object.fromEntries(
+    Object.entries(current).filter(([id]) => id !== columnId)
+  );
+  if (columnId in base) {
+    next[columnId] = base[columnId];
+  }
+  return next;
+}
+
+// src/util/aggregation.ts
+function isEmpty2(value) {
+  return value === null || value === void 0;
+}
+function toNumber(value) {
+  return Number(value);
+}
+function distinctKey(value) {
+  if (isEmpty2(value)) {
+    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 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 keyOf(spec) {
+  return spec.id ?? spec.columnId;
+}
+function computeAggregates(rows, specs, columns) {
+  const results = /* @__PURE__ */ new Map();
+  if (specs.length === 0) {
+    return results;
+  }
+  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);
+  }
+  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 index;
+}
+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 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 entry.rowIndex === position ? entry : { ...entry, rowIndex: position };
+  });
+}
+
+// src/util/filtering.ts
+function parseFilterPattern(query) {
+  const start = query.startsWith("%");
+  const end = query.endsWith("%");
+  let text = query;
+  if (start) {
+    text = text.slice(1);
+  }
+  if (end) {
+    text = text.slice(0, -1);
+  }
+  text = text.toLowerCase();
+  if (start && end) {
+    return { mode: "contains", text };
+  }
+  if (start) {
+    return { mode: "endsWith", text };
+  }
+  if (end) {
+    return { mode: "startsWith", text };
+  }
+  return { mode: "exact", text };
+}
+function isEmptyValue(value) {
+  return value === null || value === void 0;
+}
+function compileFilterQuery(query) {
+  const { mode, text } = parseFilterPattern(query);
+  return (value) => {
+    const candidate = (isEmptyValue(value) ? "" : String(value)).toLowerCase();
+    switch (mode) {
+      case "exact":
+        return candidate === text;
+      case "contains":
+        return candidate.includes(text);
+      case "startsWith":
+        return candidate.startsWith(text);
+      case "endsWith":
+        return candidate.endsWith(text);
+    }
+  };
+}
+function matchesTypedValue(value, target, type) {
+  if (typeof target === "number") {
+    if (type !== "number" && type !== "decimal" && type !== "currency" && type !== "percent") {
+      return false;
+    }
+    return typeof value === "number" && value === target;
+  }
+  if (typeof target === "boolean") {
+    if (type !== "boolean") {
+      return false;
+    }
+    return typeof value === "boolean" && value === target;
+  }
+  if (type !== "date" && type !== "dateTime" && type !== "time") {
+    return false;
+  }
+  return value instanceof Date && value.getTime() === target.getTime();
+}
+function isEntryUsable(entry, byId) {
+  if ("combinator" in entry) {
+    return true;
+  }
+  return entry.columnId === void 0 || byId.has(entry.columnId);
+}
+function compileFilterEntry(entry, byId, columns) {
+  if ("combinator" in entry) {
+    const tests = entry.entries.filter((nested) => isEntryUsable(nested, byId)).map((nested) => compileFilterEntry(nested, byId, columns));
+    return entry.combinator === "and" ? (row) => tests.every((test2) => test2(row)) : (row) => tests.some((test2) => test2(row));
+  }
+  if ("predicate" in entry) {
+    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, column.field),
+      row
+    );
   }
-  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;
+  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));
   }
-  return sameSelection(selection, orderedIds) ? selection : orderedIds;
+  if ("value" in entry) {
+    const { columnId: columnId2, value } = entry;
+    if (columnId2 !== void 0) {
+      const column = byId.get(columnId2);
+      if (column === void 0) {
+        return () => false;
+      }
+      return (row) => matchesTypedValue(accessDotted(row, column.field), value, column.type);
+    }
+    return (row) => columns.some(
+      (entry2) => matchesTypedValue(
+        accessDotted(row, entry2.column.field),
+        value,
+        entry2.column.type
+      )
+    );
+  }
+  const { columnId, query } = entry;
+  const test = compileFilterQuery(query);
+  if (columnId !== void 0) {
+    const column = byId.get(columnId);
+    if (column === void 0) {
+      return () => false;
+    }
+    return (row) => test(accessDotted(row, column.field));
+  }
+  return (row) => columns.some((entry2) => test(accessDotted(row, entry2.column.field)));
 }
-function clearSelection(selection) {
-  return selection.length === 0 ? selection : [];
+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 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))
-  };
+function matchesQuery(value, query) {
+  return compileFilterQuery(query)(value);
 }
-function isSameCell(a, b) {
-  if (a === null || b === null) {
-    return a === b;
-  }
-  return a.rowId === b.rowId && a.columnId === b.columnId;
+function filterQueryFor(filter, columnId) {
+  const entry = filter.find(
+    (candidate) => "query" in candidate && candidate.columnId === columnId
+  );
+  return entry?.query ?? null;
 }
-function selectCell(selection, cell, mode) {
-  if (mode === false || isSameCell(selection, cell)) {
-    return selection;
+function setColumnFilter(filter, columnId, query) {
+  const index = filter.findIndex(
+    (entry) => !("combinator" in entry) && entry.columnId === columnId
+  );
+  if (query === "") {
+    return index === -1 ? filter : filter.filter((_entry, i) => i !== index);
   }
-  return cell;
-}
-function toggleCellSelection(selection, cell, mode) {
-  if (mode === false) {
-    return selection;
+  const next = columnId === void 0 ? { query } : { columnId, query };
+  if (index === -1) {
+    return [...filter, next];
   }
-  return isSameCell(selection, cell) ? null : cell;
-}
-function intentOf(event) {
-  if (event.shiftKey) {
-    return "range";
+  const existing = filter[index];
+  if (existing !== void 0 && "query" in existing && existing.query === query) {
+    return filter;
   }
-  return event.ctrlKey || event.metaKey ? "toggle" : "replace";
+  return filter.map((entry, i) => i === index ? next : entry);
 }
-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);
+function clearAllFilters(filter) {
+  return filter.length === 0 ? filter : [];
+}
+function filterRows(rows, filter, columns) {
+  if (filter.length === 0) {
+    return rows;
+  }
+  const test = compileFilter(filter, columns);
+  if (test === void 0) {
+    return rows;
   }
+  const filtered = rows.filter((row) => test(row.row));
+  return filtered.map(
+    (row, index) => row.rowIndex === index ? row : { ...row, 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 };
+// src/util/rows.ts
+function resolveShownRows(rows, filter, sort, columns) {
+  return sortRows(filterRows(rows, filter, columns), sort, columns);
 }
-function resolveColumnConstraints(column, defaults) {
-  const resolved = withDefaults(defaults);
+function resolveRows(rowsById, ids) {
+  return ids.map((id) => rowsById.get(id)).filter((row) => row !== void 0);
+}
+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 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 {
-    minWidth: column.minWidth ?? resolved.minWidth,
-    maxWidth: column.maxWidth ?? resolved.maxWidth
+    rowId: cell.rowId,
+    columnId: cell.columnId,
+    row: entry.row,
+    column,
+    rowIndex: entry.rowIndex,
+    columnIndex,
+    value: accessDotted(entry.row, column.column.field)
   };
 }
-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")
-    };
-  });
+
+// src/util/visibility.ts
+function isColumnVisible(column, visibility) {
+  return visibility[getColumnId(column)] ?? column.hidden !== true;
 }
-function totalColumnWidth(resolved) {
-  return resolved.reduce((total, entry) => total + entry.width, 0);
+function applyColumnVisibility(columns, visibility) {
+  const visible = columns.filter(
+    (entry) => isColumnVisible(entry.column, visibility)
+  );
+  return visible.length === columns.length ? columns : visible;
 }
-function beginColumnResize(column, startWidth, startPosition, defaults) {
+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;
+  }
   return {
-    columnId: getColumnId(column),
-    startWidth,
-    startPosition,
-    constraints: resolveColumnConstraints(column, defaults)
+    ...visibility,
+    ...Object.fromEntries(changed.map((entry) => [entry.id, visible]))
   };
 }
-function applyColumnResize(session, position) {
-  return clampColumnWidth(
-    session.startWidth + (position - session.startPosition),
-    session.constraints
+
+// 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 reachedBound(width, item) {
-  return item.bound > item.width ? width >= item.bound : width <= item.bound;
+function totalAggregates(rows, aggregates, dataColumns) {
+  return computeAggregates(
+    rows.map((entry) => entry.row),
+    aggregates,
+    dataColumns
+  );
 }
-function redistribute(entries, remaining) {
-  for (; ; ) {
-    const movable = entries.filter(
-      (item) => item.adjustable && !reachedBound(item.width, item)
+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 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;
-      }
+    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;
     }
-    if (!clamped) {
-      break;
+  }
+  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 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]));
+  }
+  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);
+  }
+  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);
+  });
+}
+
+// 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 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 fitColumnsToWidth(resolved, availableWidth, defaults) {
-  const target = Math.floor(availableWidth);
-  const total = totalColumnWidth(resolved);
-  if (resolved.length === 0 || total === target) {
-    return resolved;
+function selectOnly(selection, id, mode) {
+  if (mode === false) {
+    return selection;
   }
-  const growing = total < target;
-  const entries = resolved.map((entry) => {
-    const constraints = resolveColumnConstraints(entry.column, defaults);
-    return {
-      entry,
-      width: entry.width,
-      bound: growing ? constraints.maxWidth : constraints.minWidth,
-      adjustable: !entry.sized
-    };
-  });
-  if (!growing) {
-    const floor = entries.reduce(
-      (sum, item) => sum + (item.adjustable ? item.bound : item.width),
-      0
-    );
-    if (floor > target) {
-      return resolved;
-    }
+  return selection.length === 1 && selection[0] === id ? selection : [id];
+}
+function selectRange(selection, orderedIds, anchorId, focusId, mode) {
+  if (mode !== "multiple") {
+    return selectOnly(selection, focusId, mode);
   }
-  redistribute(entries, (sum) => growing ? target - sum : sum - target);
-  const rounded = entries.map(
-    (item) => growing ? Math.floor(item.width) : Math.ceil(item.width)
+  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
   );
-  let remainder = target - rounded.reduce((total2, width) => total2 + width, 0);
-  return entries.map((item, index) => {
-    let width = rounded[index] ?? item.width;
-    const hasRoom = growing ? width < item.bound : width > item.bound;
-    if (remainder !== 0 && item.adjustable && hasRoom) {
-      width += growing ? 1 : -1;
-      remainder += growing ? -1 : 1;
-    }
-    return { ...item.entry, width };
-  });
+  return sameSelection(selection, next) ? selection : next;
 }
-function sizeColumnToContent(measuredWidth, constraints, padding = 2) {
-  return clampColumnWidth(Math.ceil(measuredWidth + padding), constraints);
+function selectAll(selection, orderedIds, mode) {
+  if (mode !== "multiple") {
+    return selection;
+  }
+  return sameSelection(selection, orderedIds) ? selection : orderedIds;
 }
-function revertColumnSize(current, base, columnId) {
-  const next = Object.fromEntries(
-    Object.entries(current).filter(([id]) => id !== columnId)
-  );
-  if (columnId in base) {
-    next[columnId] = base[columnId];
+function clearSelection(selection) {
+  return selection.length === 0 ? selection : [];
+}
+function diffSelection(previous, next) {
+  if (previous === next) {
+    return NO_CHANGE;
   }
-  return next;
+  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))
+  };
 }
-
-// src/util/sorting.ts
-function isEmpty(value) {
-  return value === null || value === void 0;
+function isSameCell(a, b) {
+  if (a === null || b === null) {
+    return a === b;
+  }
+  return a.rowId === b.rowId && a.columnId === b.columnId;
 }
-function toTime(value) {
-  return value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
+function selectCell(selection, cell, mode) {
+  if (mode === false || isSameCell(selection, cell)) {
+    return selection;
+  }
+  return cell;
 }
-function compareValues(a, b, type) {
-  if (isEmpty(a)) {
-    return isEmpty(b) ? 0 : 1;
+function toggleCellSelection(selection, cell, mode) {
+  if (mode === false) {
+    return selection;
   }
-  if (isEmpty(b)) {
-    return -1;
+  return isSameCell(selection, cell) ? null : cell;
+}
+function intentOf(event, options) {
+  if (event.shiftKey) {
+    return "range";
   }
-  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 String(a).localeCompare(String(b));
+  if (event.ctrlKey || event.metaKey) {
+    return "toggle";
   }
+  return options?.toggleOnClick === true ? "toggle" : "replace";
 }
-function sortDirectionFor(sort, columnId) {
-  return sort.find((entry) => entry.columnId === columnId)?.direction ?? null;
+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);
+  }
 }
-function sortPriorityFor(sort, columnId) {
-  const index = sort.findIndex((entry) => entry.columnId === columnId);
-  return index === -1 ? null : index + 1;
+
+// 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 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 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 });
   }
-  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);
+  if (added.length > 0) {
+    callbacks.onColumnsSelect?.({ columns: added, selection: next });
   }
-  if (index === -1) {
-    return [...sort, { columnId, direction: next }];
+  for (const column of removed) {
+    callbacks.onColumnDeselect?.({ column, selection: next });
   }
-  return sort.map(
-    (entry, i) => i === index ? { columnId, direction: next } : entry
-  );
+  if (removed.length > 0) {
+    callbacks.onColumnsDeselect?.({ columns: removed, selection: next });
+  }
+  callbacks.onColumnSelectionChange?.({
+    added,
+    removed,
+    selected: resolveColumns(columns, next),
+    selection: next
+  });
+  return diff;
 }
-function sortRows(rows, sort, columns) {
-  if (sort.length === 0) {
-    return rows;
+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 });
   }
-  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;
+  if (selected !== null) {
+    callbacks.onCellSelect?.({ cell: selected, selection: next });
   }
-  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;
+  callbacks.onCellSelectionChange?.({
+    selected,
+    deselected,
+    selection: next
   });
-  return sorted.map(
-    (row, index) => row.rowIndex === index ? row : { ...row, rowIndex: index }
-  );
 }
 
-// src/util/filtering.ts
-function parseFilterPattern(query) {
-  const start = query.startsWith("%");
-  const end = query.endsWith("%");
-  let text = query;
-  if (start) {
-    text = text.slice(1);
-  }
-  if (end) {
-    text = text.slice(0, -1);
+// 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
+    };
   }
-  text = text.toLowerCase();
-  if (start && end) {
-    return { mode: "contains", text };
+  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 });
+    });
   }
-  if (start) {
-    return { mode: "endsWith", text };
+  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
+      });
+    });
   }
-  if (end) {
-    return { mode: "startsWith", text };
+  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 { mode: "exact", text };
+  return {
+    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)
+      );
+    }
+  };
 }
-function isEmptyValue(value) {
-  return value === null || value === void 0;
+
+// 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 compileFilterQuery(query) {
-  const { mode, text } = parseFilterPattern(query);
-  return (value) => {
-    const candidate = (isEmptyValue(value) ? "" : String(value)).toLowerCase();
-    switch (mode) {
-      case "exact":
-        return candidate === text;
-      case "contains":
-        return candidate.includes(text);
-      case "startsWith":
-        return candidate.startsWith(text);
-      case "endsWith":
-        return candidate.endsWith(text);
-    }
+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 matchesTypedValue(value, target, type) {
-  if (typeof target === "number") {
-    if (type !== "number" && type !== "decimal" && type !== "currency" && type !== "percent") {
-      return false;
+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.`
+      );
     }
-    return typeof value === "number" && value === target;
   }
-  if (typeof target === "boolean") {
-    if (type !== "boolean") {
-      return false;
+  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 };
+      }
     }
-    return typeof value === "boolean" && value === target;
+    state = SLICE_KEYS.every((key) => next[key] === state[key]) ? state : next;
   }
-  if (type !== "date" && type !== "dateTime" && type !== "time") {
-    return false;
+  function notify() {
+    for (const listener of [...listeners]) {
+      listener();
+    }
   }
-  return value instanceof Date && value.getTime() === target.getTime();
-}
-function isEntryUsable(entry, byId) {
-  if ("combinator" in entry) {
-    return true;
+  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
+      }
+    });
   }
-  return entry.columnId === void 0 || byId.has(entry.columnId);
-}
-function compileFilterEntry(entry, byId, columns) {
-  if ("combinator" in entry) {
-    const tests = entry.entries.filter((nested) => isEntryUsable(nested, byId)).map((nested) => compileFilterEntry(nested, byId, columns));
-    return entry.combinator === "and" ? (row) => tests.every((test2) => test2(row)) : (row) => tests.some((test2) => test2(row));
+  function commitColumnSizing(next, columnId, width, phase) {
+    commit("columnSizing", next, () => {
+      options.onColumnResize?.({ columnId, width, sizing: next, phase });
+    });
   }
-  if ("predicate" in entry) {
-    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
+  function definedWidth(columnId) {
+    const entry = getView().dataColumns.find(
+      (candidate) => candidate.id === columnId
     );
-  }
-  if ("value" in entry) {
-    const { columnId: columnId2, value } = entry;
-    if (columnId2 !== void 0) {
-      const column = byId.get(columnId2);
-      if (column === void 0) {
-        return () => false;
+    const [resolved] = entry === void 0 ? [] : resolveColumnWidths(
+      [entry.column],
+      {},
+      {
+        sizes: options.columnSizeDefaults
       }
-      return (row) => matchesTypedValue(
-        accessDotted(row.row, column.field),
-        value,
-        column.type
-      );
-    }
-    return (row) => columns.some(
-      (entry2) => matchesTypedValue(
-        accessDotted(row.row, entry2.column.field),
-        value,
-        entry2.column.type
+    );
+    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
       )
     );
   }
-  const { columnId, query } = entry;
-  const test = compileFilterQuery(query);
-  if (columnId !== void 0) {
-    const column = byId.get(columnId);
-    if (column === void 0) {
-      return () => false;
-    }
-    return (row) => test(accessDotted(row.row, column.field));
+  function commitGroupBy(next, columnId) {
+    commit("groupBy", next, () => {
+      options.onGroupByChange?.({ columnId, groupBy: next });
+    });
   }
-  return (row) => columns.some((entry2) => test(accessDotted(row.row, entry2.column.field)));
-}
-function matchesQuery(value, query) {
-  return compileFilterQuery(query)(value);
-}
-function filterQueryFor(filter, columnId) {
-  const entry = filter.find(
-    (candidate) => "query" in candidate && candidate.columnId === columnId
-  );
-  return entry?.query ?? null;
-}
-function setColumnFilter(filter, columnId, query) {
-  const index = filter.findIndex(
-    (entry) => !("combinator" in entry) && entry.columnId === columnId
-  );
-  if (query === "") {
-    return index === -1 ? filter : filter.filter((_entry, i) => i !== index);
+  function commitGroupExpansion(next, groupId) {
+    commit("groupExpansion", next, () => {
+      options.onGroupExpansionChange?.({ groupId, expansion: next });
+    });
   }
-  const next = columnId === void 0 ? { query } : { columnId, query };
-  if (index === -1) {
-    return [...filter, next];
+  function commitPagination(next) {
+    if (samePagination(state.pagination, next)) {
+      return;
+    }
+    commit("pagination", next, () => {
+      options.onPaginationChange?.({
+        pagination: next,
+        pageCount: paginateRows(getView().displayRows, next).pageCount
+      });
+    });
   }
-  const existing = filter[index];
-  if (existing !== void 0 && "query" in existing && existing.query === query) {
-    return filter;
+  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 });
+      });
+    },
+    clearColumnSort(columnId) {
+      const next = state.columnSort.filter(
+        (entry) => entry.columnId !== columnId
+      );
+      if (next.length === state.columnSort.length) {
+        return;
+      }
+      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: commitPagination,
+    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 filter.map((entry, i) => i === index ? next : entry);
+  return controller;
 }
-function clearAllFilters(filter) {
-  return filter.length === 0 ? filter : [];
-}
-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) {
-    return rows;
+
+// src/commands/context.ts
+function selectedRowsOf(rows, selection) {
+  if (selection.length === 0) {
+    return [];
   }
-  const compiled = active.map(
-    (entry) => compileFilterEntry(entry, byId, columns)
-  );
-  const filtered = rows.filter((row) => compiled.every((test) => test(row)));
-  return filtered.map(
-    (row, index) => row.rowIndex === index ? row : { ...row, rowIndex: index }
-  );
+  const selected = new Set(selection);
+  return rows.filter((entry) => selected.has(entry.rowId));
+}
+function createCommandContext({
+  controller,
+  target,
+  messages,
+  host
+}) {
+  const state = controller.getState();
+  const view = controller.getView();
+  let selectedRows;
+  return {
+    target,
+    state,
+    view,
+    options: controller.getOptions(),
+    messages,
+    actions: controller,
+    host,
+    row: target.area === "cell" ? view.rows.find((entry) => entry.rowId === target.rowId) ?? null : null,
+    column: "columnId" in target ? view.dataColumns.find((entry) => entry.id === target.columnId) ?? null : null,
+    selectedRows: () => selectedRows ??= selectedRowsOf(view.rows, state.rowSelection)
+  };
 }
 
-// src/util/grouping.ts
-function groupRowId(path) {
-  return JSON.stringify(path);
+// src/commands/builtInCommands.ts
+function isOn(context, areas) {
+  return areas.includes(context.target.area);
 }
-function bucketKey(value) {
-  if (value === null || value === void 0) {
-    return "\0empty";
-  }
-  if (value instanceof Date) {
-    return `\0date:${String(value.getTime())}`;
+function columnOn(context, areas) {
+  return isOn(context, areas) ? context.column : null;
+}
+function isGroupedBy(context, columnId) {
+  return context.state.groupBy.some((entry) => entry.columnId === columnId);
+}
+function sortableColumn(context) {
+  const column = columnOn(context, ["header"]);
+  return column !== null && (column.column.sortable ?? context.options.sortableColumns ?? false) ? column : null;
+}
+function groupableColumn(context) {
+  const column = columnOn(context, ["header"]);
+  return column !== null && (column.column.groupable ?? context.options.groupableColumns ?? false) && !isGroupedBy(context, column.id) ? column : null;
+}
+function groupedColumn(context) {
+  const column = columnOn(context, ["header", "group"]);
+  return column !== null && isGroupedBy(context, column.id) ? column : null;
+}
+function hideableColumn(context) {
+  const column = columnOn(context, ["header"]);
+  return column !== null && column.column.hideable !== false ? column : null;
+}
+function resizableColumn(context) {
+  const column = columnOn(context, ["header"]);
+  if (column === null) {
+    return null;
   }
-  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 context.view.columns.find(
+    (entry) => entry.id === column.id && entry.resizable
+  ) ?? null;
+}
+function resizableColumnIds(context) {
+  return context.view.columns.filter((entry) => entry.resizable).map((entry) => entry.id);
+}
+function isAnythingSelectable(selectable) {
+  return [selectable?.rows, selectable?.columns, selectable?.cells].some(
+    (mode) => mode !== void 0 && mode !== false
+  );
+}
+function columnName(context) {
+  return context.column === null ? "" : resolveColumnHeaderText(context.column.column);
+}
+function columnCommand({
+  id,
+  label,
+  icon,
+  find,
+  isEnabled,
+  isChecked,
+  execute
+}) {
+  function test(predicate) {
+    return (context) => {
+      const column = find(context);
+      return column !== null && predicate(column, context);
+    };
   }
+  return {
+    id,
+    label,
+    icon,
+    isVisible: (context) => find(context) !== null,
+    isEnabled: isEnabled === void 0 ? void 0 : test(isEnabled),
+    isChecked: isChecked === void 0 ? void 0 : test(isChecked),
+    execute: (context) => {
+      const column = find(context);
+      if (column !== null) {
+        execute(column, context);
+      }
+    }
+  };
 }
-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 sortCommand(direction) {
+  return columnCommand({
+    id: direction === "asc" ? "sort.ascending" : "sort.descending",
+    label: ({ messages }) => direction === "asc" ? messages.sortAscending : messages.sortDescending,
+    icon: direction === "asc" ? "sortAscending" : "sortDescending",
+    find: sortableColumn,
+    isChecked: (column, { state }) => sortDirectionFor(state.columnSort, column.id) === direction,
+    execute: (column, { actions }) => {
+      actions.setColumnSort([{ columnId: column.id, direction }]);
     }
-  }
-  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 buildLevel(rows, levels, parentPath, expansion, byId, out) {
-  const level = levels[0];
-  if (level === void 0) {
-    out.push(...rows);
-    return;
-  }
-  const column = byId.get(level.columnId);
-  if (column === void 0) {
-    out.push(...rows);
-    return;
-  }
-  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);
+function builtInCommands() {
+  return [
+    sortCommand("asc"),
+    sortCommand("desc"),
+    // Cleared rather than set, so the change reports this column — the one
+    // the announcement names — rather than a key that moved up past it.
+    columnCommand({
+      id: "sort.clear",
+      label: ({ messages }) => messages.clearSort,
+      find: sortableColumn,
+      isEnabled: (column, { state }) => sortDirectionFor(state.columnSort, column.id) !== null,
+      execute: (column, { actions }) => {
+        actions.clearColumnSort(column.id);
+      }
+    }),
+    {
+      id: "sort.clearAll",
+      label: ({ messages }) => messages.clearAllSorting,
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
+      isEnabled: ({ state }) => state.columnSort.length > 0,
+      execute: ({ actions }) => {
+        actions.setColumnSort([]);
+      }
+    },
+    columnCommand({
+      id: "group.add",
+      label: (context) => context.messages.groupByColumn(columnName(context)),
+      icon: "group",
+      find: groupableColumn,
+      execute: (column, { actions }) => {
+        actions.toggleGroupBy(column.id);
+      }
+    }),
+    // Toggled rather than set, so the change reports this column — the one
+    // the announcement names — rather than the level that moved up.
+    columnCommand({
+      id: "group.remove",
+      label: (context) => context.messages.removeGroupBy(columnName(context)),
+      icon: "group",
+      find: groupedColumn,
+      execute: (column, { actions }) => {
+        actions.toggleGroupBy(column.id);
+      }
+    }),
+    {
+      id: "group.clearAll",
+      label: ({ messages }) => messages.ungroupAll,
+      isVisible: (context) => isOn(context, ["grid", "toolbar"]) && context.state.groupBy.length > 0,
+      execute: ({ actions }) => {
+        actions.setGroupBy([]);
+      }
+    },
+    {
+      id: "group.expandAll",
+      label: ({ messages }) => messages.expandAllGroups,
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "group", "cell"]) && context.state.groupBy.length > 0,
+      execute: ({ actions }) => {
+        actions.expandAllGroups();
+      }
+    },
+    {
+      id: "group.collapseAll",
+      label: ({ messages }) => messages.collapseAllGroups,
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "group", "cell"]) && context.state.groupBy.length > 0,
+      execute: ({ actions }) => {
+        actions.collapseAllGroups();
+      }
+    },
+    columnCommand({
+      id: "column.hide",
+      label: ({ messages }) => messages.hideColumn,
+      icon: "hide",
+      find: hideableColumn,
+      // The last column shown stays: a grid with none has no header left to
+      // bring one back from.
+      isEnabled: (column, { view }) => view.columns.some((entry) => entry.id !== column.id),
+      execute: (column, { actions }) => {
+        actions.hideColumns([column.id]);
+      }
+    }),
+    columnCommand({
+      id: "column.autoFit",
+      label: ({ messages }) => messages.autoFitColumn,
+      icon: "autoFit",
+      find: resizableColumn,
+      execute: (column, { host }) => {
+        host.autoFitColumns([column.id]);
+      }
+    }),
+    {
+      id: "column.autoFitAll",
+      label: ({ messages }) => messages.autoFitAllColumns,
+      icon: "autoFit",
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]) && resizableColumnIds(context).length > 0,
+      execute: (context) => {
+        context.host.autoFitColumns(resizableColumnIds(context));
+      }
+    },
+    // The target goes along, so the renderer opens the chooser where it was
+    // asked for: beside the toolbar button, below the header, or at the
+    // grid's corner for a call from nowhere in particular.
+    {
+      id: "column.choose",
+      label: ({ messages }) => messages.chooseColumns,
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
+      execute: ({ host, target }) => {
+        host.openPanel("columnChooser", target);
+      }
+    },
+    {
+      id: "selection.selectAllRows",
+      label: ({ messages }) => messages.selectAllRows,
+      isVisible: (context) => isOn(context, ["grid", "cell"]) && context.options.selectable?.rows === "multiple",
+      isEnabled: ({ view }) => view.displayDataRows.length > 0,
+      execute: ({ actions }) => {
+        actions.selectAllRows();
+      }
+    },
+    {
+      id: "selection.clear",
+      label: ({ messages }) => messages.clearSelection,
+      isVisible: (context) => isOn(context, ["grid", "cell", "header"]) && isAnythingSelectable(context.options.selectable),
+      isEnabled: ({ state }) => state.rowSelection.length > 0 || state.columnSelection.length > 0 || state.cellSelection !== null,
+      execute: ({ actions }) => {
+        actions.clearSelection();
+      }
+    },
+    {
+      id: "filter.clearAll",
+      label: ({ messages }) => messages.clearFilters,
+      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
+      isEnabled: ({ state }) => state.filter.length > 0,
+      execute: ({ actions }) => {
+        actions.setFilter([]);
+      }
+    }
+  ];
+}
+
+// src/commands/registry.ts
+function isCommandVisible(command, context) {
+  return command.isVisible?.(context) ?? true;
+}
+function isCommandEnabled(command, context) {
+  return command.isEnabled?.(context) ?? true;
+}
+function resolveCommands(commands) {
+  const registry = new Map(
+    builtInCommands().map((command) => [command.id, command])
+  );
+  for (const command of commands ?? []) {
+    if (command.id === "separator") {
+      reportError(
+        "a command cannot have the id `separator`, which a menu reads as a separator, so it is left out."
+      );
+      continue;
     }
+    registry.set(command.id, command);
   }
+  return registry;
 }
-function groupRows(rows, groupBy, expansion, columns) {
-  if (groupBy.length === 0) {
-    return rows;
+function runCommand(command, context) {
+  if (!isCommandVisible(command, context) || !isCommandEnabled(command, context)) {
+    return false;
   }
-  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;
+  command.execute(context);
+  return true;
+}
+
+// src/menu/resolveMenu.ts
+var reportedUnknownIds = /* @__PURE__ */ new WeakMap();
+function reportUnknownId(commands, id) {
+  let reported = reportedUnknownIds.get(commands);
+  if (reported === void 0) {
+    reported = /* @__PURE__ */ new Set();
+    reportedUnknownIds.set(commands, reported);
+  }
+  if (reported.has(id)) {
+    return;
   }
-  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 };
-  });
+  reported.add(id);
+  reportError(
+    `the menu or toolbar entry \`${id}\` names no command, so it is left out.`
+  );
 }
-function toggleGroupExpansion(expansion, groupId) {
-  return expansion.includes(groupId) ? expansion.filter((id) => id !== groupId) : [...expansion, groupId];
+function evaluate(value, context) {
+  return typeof value === "function" ? value(context) : value;
 }
-function expandAllGroups(expansion) {
-  return expansion.length === 0 ? expansion : [];
+function commandItem(command, context) {
+  if (!isCommandVisible(command, context)) {
+    return null;
+  }
+  return {
+    type: "item",
+    id: command.id,
+    label: evaluate(command.label, context),
+    icon: command.icon,
+    shortcut: command.shortcut,
+    disabled: !isCommandEnabled(command, context),
+    checked: command.isChecked?.(context),
+    run: () => runCommand(command, context)
+  };
 }
-function collapseAllGroups(rows) {
-  return rows.filter((entry) => "kind" in entry).map((entry) => entry.groupId);
+function inlineItem(entry, context) {
+  if (evaluate(entry.hidden ?? false, context)) {
+    return null;
+  }
+  const disabled = evaluate(entry.disabled ?? false, context);
+  return {
+    type: "item",
+    id: entry.id,
+    label: evaluate(entry.label, context),
+    icon: entry.icon,
+    shortcut: entry.shortcut,
+    disabled,
+    checked: entry.checked === void 0 ? void 0 : evaluate(entry.checked, context),
+    run: () => {
+      if (disabled) {
+        return false;
+      }
+      entry.onSelect(context);
+      return true;
+    }
+  };
 }
-function moveGroupByBefore(groupBy, columnId, beforeColumnId) {
-  if (columnId === beforeColumnId) {
-    return groupBy;
+function collapseSeparators(entries, isEdge = () => false) {
+  const collapsed = [];
+  for (const entry of entries) {
+    const previous = collapsed.at(-1);
+    if (entry.type !== "separator") {
+      if (isEdge(entry) && previous?.type === "separator") {
+        collapsed.pop();
+      }
+      collapsed.push(entry);
+    } else if (previous !== void 0 && previous.type !== "separator" && !isEdge(previous)) {
+      collapsed.push(entry);
+    }
   }
-  const without = groupBy.filter((entry) => entry.columnId !== columnId);
-  const moved = groupBy.find((entry) => entry.columnId === columnId) ?? {
-    columnId
+  if (collapsed.at(-1)?.type === "separator") {
+    collapsed.pop();
+  }
+  return collapsed;
+}
+function resolveMenuEntry(entry, index, options) {
+  const { commands, context } = options;
+  if (entry === "separator") {
+    return { type: "separator", key: `separator-${String(index)}` };
+  }
+  if (typeof entry === "string") {
+    const command = commands.get(entry);
+    if (command === void 0) {
+      reportUnknownId(commands, entry);
+      return null;
+    }
+    return commandItem(command, context);
+  }
+  return entry.type === "item" ? inlineItem(entry, context) : resolveSubmenu(entry, options);
+}
+function resolveSubmenu(entry, options) {
+  const items = resolveMenu(entry.items, options);
+  return items.length === 0 ? null : {
+    type: "submenu",
+    id: entry.id,
+    label: evaluate(entry.label, options.context),
+    icon: entry.icon,
+    items
   };
-  const target = beforeColumnId === null ? without.length : without.findIndex((entry) => entry.columnId === beforeColumnId);
-  if (target === -1) {
-    return groupBy;
+}
+function resolveMenu(entries, options) {
+  return collapseSeparators(
+    entries.map((entry, index) => resolveMenuEntry(entry, index, options)).filter((entry) => entry !== null)
+  );
+}
+
+// src/menu/contextMenu.ts
+var defaultContextMenu = {
+  header: [
+    "sort.ascending",
+    "sort.descending",
+    "sort.clear",
+    "separator",
+    "group.add",
+    "group.remove",
+    "separator",
+    "column.autoFit",
+    "column.autoFitAll",
+    "separator",
+    "column.hide",
+    "column.choose"
+  ],
+  cell: [
+    "selection.selectAllRows",
+    "selection.clear",
+    "separator",
+    "group.expandAll",
+    "group.collapseAll"
+  ],
+  group: ["group.expandAll", "group.collapseAll", "separator", "group.remove"],
+  body: []
+};
+function hasContextMenu(contextMenu, area) {
+  if (contextMenu === void 0 || contextMenu === false) {
+    return false;
   }
-  const next = [...without];
-  next.splice(target, 0, moved);
-  return next.length === groupBy.length && next.every((entry, index) => entry === groupBy[index]) ? groupBy : next;
+  const entries = (contextMenu === true ? void 0 : contextMenu[area]) ?? defaultContextMenu[area];
+  return typeof entries === "function" || entries.length > 0;
 }
-function movesGroupBy(groupBy, columnId, beforeColumnId) {
-  return moveGroupByBefore(groupBy, columnId, beforeColumnId) !== groupBy;
+function entriesFor(given, request) {
+  if (given === void 0) {
+    return request.defaults;
+  }
+  return typeof given === "function" ? given(request) ?? [] : given;
+}
+function contextMenuEntries(contextMenu, context) {
+  if (contextMenu === void 0 || contextMenu === false) {
+    return [];
+  }
+  const options = contextMenu === true ? {} : contextMenu;
+  const { target } = context;
+  switch (target.area) {
+    case "header":
+      return entriesFor(options.header, {
+        target,
+        defaults: defaultContextMenu.header,
+        context
+      });
+    case "cell":
+      return entriesFor(options.cell, {
+        target,
+        defaults: defaultContextMenu.cell,
+        context
+      });
+    case "group":
+      return entriesFor(options.group, {
+        target,
+        defaults: defaultContextMenu.group,
+        context
+      });
+    case "body":
+      return entriesFor(options.body, {
+        target,
+        defaults: defaultContextMenu.body,
+        context
+      });
+    default:
+      return [];
+  }
 }
 
-// src/util/rows.ts
-function resolveShownRows(rows, filter, sort, columns) {
-  return sortRows(filterRows(rows, filter, columns), sort, columns);
+// src/menu/navigation.ts
+function startIndex(count, from, move) {
+  const focused = from >= 0 && from < count;
+  switch (move) {
+    case "first":
+      return 0;
+    case "last":
+      return count - 1;
+    case "next":
+      return focused ? from + 1 : 0;
+    case "previous":
+      return focused ? from - 1 : count - 1;
+  }
+}
+function nextMenuIndex(entries, from, move) {
+  const count = entries.length;
+  const step = move === "next" || move === "first" ? 1 : -1;
+  const start = startIndex(count, from, move);
+  for (let offset = 0; offset < count; offset++) {
+    const index = ((start + step * offset) % count + count) % count;
+    if (entries[index]?.type !== "separator") {
+      return index;
+    }
+  }
+  return -1;
 }
-function resolveRows(rowsById, ids) {
-  return ids.map((id) => rowsById.get(id)).filter((row) => row !== void 0);
+function typeaheadIndex(labels, from, query) {
+  const typed = query.toLowerCase();
+  const firstCodePoint = typed.codePointAt(0);
+  if (firstCodePoint === void 0) {
+    return -1;
+  }
+  const first = String.fromCodePoint(firstCodePoint);
+  const repeated = typed.replaceAll(first, "") === "";
+  const prefix = repeated ? first : typed;
+  const start = repeated ? from + 1 : Math.max(from, 0);
+  for (let offset = 0; offset < labels.length; offset++) {
+    const index = (start + offset) % labels.length;
+    if (labels[index]?.toLowerCase().startsWith(prefix) === true) {
+      return index;
+    }
+  }
+  return -1;
 }
-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);
+
+// src/toolbar/options.ts
+var defaultToolbar = ["search", "spacer", "filter.clearAll", "column.choose"];
+function toolbarEntries(toolbar) {
+  if (toolbar === void 0 || toolbar === false) {
+    return [];
+  }
+  return (toolbar === true ? void 0 : toolbar.items) ?? defaultToolbar;
 }
-function resolveCell(rowsById, columns, cell) {
-  if (cell === null) {
-    return null;
+
+// src/toolbar/resolveToolbar.ts
+function isSpacer(entry) {
+  return entry.type === "spacer";
+}
+function resolveToolbar(entries, options) {
+  const { commands, contextFor } = options;
+  function resolveEntry(entry, index) {
+    if (entry === "search") {
+      return { type: "search", key: "search" };
+    }
+    if (entry === "spacer") {
+      return { type: "spacer", key: `spacer-${String(index)}` };
+    }
+    if (typeof entry === "object" && entry.type === "custom") {
+      return { type: "custom", id: entry.id, key: entry.id };
+    }
+    if (entry === "separator") {
+      return { type: "separator", key: `separator-${String(index)}` };
+    }
+    const resolved = resolveMenuEntry(entry, index, {
+      commands,
+      context: contextFor({
+        area: "toolbar",
+        itemId: typeof entry === "string" ? entry : entry.id
+      })
+    });
+    if (resolved === null || resolved.type === "separator") {
+      return resolved;
+    }
+    if (resolved.type === "submenu") {
+      return { ...resolved, type: "menu", key: resolved.id };
+    }
+    const { checked, ...item } = resolved;
+    return { ...item, type: "button", key: item.id, pressed: checked };
   }
-  const entry = rowsById.get(cell.rowId);
-  const columnIndex = columns.findIndex(
-    (candidate) => candidate.id === cell.columnId
+  return collapseSeparators(
+    entries.map(resolveEntry).filter((entry) => entry !== null),
+    isSpacer
   );
-  const column = columns[columnIndex];
-  if (entry === void 0 || column === void 0) {
-    return null;
+}
+
+// src/toolbar/overflow.ts
+function fitToolbarItems({
+  widths,
+  available,
+  moreWidth,
+  pinned
+}) {
+  const total = widths.reduce((sum, width) => sum + width, 0);
+  if (total <= available) {
+    return widths.length;
+  }
+  let used = moreWidth + widths.reduce((sum, width, index) => sum + (pinned[index] ? width : 0), 0);
+  for (const [index, width] of widths.entries()) {
+    if (!pinned[index]) {
+      used += width;
+      if (used > available) {
+        return index;
+      }
+    }
+  }
+  return widths.length;
+}
+function isPinnedToolbarItem(item) {
+  return item.type === "search" || item.type === "custom";
+}
+function asMenuEntry(item) {
+  switch (item.type) {
+    case "button":
+      return {
+        type: "item",
+        id: item.id,
+        label: item.label,
+        icon: item.icon,
+        shortcut: item.shortcut,
+        disabled: item.disabled,
+        checked: item.pressed,
+        run: item.run
+      };
+    case "menu":
+      return {
+        type: "submenu",
+        id: item.id,
+        label: item.label,
+        icon: item.icon,
+        items: item.items
+      };
+    case "separator":
+      return item;
+    default:
+      return null;
   }
+}
+function splitToolbarItems(items, fit) {
+  const fits = (item, index) => index < fit || isPinnedToolbarItem(item);
   return {
-    rowId: cell.rowId,
-    columnId: cell.columnId,
-    row: entry.row,
-    column,
-    rowIndex: entry.rowIndex,
-    columnIndex,
-    value: accessDotted(entry.row, column.column.field)
+    shown: collapseSeparators(
+      items.filter(fits),
+      (item) => item.type === "spacer"
+    ),
+    overflow: collapseSeparators(
+      items.filter((item, index) => !fits(item, index)).map(asMenuEntry).filter((entry) => entry !== 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;
+// src/toolbar/search.ts
+function searchTextOf(filter) {
+  const query = filterQueryFor(filter) ?? "";
+  const start = query.startsWith("%") ? 1 : 0;
+  const end = query.endsWith("%") ? -1 : void 0;
+  return query.slice(start, end);
+}
+function setSearchText(filter, text) {
+  return setColumnFilter(filter, void 0, text === "" ? "" : `%${text}%`);
+}
+
+// src/util/navigation.ts
+var HEADER_ROW = -1;
+function clampFocus(focus, rowCount, columnCount2) {
+  return {
+    rowIndex: Math.min(Math.max(focus.rowIndex, HEADER_ROW), rowCount - 1),
+    columnIndex: Math.min(
+      Math.max(focus.columnIndex, 0),
+      Math.max(columnCount2 - 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;
   }
-  if (start < rows.length) {
-    units.push({ start, end: rows.length });
-  }
-  return units;
+  return next;
 }
-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 };
+function nextFocusForKey(key, modifiers, focus, rowCount, columnCount2, pageSize, isSkippableRow = noRowsSkippable) {
+  if (modifiers.altKey) {
+    return null;
   }
-  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 { 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: columnCount2 - 1
+      } : { rowIndex, columnIndex: columnCount2 - 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 +2929,522 @@ function paginationWindow(currentPage, pageCount, options) {
   return entries;
 }
 
-// src/util/aggregation.ts
-function isEmpty2(value) {
-  return value === null || value === void 0;
+// src/util/columnChooser.ts
+function isHideable(column) {
+  return column.column.hideable !== false;
 }
-function toNumber(value) {
-  return Number(value);
+function matchesSearch(label, search) {
+  return label.toLowerCase().includes(search.toLowerCase());
 }
-function distinctKey(value) {
-  if (isEmpty2(value)) {
-    return "\0empty";
-  }
-  if (value instanceof Date) {
-    return `\0date:${String(value.getTime())}`;
+function selectAllStateOf(states) {
+  if (states.length > 0 && states.every(Boolean)) {
+    return "checked";
   }
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "symbol":
-      return `\0${typeof value}:${String(value)}`;
-    case "function":
-      return "\0function";
+  return states.some(Boolean) ? "mixed" : "unchecked";
+}
+function resolveColumnChooser({
+  columns,
+  visibility,
+  search = ""
+}) {
+  const all = columns.map((column) => ({
+    column,
+    label: resolveColumnHeaderText(column.column),
+    visible: isColumnVisible(column.column, visibility)
+  }));
+  const shownCount = all.filter(({ visible }) => visible).length;
+  const matched = all.filter(({ label }) => matchesSearch(label, search));
+  const entries = matched.map(
+    ({ column, label, visible }) => ({
+      columnId: column.id,
+      label,
+      visible,
+      disabled: visible && (!isHideable(column) || shownCount === 1)
+    })
+  );
+  const covered = matched.filter(({ column }) => isHideable(column));
+  const selectAll2 = selectAllStateOf(covered.map(({ visible }) => visible));
+  return {
+    entries,
+    selectAll: selectAll2,
+    toggleAll: toggleAllOf(covered, selectAll2, shownCount)
+  };
+}
+function toggleAllOf(covered, selectAll2, shownCount) {
+  const show = selectAll2 !== "checked";
+  const changing = covered.filter(({ visible }) => visible !== show).map(({ column }) => column.id);
+  const columnIds = !show && changing.length === shownCount ? changing.slice(1) : changing;
+  return columnIds.length === 0 ? null : { visible: show, columnIds };
+}
+
+// src/messages.ts
+function columnCount(count, change) {
+  return count === 1 ? `1 column ${change}` : `${String(count)} columns ${change}`;
+}
+function searchResults(count) {
+  if (count === 0) {
+    return "No rows found";
+  }
+  return count === 1 ? "1 row found" : `${String(count)} rows found`;
+}
+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: (columnName2, level, levelCount) => levelCount > 1 ? `${columnName2}, level ${String(level)} of ${String(levelCount)}` : columnName2,
+  removeGroupBy: (columnName2) => `Stop grouping by ${columnName2}`,
+  columnResized: (columnName2, width) => `${columnName2}, ${String(width)} pixels wide`,
+  columnMoved: (columnName2, position, columnCount2) => `${columnName2}, column ${String(position)} of ${String(columnCount2)}`,
+  columnSorted: (columnName2, direction, key, keyCount) => {
+    const sorted = `${columnName2} sorted ${direction === "asc" ? "ascending" : "descending"}`;
+    return keyCount > 1 ? `${sorted}, key ${String(key)} of ${String(keyCount)}` : sorted;
+  },
+  sortCleared: (columnName2) => `${columnName2}, sort cleared`,
+  groupedBy: (columnName2, level, levelCount) => levelCount > 1 ? `Grouped by ${columnName2}, level ${String(level)} of ${String(levelCount)}` : `Grouped by ${columnName2}`,
+  groupingRemoved: (columnName2) => `${columnName2}, grouping removed`,
+  groupExpanded: "Group expanded",
+  groupCollapsed: "Group collapsed",
+  allGroupsExpanded: "All groups expanded",
+  allGroupsCollapsed: "All groups collapsed",
+  selectedCount,
+  cellSelected: (columnName2, rowNumber) => `${columnName2}, row ${String(rowNumber)}, selected`,
+  columnHidden: (columnName2) => `${columnName2}, column hidden`,
+  columnShown: (columnName2) => `${columnName2}, column shown`,
+  columnsHidden: (count) => columnCount(count, "hidden"),
+  columnsShown: (count) => columnCount(count, "shown"),
+  columnsAutoFitted: (count) => columnCount(count, "autofitted"),
+  headerMenuLabel: (columnName2) => `${columnName2} column menu`,
+  cellMenuLabel: "Row menu",
+  groupMenuLabel: "Group menu",
+  bodyMenuLabel: "Grid menu",
+  sortAscending: "Sort ascending",
+  sortDescending: "Sort descending",
+  clearSort: "Clear sort",
+  clearAllSorting: "Clear all sorting",
+  groupByColumn: (columnName2) => `Group by ${columnName2}`,
+  ungroupAll: "Ungroup all",
+  expandAllGroups: "Expand all groups",
+  collapseAllGroups: "Collapse all groups",
+  hideColumn: "Hide column",
+  autoFitColumn: "Autofit column",
+  autoFitAllColumns: "Autofit all columns",
+  selectAllRows: "Select all rows",
+  clearSelection: "Clear selection",
+  clearFilters: "Clear filters",
+  chooseColumns: "Choose columns",
+  toolbarLabel: "Grid toolbar",
+  searchLabel: "Search",
+  searchPlaceholder: "Search\u2026",
+  moreToolbarItems: "More",
+  searchResults,
+  columnChooserLabel: "Columns",
+  columnChooserSearchLabel: "Search columns",
+  showAllColumns: "Show all",
+  noMatchingColumns: "No matching columns"
+};
+function resolveMessages(messages) {
+  return messages === void 0 ? defaultMessages : { ...defaultMessages, ...messages };
+}
+
+// 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 `\0object:${JSON.stringify(value)}`;
+      return format ?? {};
   }
 }
-function reduceBuiltIn(rows, fn, column) {
-  if (fn === "count") {
-    return rows.length;
+function dateOptions(type, format) {
+  if (format !== void 0) {
+    return format;
   }
-  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;
+  if (type === "date") return DATE_FIELDS;
+  if (type === "time") return TIME_FIELDS;
+  return DATE_TIME_FIELDS;
+}
+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 keyOf(spec) {
-  return spec.id ?? spec.columnId;
+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 formatted ? formatDate(value, type, format, locale) : value.toLocaleString();
+  }
+  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 computeAggregates(rows, specs, columns) {
-  const results = /* @__PURE__ */ new Map();
-  if (specs.length === 0) {
-    return results;
+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 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);
+  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 results;
+  return formatCellValue(value, target, locale);
 }
-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);
+
+// src/util/filterEditor.ts
+function touchesColumn(entry, columnId) {
+  return "combinator" in entry ? entry.entries.some((nested) => touchesColumn(nested, columnId)) : entry.columnId === columnId;
 }
-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 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 };
+  }
+  if (!("combinator" in entry) || entry.combinator !== "or" || entry.entries.length !== 2) {
+    return void 0;
+  }
+  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 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 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 matchesSearch2(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 = filterValueKey(value, column.type);
+      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 messages = resolveMessages(query.messages);
+  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, messages),
+    count
+  })).filter((option) => matchesSearch2(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,
+    columnType: column.type
+  };
+}
+function keyOf2(draft, value) {
+  return filterValueKey(value, draft.columnType);
+}
+function everyOption(draft) {
+  return new Map(
+    draft.options.map((option) => [keyOf2(draft, option.value), option.value])
+  );
+}
+function initialFilterEditorDraft(shape, values) {
+  const draft = {
+    mode: "values",
+    options: values.options,
+    blanks: values.blanks,
+    search: "",
+    checked: everyOption(values),
+    includeBlanks: values.blanks > 0,
+    conditions: [],
+    combinator: "and",
+    columnType: values.columnType
+  };
+  switch (shape.kind) {
+    case "values":
+      return {
+        ...draft,
+        checked: new Map(
+          shape.values.filter((value) => !isEmptyCell(value)).map((value) => [keyOf2(draft, 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) => matchesSearch2(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(keyOf2(draft, 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 = keyOf2(draft, 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 = keyOf2(draft, 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),
+        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(keyOf2(draft, 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/util/virtualization.ts
@@ -1190,26 +3495,46 @@ export {
   alignmentForType,
   applyColumnOrder,
   applyColumnResize,
+  applyColumnVisibility,
   applySelectionIntent,
   beginColumnResize,
   buildKeyShortcuts,
+  builtInCommands,
   clampColumnWidth,
   clampFocus,
   clearAllFilters,
   clearSelection,
   collapseAllGroups,
+  columnValueOptions,
   compareValues,
   computeAggregates,
+  contextMenuEntries,
+  createCommandContext,
+  createGridController,
+  createGridViewResolver,
+  defaultContextMenu,
+  defaultMessages,
+  defaultToolbar,
   defineColumnsFromRows,
+  describeColumnFilter,
   diffSelection,
+  draftToFilter,
   expandAllGroups,
+  filterEditorReducer,
   filterQueryFor,
   filterRows,
   fitColumnsToWidth,
+  fitToolbarItems,
+  formatAggregateValue,
+  formatCellValue,
   getColumnId,
   groupRowId,
   groupRows,
+  hasContextMenu,
+  initialFilterEditorDraft,
   intentOf,
+  isColumnVisible,
+  isPinnedToolbarItem,
   isSameCell,
   matchesQuery,
   moveColumnBefore,
@@ -1217,33 +3542,52 @@ export {
   movesColumn,
   movesGroupBy,
   nextFocusForKey,
+  nextMenuIndex,
   paginateRows,
   paginationWindow,
   resolveCell,
+  resolveColumnChooser,
   resolveColumnConstraints,
+  resolveColumnHeaderText,
   resolveColumnLabel,
   resolveColumnWidths,
   resolveColumns,
+  resolveCommands,
+  resolveDataColumns,
   resolveDropBefore,
+  resolveGridView,
   resolveKeyboardDropTarget,
+  resolveMenu,
+  resolveMessages,
   resolveRowId,
   resolveRows,
   resolveShownRows,
+  resolveToolbar,
   revertColumnSize,
+  runCommand,
+  searchTextOf,
   selectAll,
+  selectAllState,
   selectCell,
   selectOnly,
   selectRange,
+  serializeGridState,
   setColumnFilter,
+  setColumnVisibility,
+  setSearchText,
   sizeColumnToContent,
   sortDirectionFor,
   sortPriorityFor,
   sortRows,
+  splitToolbarItems,
   toggleCellSelection,
   toggleColumnSort,
   toggleGroupExpansion,
   toggleSelection,
+  toolbarEntries,
   totalColumnWidth,
+  typeaheadIndex,
+  visibleFilterOptions,
   visibleRange,
   withGroupAggregates
 };