@gridkitjs/core 0.0.0-dev-20261106222533

package/dist/index.js

@@ -0,0 +1,4757 @@
+// src/util/grid.ts
+function isNested(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function getType(value) {
+  if (value instanceof Date) return "dateTime";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "bigint") return "number";
+  if (typeof value === "symbol") return "string";
+  return "string";
+}
+function alignmentForType(type) {
+  switch (type) {
+    case "number":
+    case "decimal":
+    case "currency":
+    case "percent":
+      return "right";
+    default:
+      return "left";
+  }
+}
+function getAlignment(value) {
+  return alignmentForType(getType(value));
+}
+function defineColumnsFromRows(rows) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(field, value) {
+    if (seen.has(field)) {
+      return;
+    }
+    seen.add(field);
+    columns.push({
+      field,
+      type: getType(value),
+      alignment: getAlignment(value)
+    });
+  }
+  for (const row of rows) {
+    if (!isNested(row)) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(row)) {
+      if (!isNested(value)) {
+        add(key, value);
+        continue;
+      }
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        if (!isNested(nestedValue)) {
+          add(`${key}.${nestedKey}`, nestedValue);
+        }
+      }
+    }
+  }
+  return columns;
+}
+function getColumnId(column) {
+  return column.id ?? column.field;
+}
+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.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" : "",
+    // Alt+Enter is the keyboard equivalent of double-clicking the resize
+    // handle to size the column to its content — same gate as the nudge
+    // shortcuts, since both are resize actions.
+    capabilities.resizable ? "Alt+ArrowLeft Alt+ArrowRight Alt+Enter" : "",
+    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" : "",
+    // Excel's own key for its filter dropdown is Alt+ArrowDown, which
+    // grouping already holds here; Shift sets the filter apart from it.
+    capabilities.filterable === true ? "Alt+Shift+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/position.ts
+function renumberRows(entries) {
+  return entries.map(
+    (entry, index) => entry.rowIndex === index && entry.datasetIndex === index ? entry : { ...entry, rowIndex: index, datasetIndex: index }
+  );
+}
+
+// src/util/sorting.ts
+function isEmpty(value) {
+  return value === null || value === void 0;
+}
+function toTime(value) {
+  return value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
+}
+function compareValues(a, b, type) {
+  if (isEmpty(a)) {
+    return isEmpty(b) ? 0 : 1;
+  }
+  if (isEmpty(b)) {
+    return -1;
+  }
+  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));
+  }
+}
+function sortDirectionFor(sort, columnId) {
+  return sort.find((entry) => entry.columnId === columnId)?.direction ?? null;
+}
+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 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 (index === -1) {
+    return [...sort, { columnId, direction: next }];
+  }
+  return sort.map(
+    (entry, i) => i === index ? { columnId, direction: next } : entry
+  );
+}
+function sortRows(rows, sort, columns) {
+  if (sort.length === 0) {
+    return rows;
+  }
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const active = sort.filter((entry) => byId.has(entry.columnId));
+  if (active.length === 0) {
+    return rows;
+  }
+  const sorted = [...rows].sort((a, b) => {
+    for (const { columnId, direction } of active) {
+      const column = byId.get(columnId);
+      if (column === void 0) {
+        continue;
+      }
+      const left = accessDotted(a.row, column.field);
+      const right = accessDotted(b.row, column.field);
+      const leftEmpty = isEmpty(left);
+      const rightEmpty = isEmpty(right);
+      if (leftEmpty || rightEmpty) {
+        if (leftEmpty && rightEmpty) {
+          continue;
+        }
+        return leftEmpty ? 1 : -1;
+      }
+      const result = compareValues(left, right, column.type);
+      if (result !== 0) {
+        return direction === "asc" ? result : -result;
+      }
+    }
+    return 0;
+  });
+  return renumberRows(sorted);
+}
+
+// src/util/grouping.ts
+function groupRowId(path) {
+  return JSON.stringify(path);
+}
+function bucketKey(value) {
+  if (value === null || value === void 0) {
+    return "\0empty";
+  }
+  if (value instanceof Date) {
+    return `\0date:${String(value.getTime())}`;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return `\0${typeof value}:${String(value)}`;
+    case "function":
+      return "\0function";
+    default:
+      return `\0object:${JSON.stringify(value)}`;
+  }
+}
+function 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 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,
+      // Both set by `groupRows` once it has the whole flattened array.
+      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 renumberRows(out);
+}
+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 renumberRows(out);
+}
+
+// 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
+    );
+  }
+  if ("operator" in entry) {
+    const column = byId.get(entry.columnId);
+    if (column === void 0) {
+      return () => false;
+    }
+    const test2 = compileOperatorEntry(entry, column.type);
+    return (row) => test2(accessDotted(row, column.field));
+  }
+  if ("value" in entry) {
+    const { columnId: columnId2, value } = entry;
+    if (columnId2 !== void 0) {
+      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 compileFilter(filter, columns) {
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const compiled = filter.filter((entry) => isEntryUsable(entry, byId)).map((entry) => compileFilterEntry(entry, byId, columns));
+  return compiled.length === 0 ? void 0 : (row) => compiled.every((test) => test(row));
+}
+function matchesQuery(value, query) {
+  return compileFilterQuery(query)(value);
+}
+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);
+  }
+  const next = columnId === void 0 ? { query } : { columnId, query };
+  if (index === -1) {
+    return [...filter, next];
+  }
+  const existing = filter[index];
+  if (existing !== void 0 && "query" in existing && existing.query === query) {
+    return filter;
+  }
+  return filter.map((entry, i) => i === index ? next : entry);
+}
+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 renumberRows(filtered);
+}
+
+// src/util/rows.ts
+function resolveShownRows(rows, filter, sort, columns) {
+  return sortRows(filterRows(rows, filter, columns), sort, columns);
+}
+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 {
+    rowId: cell.rowId,
+    columnId: cell.columnId,
+    row: entry.row,
+    column,
+    rowIndex: entry.rowIndex,
+    columnIndex,
+    value: accessDotted(entry.row, column.column.field)
+  };
+}
+
+// src/util/visibility.ts
+function isColumnVisible(column, visibility) {
+  return visibility[getColumnId(column)] ?? column.hidden !== true;
+}
+function applyColumnVisibility(columns, visibility) {
+  const visible = columns.filter(
+    (entry) => isColumnVisible(entry.column, visibility)
+  );
+  return visible.length === columns.length ? columns : visible;
+}
+function setColumnVisibility(columns, visibility, columnIds, visible) {
+  const requested = new Set(columnIds);
+  const changed = columns.filter(
+    (entry) => requested.has(entry.id) && isColumnVisible(entry.column, visibility) !== visible
+  );
+  if (changed.length === 0) {
+    return visibility;
+  }
+  return {
+    ...visibility,
+    ...Object.fromEntries(changed.map((entry) => [entry.id, visible]))
+  };
+}
+
+// src/util/view.ts
+var NO_AGGREGATES = [];
+function identifyRows(rows, getRowId) {
+  return rows.map((row, rowIndex) => ({
+    rowId: resolveRowId(row, rowIndex, getRowId),
+    row,
+    rowIndex,
+    datasetIndex: rowIndex
+  }));
+}
+function sizeColumns(visibleColumns, sizing, sizes, resizable, reorderable, groupByDraggable, resizeMode, viewportWidth) {
+  const widths = resolveColumnWidths(
+    visibleColumns.map((entry) => entry.column),
+    sizing,
+    { sizes, resizable, reorderable, groupByDraggable }
+  );
+  return resizeMode === "fit" && viewportWidth !== null ? fitColumnsToWidth(widths, viewportWidth, sizes) : widths;
+}
+function totalAggregates(rows, aggregates, dataColumns) {
+  return computeAggregates(
+    rows.map((entry) => entry.row),
+    aggregates,
+    dataColumns
+  );
+}
+function paginate(displayRows, paginated, pagination) {
+  return paginated ? paginateRows(displayRows, pagination) : { rows: displayRows, pageCount: 1, pageIndex: 0 };
+}
+function narrowToDataRows(pageRows, rows, reshaped) {
+  return reshaped ? pageRows.filter((entry) => !("kind" in entry)) : rows;
+}
+function createGridViewResolver() {
+  const identify = memoizeLast(identifyRows);
+  const orderColumns = memoizeLast(resolveDataColumns);
+  const showColumns = memoizeLast(applyColumnVisibility);
+  const size = memoizeLast(sizeColumns);
+  const filterAndSort = memoizeLast(resolveShownRows);
+  const group = memoizeLast(groupRows);
+  const aggregate = memoizeLast(withGroupAggregates);
+  const total = memoizeLast(totalAggregates);
+  const page = memoizeLast(paginate);
+  const narrow = memoizeLast(narrowToDataRows);
+  const assemble = memoizeLast(
+    (dataColumns, columns, rows, displayRows, pageRows, displayDataRows, pageCount, pageIndex, grandTotal) => ({
+      dataColumns,
+      columns,
+      rows,
+      displayRows,
+      pageRows,
+      displayDataRows,
+      pageCount,
+      pageIndex,
+      grandTotal
+    })
+  );
+  return ({ rows: data, getRowId, columns: definitions, state, options }) => {
+    const paginated = options.paginated ?? false;
+    const aggregates = options.aggregates ?? NO_AGGREGATES;
+    const dataColumns = orderColumns(definitions, state.columnOrder);
+    const columns = size(
+      showColumns(dataColumns, state.columnVisibility),
+      state.columnSizing,
+      options.columnSizeDefaults,
+      options.resizableColumns,
+      options.reorderableColumns,
+      options.groupByDraggableColumns,
+      options.resizeMode ?? "fit",
+      options.viewportWidth ?? null
+    );
+    const rows = filterAndSort(
+      identify(data, getRowId),
+      state.filter,
+      state.columnSort,
+      dataColumns
+    );
+    const displayRows = aggregate(
+      group(rows, state.groupBy, state.groupExpansion, dataColumns),
+      rows,
+      state.groupBy,
+      aggregates,
+      dataColumns,
+      options.groupAggregateDisplay ?? "inline"
+    );
+    const {
+      rows: pageRows,
+      pageCount,
+      pageIndex
+    } = page(displayRows, paginated, state.pagination);
+    return assemble(
+      dataColumns,
+      columns,
+      rows,
+      displayRows,
+      pageRows,
+      narrow(pageRows, rows, state.groupBy.length > 0 || paginated),
+      pageCount,
+      pageIndex,
+      total(rows, aggregates, dataColumns)
+    );
+  };
+}
+function resolveGridView(input) {
+  return createGridViewResolver()(input);
+}
+
+// src/controller/changes.ts
+function changedEntryColumnId(previous, next) {
+  const length = Math.max(previous.length, next.length);
+  for (let index = 0; index < length; index++) {
+    const before = previous[index];
+    const after = next[index];
+    if (before?.columnId !== after?.columnId || before?.direction !== after?.direction) {
+      return (after ?? before)?.columnId;
+    }
+  }
+  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 selectOnly(selection, id, mode) {
+  if (mode === false) {
+    return selection;
+  }
+  return selection.length === 1 && selection[0] === id ? selection : [id];
+}
+function selectRange(selection, orderedIds, anchorId, focusId, mode) {
+  if (mode !== "multiple") {
+    return selectOnly(selection, focusId, mode);
+  }
+  const anchor = orderedIds.indexOf(anchorId);
+  const focus = orderedIds.indexOf(focusId);
+  if (anchor === -1 || focus === -1) {
+    return selection;
+  }
+  const next = orderedIds.slice(
+    Math.min(anchor, focus),
+    Math.max(anchor, focus) + 1
+  );
+  return sameSelection(selection, next) ? selection : next;
+}
+function selectAll(selection, orderedIds, mode) {
+  if (mode !== "multiple") {
+    return selection;
+  }
+  return sameSelection(selection, orderedIds) ? selection : orderedIds;
+}
+function clearSelection(selection) {
+  return selection.length === 0 ? selection : [];
+}
+function diffSelection(previous, next) {
+  if (previous === next) {
+    return NO_CHANGE;
+  }
+  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 isSameCell(a, b) {
+  if (a === null || b === null) {
+    return a === b;
+  }
+  return a.rowId === b.rowId && a.columnId === b.columnId;
+}
+function selectCell(selection, cell, mode) {
+  if (mode === false || isSameCell(selection, cell)) {
+    return selection;
+  }
+  return cell;
+}
+function toggleCellSelection(selection, cell, mode) {
+  if (mode === false) {
+    return selection;
+  }
+  return isSameCell(selection, cell) ? null : cell;
+}
+function intentOf(event, options) {
+  if (event.shiftKey) {
+    return "range";
+  }
+  if (event.ctrlKey || event.metaKey) {
+    return "toggle";
+  }
+  return options?.toggleOnClick === true ? "toggle" : "replace";
+}
+function applySelectionIntent(selection, orderedIds, anchorId, id, intent, mode) {
+  switch (intent) {
+    case "toggle":
+      return toggleSelection(selection, id, mode);
+    // A range with no anchor yet spans from the id to itself, which is the
+    // plain click a first Shift-click may as well be.
+    case "range":
+      return selectRange(selection, orderedIds, anchorId ?? id, id, mode);
+    default:
+      return selectOnly(selection, id, mode);
+  }
+}
+
+// src/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 reportColumnSelection(previous, next, columns, callbacks) {
+  const diff = diffSelection(previous, next);
+  const added = resolveColumns(columns, diff.added);
+  const removed = resolveColumns(columns, diff.removed);
+  for (const column of added) {
+    callbacks.onColumnSelect?.({ column, selection: next });
+  }
+  if (added.length > 0) {
+    callbacks.onColumnsSelect?.({ columns: added, selection: next });
+  }
+  for (const column of removed) {
+    callbacks.onColumnDeselect?.({ column, selection: next });
+  }
+  if (removed.length > 0) {
+    callbacks.onColumnsDeselect?.({ columns: removed, selection: next });
+  }
+  callbacks.onColumnSelectionChange?.({
+    added,
+    removed,
+    selected: resolveColumns(columns, next),
+    selection: next
+  });
+  return diff;
+}
+function reportCellSelection(previous, next, rowsById, columns, callbacks) {
+  const selected = resolveCell(rowsById, columns, next);
+  const deselected = resolveCell(rowsById, columns, previous);
+  if (deselected !== null) {
+    callbacks.onCellDeselect?.({ cell: deselected, selection: next });
+  }
+  if (selected !== null) {
+    callbacks.onCellSelect?.({ cell: selected, selection: next });
+  }
+  callbacks.onCellSelectionChange?.({
+    selected,
+    deselected,
+    selection: next
+  });
+}
+
+// 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
+    };
+  }
+  function rowIds() {
+    return grid.getView().displayDataRows.map((entry) => entry.rowId);
+  }
+  function columnIds() {
+    return grid.getView().columns.map((entry) => entry.id);
+  }
+  function commitRows(next) {
+    const previous = grid.getState().rowSelection;
+    grid.commit("rowSelection", next, () => {
+      const options = grid.getOptions();
+      const diff = reportRowSelection(
+        previous,
+        next,
+        rowsById(grid.getView().displayDataRows),
+        options
+      );
+      options.onSelectionDiff?.({ target: "rows", ...diff, selection: next });
+    });
+  }
+  function commitColumns(next) {
+    const previous = grid.getState().columnSelection;
+    grid.commit("columnSelection", next, () => {
+      const options = grid.getOptions();
+      const diff = reportColumnSelection(
+        previous,
+        next,
+        grid.getView().columns,
+        options
+      );
+      options.onSelectionDiff?.({
+        target: "columns",
+        ...diff,
+        selection: next
+      });
+    });
+  }
+  function commitCell(next) {
+    const previous = grid.getState().cellSelection;
+    grid.commit("cellSelection", next, () => {
+      const view = grid.getView();
+      reportCellSelection(
+        previous,
+        next,
+        rowsById(view.displayDataRows),
+        view.columns,
+        grid.getOptions()
+      );
+    });
+  }
+  return {
+    setRowSelection(selection) {
+      if (!sameItems(grid.getState().rowSelection, selection)) {
+        commitRows(selection);
+      }
+    },
+    selectRows(ids, intent = "replace") {
+      const mode = modes().rows;
+      const current = grid.getState().rowSelection;
+      if (mode === false || ids.length === 0) {
+        return;
+      }
+      const next = intent === "toggle" ? ids.reduce(
+        (selection, id) => toggleSelection(selection, id, mode),
+        current
+      ) : mode === "single" ? ids.slice(-1) : distinct(ids);
+      rowAnchor = ids.at(-1) ?? null;
+      if (!sameItems(current, next)) {
+        commitRows(next);
+      }
+    },
+    selectRow(rowId, intent) {
+      const next = applySelectionIntent(
+        grid.getState().rowSelection,
+        rowIds(),
+        rowAnchor,
+        rowId,
+        intent,
+        modes().rows
+      );
+      if (intent !== "range") {
+        rowAnchor = rowId;
+      }
+      commitRows(next);
+    },
+    selectAllRows() {
+      commitRows(
+        selectAll(grid.getState().rowSelection, rowIds(), modes().rows)
+      );
+    },
+    clearSelection() {
+      commitRows(clearSelection(grid.getState().rowSelection));
+      commitColumns(clearSelection(grid.getState().columnSelection));
+      commitCell(null);
+    },
+    setColumnSelection(selection) {
+      if (!sameItems(grid.getState().columnSelection, selection)) {
+        commitColumns(selection);
+      }
+    },
+    selectColumn(columnId, intent) {
+      const next = applySelectionIntent(
+        grid.getState().columnSelection,
+        columnIds(),
+        columnAnchor,
+        columnId,
+        intent,
+        modes().columns
+      );
+      if (intent !== "range") {
+        columnAnchor = columnId;
+      }
+      commitColumns(next);
+    },
+    setCellSelection(selection) {
+      if (!isSameCell(grid.getState().cellSelection, selection)) {
+        commitCell(selection);
+      }
+    },
+    selectCell(cell, intent) {
+      const current = grid.getState().cellSelection;
+      const mode = modes().cells;
+      commitCell(
+        intent === "toggle" ? toggleCellSelection(current, cell, mode) : selectCell(current, cell, mode)
+      );
+    }
+  };
+}
+
+// src/controller/createGridController.ts
+var DEFAULT_PAGE_SIZE = 25;
+var NO_ROWS = [];
+var NO_COLUMNS = [];
+var SLICE_KEYS = [
+  "columnSizing",
+  "columnOrder",
+  "columnVisibility",
+  "columnSort",
+  "filter",
+  "groupBy",
+  "groupExpansion",
+  "pagination",
+  "rowSelection",
+  "columnSelection",
+  "cellSelection"
+];
+var DEFAULT_OPTION = {
+  columnSizing: "defaultColumnSizing",
+  columnOrder: "defaultColumnOrder",
+  columnVisibility: "defaultColumnVisibility",
+  columnSort: "defaultColumnSort",
+  filter: "defaultFilter",
+  groupBy: "defaultGroupBy",
+  groupExpansion: "defaultGroupExpansion",
+  pagination: "defaultPagination",
+  rowSelection: "defaultRowSelection",
+  columnSelection: "defaultColumnSelection",
+  cellSelection: "defaultCellSelection"
+};
+function startingState(options) {
+  return {
+    columnSizing: options.defaultColumnSizing ?? {},
+    columnOrder: options.defaultColumnOrder ?? [],
+    columnVisibility: options.defaultColumnVisibility ?? {},
+    columnSort: options.defaultColumnSort ?? [],
+    filter: options.defaultFilter ?? [],
+    groupBy: options.defaultGroupBy ?? [],
+    groupExpansion: options.defaultGroupExpansion ?? [],
+    pagination: options.defaultPagination ?? {
+      pageIndex: 0,
+      pageSize: DEFAULT_PAGE_SIZE
+    },
+    rowSelection: options.defaultRowSelection ?? [],
+    columnSelection: options.defaultColumnSelection ?? [],
+    cellSelection: options.defaultCellSelection ?? null
+  };
+}
+function definedColumns(columns, rows) {
+  if (columns !== void 0 && columns.length > 0) {
+    return columns;
+  }
+  if (rows !== void 0 && rows.length > 0) {
+    return defineColumnsFromRows(rows);
+  }
+  return NO_COLUMNS;
+}
+function pagingInputsOf(state) {
+  return {
+    filter: state.filter,
+    columnSort: state.columnSort,
+    groupBy: state.groupBy
+  };
+}
+function createGridController(initial) {
+  let options = initial;
+  const own = startingState(initial);
+  const resolveView = createGridViewResolver();
+  const resolveColumns2 = memoizeLast(definedColumns);
+  const listeners = /* @__PURE__ */ new Set();
+  const reportedConflicts = /* @__PURE__ */ new Set();
+  let heldReports;
+  let state = resolveSlices();
+  let pagingInputs = pagingInputsOf(state);
+  reportConflicts();
+  function controlledValue(key) {
+    const controlled = options;
+    return controlled[key];
+  }
+  function isControlled(key) {
+    return controlledValue(key) !== void 0;
+  }
+  function resolveSlice(key) {
+    const controlled = controlledValue(key);
+    return controlled === void 0 ? own[key] : controlled;
+  }
+  function resolveSlices() {
+    return {
+      columnSizing: resolveSlice("columnSizing"),
+      columnOrder: resolveSlice("columnOrder"),
+      columnVisibility: resolveSlice("columnVisibility"),
+      columnSort: resolveSlice("columnSort"),
+      filter: resolveSlice("filter"),
+      groupBy: resolveSlice("groupBy"),
+      groupExpansion: resolveSlice("groupExpansion"),
+      pagination: resolveSlice("pagination"),
+      rowSelection: resolveSlice("rowSelection"),
+      columnSelection: resolveSlice("columnSelection"),
+      cellSelection: resolveSlice("cellSelection")
+    };
+  }
+  function reportConflicts() {
+    for (const key of SLICE_KEYS) {
+      const defaultKey = DEFAULT_OPTION[key];
+      if (reportedConflicts.has(key) || !isControlled(key) || options[defaultKey] === void 0) {
+        continue;
+      }
+      reportedConflicts.add(key);
+      reportError(
+        `\`${key}\` and \`${defaultKey}\` are both set \u2014 \`${key}\` is controlled, so \`${defaultKey}\` is ignored.`
+      );
+    }
+  }
+  function refresh() {
+    let next = resolveSlices();
+    if (next.filter !== pagingInputs.filter || next.columnSort !== pagingInputs.columnSort || next.groupBy !== pagingInputs.groupBy) {
+      pagingInputs = pagingInputsOf(next);
+      if (!isControlled("pagination") && own.pagination.pageIndex !== 0) {
+        own.pagination = { ...own.pagination, pageIndex: 0 };
+        next = { ...next, pagination: own.pagination };
+      }
+    }
+    state = SLICE_KEYS.every((key) => next[key] === state[key]) ? state : next;
+  }
+  function notify() {
+    for (const listener of [...listeners]) {
+      listener();
+    }
+  }
+  function commit(key, next, report) {
+    if (next === state[key]) {
+      return;
+    }
+    if (!isControlled(key)) {
+      own[key] = next;
+    }
+    if (heldReports !== void 0) {
+      heldReports.push(report);
+      return;
+    }
+    refresh();
+    report();
+    notify();
+  }
+  function getView() {
+    return resolveView({
+      rows: options.dataSource ?? NO_ROWS,
+      getRowId: options.getRowId,
+      columns: resolveColumns2(options.columns, options.dataSource),
+      state,
+      options: {
+        paginated: options.paginated,
+        aggregates: options.aggregates,
+        groupAggregateDisplay: options.groupAggregateDisplay,
+        columnSizeDefaults: options.columnSizeDefaults,
+        resizableColumns: options.resizableColumns,
+        reorderableColumns: options.reorderableColumns,
+        groupByDraggableColumns: options.groupByDraggableColumns,
+        resizeMode: options.resizeMode,
+        viewportWidth: options.viewportWidth
+      }
+    });
+  }
+  function commitColumnSizing(next, columnId, width, phase) {
+    commit("columnSizing", next, () => {
+      options.onColumnResize?.({ columnId, width, sizing: next, phase });
+    });
+  }
+  function definedWidth(columnId) {
+    const entry = getView().dataColumns.find(
+      (candidate) => candidate.id === columnId
+    );
+    const [resolved] = entry === void 0 ? [] : resolveColumnWidths(
+      [entry.column],
+      {},
+      {
+        sizes: options.columnSizeDefaults
+      }
+    );
+    return resolved?.width ?? 0;
+  }
+  function commitColumnVisibility(next) {
+    const previous = state.columnVisibility;
+    commit("columnVisibility", next, () => {
+      const changed = new Set(changedKeys(previous, next));
+      const shown = getView().dataColumns.map((entry) => entry.id).filter((id) => changed.delete(id));
+      options.onColumnVisibilityChange?.({
+        columnIds: [...shown, ...changed],
+        visibility: next
+      });
+    });
+  }
+  function changeColumnVisibility(columnIds, visible) {
+    commitColumnVisibility(
+      setColumnVisibility(
+        getView().dataColumns,
+        state.columnVisibility,
+        columnIds,
+        visible
+      )
+    );
+  }
+  function commitGroupBy(next, columnId) {
+    commit("groupBy", next, () => {
+      options.onGroupByChange?.({ columnId, groupBy: next });
+    });
+  }
+  function commitGroupExpansion(next, groupId) {
+    commit("groupExpansion", next, () => {
+      options.onGroupExpansionChange?.({ groupId, expansion: next });
+    });
+  }
+  function commitPagination(next) {
+    if (samePagination(state.pagination, next)) {
+      return;
+    }
+    commit("pagination", next, () => {
+      options.onPaginationChange?.({
+        pagination: next,
+        pageCount: paginateRows(getView().displayRows, next).pageCount
+      });
+    });
+  }
+  function goToPage(pageIndex) {
+    const current = state.pagination;
+    const clamped = paginateRows(getView().displayRows, {
+      ...current,
+      pageIndex
+    }).pageIndex;
+    commitPagination({ ...current, pageIndex: clamped });
+  }
+  function shownPageIndex() {
+    return paginateRows(getView().displayRows, state.pagination).pageIndex;
+  }
+  const selection = createSelectionActions({
+    getState: () => state,
+    getOptions: () => options,
+    getView,
+    commit
+  });
+  const controller = {
+    ...selection,
+    getOptions: () => options,
+    setOptions(next) {
+      options = next;
+      reportConflicts();
+      refresh();
+    },
+    getState: () => state,
+    getView,
+    restoreState(saved) {
+      const reports = [];
+      heldReports = reports;
+      try {
+        restoreSlices(saved);
+      } finally {
+        heldReports = void 0;
+      }
+      if (saved.pagination !== void 0) {
+        pagingInputs = pagingInputsOf(resolveSlices());
+      }
+      refresh();
+      for (const report of reports) {
+        report();
+      }
+      if (reports.length > 0) {
+        notify();
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setColumnSizing(sizing) {
+      const [columnId] = changedKeys(state.columnSizing, sizing);
+      if (columnId !== void 0) {
+        commitColumnSizing(
+          sizing,
+          columnId,
+          sizing[columnId] ?? definedWidth(columnId),
+          "end"
+        );
+      }
+    },
+    resizeColumn(columnId, width, phase) {
+      commitColumnSizing(
+        { ...state.columnSizing, [columnId]: width },
+        columnId,
+        width,
+        phase
+      );
+    },
+    cancelColumnResize(columnId, startSizing, startWidth) {
+      commitColumnSizing(
+        revertColumnSize(state.columnSizing, startSizing, columnId),
+        columnId,
+        startWidth,
+        "end"
+      );
+    },
+    setColumnOrder(order) {
+      const columnId = changedId(state.columnOrder, order);
+      if (columnId === void 0) {
+        return;
+      }
+      commit("columnOrder", order, () => {
+        options.onColumnOrderChange?.({ columnId, order });
+      });
+    },
+    /**
+     * Applied to every id in display order rather than to the stored order,
+     * which starts empty and may name only some columns, so would have
+     * nothing to rearrange.
+     */
+    moveColumn(columnId, beforeId) {
+      const orderedIds = getView().dataColumns.map((entry) => entry.id);
+      const next = moveColumnBefore(orderedIds, columnId, beforeId);
+      if (next === orderedIds) {
+        return;
+      }
+      commit("columnOrder", next, () => {
+        options.onColumnOrderChange?.({ columnId, order: next });
+      });
+    },
+    setColumnVisibility(visibility) {
+      if (changedKeys(state.columnVisibility, visibility).length > 0) {
+        commitColumnVisibility(visibility);
+      }
+    },
+    showColumns(columnIds) {
+      changeColumnVisibility(columnIds, true);
+    },
+    hideColumns(columnIds) {
+      changeColumnVisibility(columnIds, false);
+    },
+    setFilter(filter) {
+      if (sameFilter(state.filter, filter)) {
+        return;
+      }
+      commit("filter", filter, () => {
+        options.onFilterChange?.({ filter });
+      });
+    },
+    setColumnSort(sort) {
+      const columnId = changedEntryColumnId(state.columnSort, sort);
+      if (columnId === void 0) {
+        return;
+      }
+      commit("columnSort", sort, () => {
+        options.onColumnSortChange?.({ columnId, sort });
+      });
+    },
+    toggleColumnSort(columnId, { stack = false } = {}) {
+      const next = toggleColumnSort(state.columnSort, columnId, { stack });
+      commit("columnSort", next, () => {
+        options.onColumnSortChange?.({ columnId, sort: next });
+      });
+    },
+    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 controller;
+}
+
+// src/commands/context.ts
+function selectedRowsOf(rows, selection) {
+  if (selection.length === 0) {
+    return [];
+  }
+  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/format.ts
+var DATE_FIELDS = {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric"
+};
+var TIME_FIELDS = {
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+};
+var DATE_TIME_FIELDS = {
+  ...DATE_FIELDS,
+  ...TIME_FIELDS
+};
+var CURRENCY_DIGITS = {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+};
+var NO_FORMAT = {};
+var formatters = /* @__PURE__ */ new WeakMap();
+function cached(format, key, create) {
+  const owner = format ?? NO_FORMAT;
+  let byKey = formatters.get(owner);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    formatters.set(owner, byKey);
+  }
+  const existing = byKey.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const formatter = create();
+  byKey.set(key, formatter);
+  return formatter;
+}
+function localeKey(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
+}
+function isNumericType(type) {
+  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
+}
+function numberOptions(type, format) {
+  switch (type) {
+    case "currency":
+      return format?.currency === void 0 ? { ...CURRENCY_DIGITS, ...format } : { style: "currency", ...format };
+    case "percent":
+      return { style: "percent", ...format };
+    default:
+      return format ?? {};
+  }
+}
+function dateOptions(type, format) {
+  if (format !== void 0) {
+    return format;
+  }
+  if (type === "date") return DATE_FIELDS;
+  if (type === "time") return TIME_FIELDS;
+  return DATE_TIME_FIELDS;
+}
+function formatNumber(value, type, format, locale) {
+  const formatter = cached(
+    format,
+    `number|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.NumberFormat(
+      locale,
+      numberOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatDate(value, type, format, locale) {
+  if (Number.isNaN(value.getTime())) {
+    return String(value);
+  }
+  const formatter = cached(
+    format,
+    `date|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.DateTimeFormat(
+      locale,
+      dateOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatOther(value) {
+  if (typeof value === "function") {
+    return "(function)";
+  }
+  if (typeof value === "object" && value !== null) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return Object.prototype.toString.call(value);
+    }
+  }
+  return String(value);
+}
+function formatCellValue(value, column, locale, row, messages) {
+  if (column.valueFormatter !== void 0) {
+    return column.valueFormatter(value, row);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "boolean" && messages !== void 0) {
+    return value ? messages.booleanTrue : messages.booleanFalse;
+  }
+  const { type, format } = column;
+  const formatted = format !== void 0 || locale !== void 0;
+  if (value instanceof Date) {
+    return 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 aggregateFormatColumn(value, spec, column) {
+  const plain = {
+    field: spec.columnId,
+    type: "number"
+  };
+  if (column === void 0 || spec.fn === "count" || spec.fn === "countDistinct") {
+    return plain;
+  }
+  const numeric = typeof value === "number" || typeof value === "bigint";
+  return column.valueFormatter === void 0 && numeric && !isNumericType(column.type) ? plain : column;
+}
+function formatAggregateValue(value, spec, column, locale) {
+  const target = aggregateFormatColumn(value, spec, column);
+  if (typeof value === "number" && target.valueFormatter === void 0 && target.format === void 0 && locale === void 0) {
+    return value.toLocaleString();
+  }
+  return formatCellValue(value, target, locale);
+}
+function formatGroupValue(value, column, locale, messages) {
+  return value === null || value === void 0 ? messages.blankGroupValue : formatCellValue(value, column, locale, void 0, messages);
+}
+
+// src/export/buildExportTable.ts
+var EMPTY_CELL = { value: null, text: "" };
+function isDataRow(entry) {
+  return !("kind" in entry);
+}
+function pickColumns(view, selection) {
+  let picked;
+  if (selection === "visible") {
+    picked = view.columns;
+  } else if (selection === "all") {
+    picked = view.dataColumns;
+  } else {
+    const byId = new Map(view.dataColumns.map((entry) => [entry.id, entry]));
+    picked = [...new Set(selection)].flatMap((id) => byId.get(id) ?? []);
+  }
+  return picked.filter((entry) => entry.column.exportable !== false);
+}
+function describeColumns(picked, source) {
+  const shown = new Map(source.view.columns.map((entry) => [entry.id, entry]));
+  const resolved = resolveColumnWidths(
+    picked.map((entry) => entry.column),
+    source.state.columnSizing,
+    { sizes: source.options.columnSizeDefaults }
+  );
+  return resolved.map((entry) => {
+    const rendered = shown.get(entry.id) ?? entry;
+    return {
+      id: rendered.id,
+      header: resolveColumnHeaderText(rendered.column),
+      type: rendered.column.type ?? "string",
+      format: rendered.column.format,
+      alignment: rendered.alignment,
+      width: rendered.width
+    };
+  });
+}
+function scopedRows(source, scope) {
+  const { view, state } = source;
+  switch (scope) {
+    case "all":
+      return view.rows;
+    case "page":
+      return view.displayDataRows;
+    case "selection": {
+      const selected = new Set(state.rowSelection);
+      return view.rows.filter((entry) => selected.has(entry.rowId));
+    }
+  }
+}
+function typedValue(value, text) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date ? value : text;
+}
+function dataCell(row, column, context) {
+  const raw = accessDotted(row, column.field);
+  const text = formatCellValue(
+    raw,
+    column,
+    context.locale,
+    row,
+    context.messages
+  );
+  return {
+    value: column.exportValue === void 0 ? typedValue(raw, text) : column.exportValue(raw, row),
+    text
+  };
+}
+function aggregateCell(results, specs, column, locale) {
+  const parts = specs.flatMap((spec) => {
+    const value = results.get(spec.id ?? spec.columnId);
+    return value === null || value === void 0 ? [] : [{ value, text: formatAggregateValue(value, spec, column, locale) }];
+  });
+  const [only] = parts;
+  if (only === void 0) {
+    return EMPTY_CELL;
+  }
+  if (parts.length === 1) {
+    return { value: typedValue(only.value, only.text), text: only.text };
+  }
+  const text = parts.map((part) => part.text).join(", ");
+  return { value: text, text };
+}
+function aggregateCells(results, context) {
+  return context.columns.map((entry) => {
+    const specs = context.specsByColumn.get(entry.id);
+    return specs === void 0 ? EMPTY_CELL : aggregateCell(results, specs, entry.column, context.locale);
+  });
+}
+function groupLabel(entry, source) {
+  const column = source.view.dataColumns.find(
+    (candidate) => candidate.id === entry.columnId
+  )?.column ?? { field: entry.columnId };
+  const value = formatGroupValue(
+    entry.value,
+    column,
+    source.options.locale,
+    source.messages
+  );
+  return `${resolveColumnHeaderText(column)}: ${value}`;
+}
+function toExportRow(entry, source, context) {
+  if (isDataRow(entry)) {
+    return {
+      kind: "data",
+      rowId: entry.rowId,
+      cells: context.columns.map(
+        (column) => dataCell(entry.row, column.column, context)
+      )
+    };
+  }
+  if (entry.kind === "group") {
+    return {
+      kind: "group",
+      level: entry.level,
+      groupId: entry.groupId,
+      label: groupLabel(entry, source),
+      count: entry.count,
+      cells: context.display === "inline" ? aggregateCells(entry.aggregates, context) : context.columns.map(() => EMPTY_CELL)
+    };
+  }
+  return {
+    kind: "groupSummary",
+    level: entry.level,
+    cells: aggregateCells(entry.aggregates, context)
+  };
+}
+function specsByColumnOf(specs) {
+  const byColumn = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const owned = byColumn.get(spec.columnId);
+    if (owned === void 0) {
+      byColumn.set(spec.columnId, [spec]);
+    } else {
+      owned.push(spec);
+    }
+  }
+  return byColumn;
+}
+function buildExportTable(source, options = {}) {
+  const { view, state } = source;
+  const specs = options.includeAggregates ?? true ? source.options.aggregates ?? [] : [];
+  const columns = pickColumns(view, options.columns ?? "visible");
+  const context = {
+    columns,
+    specsByColumn: specsByColumnOf(specs),
+    display: source.options.groupAggregateDisplay ?? "inline",
+    locale: source.options.locale,
+    messages: source.messages
+  };
+  const rows = scopedRows(source, options.scope ?? "all");
+  const grouped = groupRows(rows, state.groupBy, [], view.dataColumns);
+  const displayRows = options.includeGroups ?? true ? withGroupAggregates(
+    grouped,
+    rows,
+    state.groupBy,
+    specs,
+    view.dataColumns,
+    context.display
+  ) : grouped.filter(isDataRow);
+  let footer = null;
+  if (specs.length > 0) {
+    const totals = rows === view.rows ? view.grandTotal : computeAggregates(
+      rows.map((entry) => entry.row),
+      specs,
+      view.dataColumns
+    );
+    footer = { kind: "total", cells: aggregateCells(totals, context) };
+  }
+  return {
+    columns: describeColumns(columns, source),
+    header: options.includeHeader ?? true,
+    rows: displayRows.map((entry) => toExportRow(entry, source, context)),
+    footer
+  };
+}
+
+// src/export/htmlTable.ts
+var ENTITIES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(text) {
+  return text.replace(/[&<>"']/g, (char) => ENTITIES[char] ?? char);
+}
+function cellHtml(tag, text, column) {
+  const alignment = column?.alignment ?? "left";
+  const style = alignment === "left" ? "" : ` style="text-align:${alignment}"`;
+  return `<${tag}${style}>${escapeHtml(text)}</${tag}>`;
+}
+function cellsHtml(cells, columns) {
+  return cells.map((cell, index) => cellHtml("td", cell.text, columns[index])).join("");
+}
+function groupRowHtml(row, columns) {
+  const firstAggregate = row.cells.findIndex((cell) => cell.text !== "");
+  const span = Math.max(
+    1,
+    firstAggregate === -1 ? row.cells.length : firstAggregate
+  );
+  const colspan = span > 1 ? ` colspan="${String(span)}"` : "";
+  const label = `<td${colspan}>${escapeHtml(row.label)}</td>`;
+  const aggregates = row.cells.slice(span).map((cell, index) => cellHtml("td", cell.text, columns[span + index])).join("");
+  return `<tr class="export-group" data-level="${String(row.level)}">${label}${aggregates}</tr>`;
+}
+function rowHtml(row, columns) {
+  switch (row.kind) {
+    case "data":
+      return `<tr>${cellsHtml(row.cells, columns)}</tr>`;
+    case "group":
+      return groupRowHtml(row, columns);
+    case "groupSummary":
+      return `<tr class="export-group-summary" data-level="${String(row.level)}">${cellsHtml(row.cells, columns)}</tr>`;
+  }
+}
+function toHtmlTable(table, options = {}) {
+  const { columns } = table;
+  const caption = options.caption === void 0 ? "" : `<caption>${escapeHtml(options.caption)}</caption>`;
+  const head = table.header ? `<thead><tr>${columns.map((column) => cellHtml("th", column.header, column)).join("")}</tr></thead>` : "";
+  const body = `<tbody>${table.rows.map((row) => rowHtml(row, columns)).join("")}</tbody>`;
+  const foot = table.footer === null ? "" : `<tfoot><tr>${cellsHtml(table.footer.cells, columns)}</tr></tfoot>`;
+  return `<table class="gridkit-export-table">${caption}${head}${body}${foot}</table>`;
+}
+
+// src/export/records.ts
+function rawText(value) {
+  if (value === null) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  }
+  return String(value);
+}
+function cellField(cell, values) {
+  return {
+    text: values === "raw" ? rawText(cell.value) : cell.text,
+    isNumber: typeof cell.value === "number"
+  };
+}
+function textField(text) {
+  return { text, isNumber: false };
+}
+function textRecords(table, values) {
+  const records = [];
+  if (table.header) {
+    records.push(table.columns.map((column) => textField(column.header)));
+  }
+  for (const row of table.rows) {
+    records.push(
+      row.cells.map(
+        (cell, index) => row.kind === "group" && index === 0 ? textField(row.label) : cellField(cell, values)
+      )
+    );
+  }
+  if (table.footer !== null) {
+    records.push(table.footer.cells.map((cell) => cellField(cell, values)));
+  }
+  return records;
+}
+
+// src/export/tsv.ts
+var SEPARATORS = /\r\n|[\t\r\n]/g;
+function toTsv(table, options = {}) {
+  return textRecords(table, options.values ?? "text").map(
+    (record) => record.map((field) => field.text.replace(SEPARATORS, " ")).join("	")
+  ).join("\n");
+}
+
+// src/export/copy.ts
+function isCopyable(column) {
+  return column.column.exportable !== false;
+}
+function hasRow(source, rowId) {
+  return source.view.rows.some((entry) => entry.rowId === rowId);
+}
+function hasColumn(source, columnId) {
+  return source.view.columns.some(
+    (entry) => entry.id === columnId && isCopyable(entry)
+  );
+}
+function selectionCopy(source) {
+  const { state, view } = source;
+  const selectedRows = new Set(state.rowSelection);
+  const count = view.rows.filter(
+    (entry) => selectedRows.has(entry.rowId)
+  ).length;
+  if (count > 0) {
+    return { kind: "rows", count };
+  }
+  const selectedColumns = new Set(state.columnSelection);
+  const columnIds = view.columns.filter((entry) => selectedColumns.has(entry.id) && isCopyable(entry)).map((entry) => entry.id);
+  if (columnIds.length > 0 && view.rows.length > 0) {
+    return { kind: "columns", columnIds };
+  }
+  const cell = state.cellSelection;
+  if (cell !== null && hasRow(source, cell.rowId) && hasColumn(source, cell.columnId)) {
+    return { kind: "cell", rowId: cell.rowId, columnId: cell.columnId };
+  }
+  return null;
+}
+function canCopySelection(source) {
+  return selectionCopy(source) !== null;
+}
+function withRows(source, rowIds) {
+  return { ...source, state: { ...source.state, rowSelection: rowIds } };
+}
+function contentOf(source, { scope, columns, header }, unit) {
+  const table = buildExportTable(source, {
+    scope,
+    columns: columns ?? "visible",
+    includeHeader: header,
+    includeGroups: false,
+    includeAggregates: false
+  });
+  if (table.columns.length === 0 || table.rows.length === 0) {
+    return null;
+  }
+  return {
+    text: toTsv(table),
+    html: toHtmlTable(table),
+    count: unit === "columns" ? table.columns.length : table.rows.length,
+    unit
+  };
+}
+function cellContent(source, rowId, columnId) {
+  if (!hasRow(source, rowId) || !hasColumn(source, columnId)) {
+    return null;
+  }
+  return contentOf(
+    withRows(source, [rowId]),
+    { scope: "selection", columns: [columnId], header: false },
+    "cells"
+  );
+}
+function rowContent(source, rowId) {
+  if (!hasRow(source, rowId)) {
+    return null;
+  }
+  return contentOf(
+    withRows(source, [rowId]),
+    { scope: "selection", header: false },
+    "rows"
+  );
+}
+function selectionContent(source) {
+  const selection = selectionCopy(source);
+  switch (selection?.kind) {
+    case void 0:
+      return null;
+    case "rows":
+      return contentOf(
+        source,
+        { scope: "selection", header: selection.count > 1 },
+        "rows"
+      );
+    case "columns":
+      return contentOf(
+        source,
+        { scope: "all", columns: selection.columnIds, header: true },
+        "columns"
+      );
+    case "cell":
+      return cellContent(source, selection.rowId, selection.columnId);
+  }
+}
+function copyContent(source, request) {
+  switch (request.kind) {
+    case "cell":
+      return cellContent(source, request.rowId, request.columnId);
+    case "row":
+      return rowContent(source, request.rowId);
+    case "selection":
+      return selectionContent(source);
+  }
+}
+
+// src/export/exportFile.ts
+function withExtension(fileName, extension) {
+  const suffix = `.${extension}`;
+  return fileName.toLowerCase().endsWith(suffix.toLowerCase()) ? fileName : fileName + suffix;
+}
+function writerFor(format, writers) {
+  if (typeof format !== "string") {
+    return format;
+  }
+  const writer = writers.get(format);
+  if (writer === void 0) {
+    reportError(
+      `there is no export writer for \`${format}\` \u2014 register one through \`exportWriters\`.`
+    );
+    return null;
+  }
+  return writer;
+}
+function fileNameFor(options, writer) {
+  const { fileName = "export" } = options;
+  const name = typeof fileName === "function" ? fileName(writer.format) : fileName;
+  return withExtension(name, writer.fileExtension);
+}
+function exportFile(source, format, options, writers) {
+  const writer = writerFor(format, writers);
+  if (writer === null) {
+    return null;
+  }
+  const content = writer.write(buildExportTable(source, options), {
+    locale: source.options.locale,
+    messages: source.messages,
+    options
+  });
+  const fileName = fileNameFor(options, writer);
+  const { mimeType } = writer;
+  return content instanceof Promise ? content.then((resolved) => ({ fileName, mimeType, content: resolved })) : { fileName, mimeType, content };
+}
+
+// src/export/print.ts
+var PORTRAIT_COLUMN_LIMIT = 6;
+function resolveOrientation(table, options) {
+  return options.orientation ?? (table.columns.length > PORTRAIT_COLUMN_LIMIT ? "landscape" : "portrait");
+}
+function timestampText(timestamp, locale) {
+  const date = timestamp === true ? /* @__PURE__ */ new Date() : timestamp;
+  return new Intl.DateTimeFormat(locale, {
+    dateStyle: "medium",
+    timeStyle: "short"
+  }).format(date);
+}
+function line(tag, className, text) {
+  return text === void 0 || text === "" ? "" : `<${tag} class="${className}">${escapeHtml(text)}</${tag}>`;
+}
+function headerHtml(options) {
+  const { timestamp = false } = options;
+  const lines = line("h1", "print-title", options.title) + line("p", "print-subtitle", options.subtitle) + (timestamp === false ? "" : line("p", "print-timestamp", timestampText(timestamp, options.locale)));
+  return lines === "" ? "" : `<header class="gridkit-print-header">${lines}</header>`;
+}
+function buildPrintDocument(table, options = {}) {
+  const footer = line("footer", "gridkit-print-footer", options.footer);
+  return {
+    title: options.title ?? "",
+    bodyHtml: `${headerHtml(options)}${toHtmlTable(table)}${footer}`,
+    page: {
+      paperSize: options.paperSize ?? "A4",
+      orientation: resolveOrientation(table, options),
+      pageNumbers: options.pageNumbers ?? true,
+      fitToWidth: options.fitToWidth ?? false
+    }
+  };
+}
+function exportPrintDocument(source, options = {}) {
+  return buildPrintDocument(buildExportTable(source, options), {
+    ...options,
+    title: options.title ?? source.options.label,
+    locale: options.locale ?? source.options.locale
+  });
+}
+
+// src/export/csv.ts
+var BOM = "\uFEFF";
+var FORMULA_START = /^[=+\-@\t\r]/;
+var SIGN_START = /^[+-]/;
+var NEEDS_QUOTES = /["\r\n]/;
+function autoDelimiter(locale) {
+  const decimal = new Intl.NumberFormat(locale).formatToParts(1.5).find((part) => part.type === "decimal")?.value;
+  return decimal === "," ? ";" : ",";
+}
+function neutralize(field) {
+  const { text } = field;
+  if (!FORMULA_START.test(text) || field.isNumber && SIGN_START.test(text)) {
+    return text;
+  }
+  return `'${text}`;
+}
+function quote(text, delimiter) {
+  return text.includes(delimiter) || NEEDS_QUOTES.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function toCsv(table, options = {}) {
+  const delimiter = options.delimiter === "auto" ? autoDelimiter(options.locale) : options.delimiter ?? ",";
+  const guard = options.neutralizeFormulas ?? true;
+  const lines = textRecords(table, options.values ?? "text").map(
+    (record) => record.map((field) => quote(guard ? neutralize(field) : field.text, delimiter)).join(delimiter)
+  );
+  return (options.bom ?? true ? BOM : "") + lines.join(options.eol ?? "\r\n");
+}
+
+// src/export/json.ts
+function uniqueNames(names) {
+  const used = /* @__PURE__ */ new Set();
+  return names.map((name) => {
+    let unique = name;
+    for (let n = 2; used.has(unique); n += 1) {
+      unique = `${name} (${String(n)})`;
+    }
+    used.add(unique);
+    return unique;
+  });
+}
+function toJson(table, options = {}) {
+  const keys = options.keys === "header" ? uniqueNames(table.columns.map((column) => column.header)) : table.columns.map((column) => column.id);
+  const records = table.rows.flatMap(
+    (row) => row.kind === "data" ? [
+      Object.fromEntries(
+        keys.map((key, index) => [key, row.cells[index]?.value ?? null])
+      )
+    ] : []
+  );
+  return JSON.stringify(records, null, options.space);
+}
+
+// src/export/writer.ts
+var csvWriter = {
+  format: "csv",
+  fileExtension: "csv",
+  mimeType: "text/csv;charset=utf-8",
+  write: (table, { locale, options }) => toCsv(table, { locale, ...options.csv })
+};
+var jsonWriter = {
+  format: "json",
+  fileExtension: "json",
+  mimeType: "application/json",
+  write: (table, { options }) => toJson(table, options.json)
+};
+function resolveExportWriters(writers) {
+  return new Map(
+    [csvWriter, jsonWriter, ...writers ?? []].map((writer) => [
+      writer.format,
+      writer
+    ])
+  );
+}
+
+// src/filterMenu/operators.ts
+function filterOperatorFamily(type) {
+  return kindOf(type);
+}
+var familyOperators = {
+  text: [
+    "contains",
+    "notContains",
+    "eq",
+    "ne",
+    "startsWith",
+    "endsWith",
+    "isEmpty",
+    "isNotEmpty"
+  ],
+  number: [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "isEmpty",
+    "isNotEmpty"
+  ],
+  date: ["eq", "ne", "lt", "gt", "between", "isEmpty", "isNotEmpty"],
+  boolean: ["eq", "isEmpty", "isNotEmpty"]
+};
+var instantOperators = [
+  "lt",
+  "gt",
+  "between",
+  "isEmpty",
+  "isNotEmpty"
+];
+function defaultFilterOperators(type) {
+  return type === "dateTime" || type === "time" ? instantOperators : familyOperators[filterOperatorFamily(type)];
+}
+function filterOperandArity(operator) {
+  switch (operator) {
+    case "isEmpty":
+    case "isNotEmpty":
+      return 0;
+    case "between":
+      return 2;
+    case "eq":
+    case "ne":
+    case "contains":
+    case "notContains":
+    case "startsWith":
+    case "endsWith":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "in":
+      return 1;
+  }
+}
+var NUMBER_INPUT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+var DATE_INPUT = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?$/;
+function parseNumber(text) {
+  const value = Number(text);
+  return NUMBER_INPUT.test(text) && Number.isFinite(value) ? value : void 0;
+}
+function parseDate(text) {
+  const match = DATE_INPUT.exec(text);
+  if (match === null) {
+    return void 0;
+  }
+  const [
+    ,
+    year,
+    month,
+    day,
+    hours = "0",
+    minutes = "0",
+    seconds = "0",
+    fraction = ""
+  ] = match;
+  if (Number(hours) > 23 || Number(minutes) > 59 || Number(seconds) > 59) {
+    return void 0;
+  }
+  const date = new Date(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hours),
+    Number(minutes),
+    Number(seconds),
+    Number(fraction.padEnd(3, "0"))
+  );
+  return date.getFullYear() === Number(year) && date.getMonth() === Number(month) - 1 && date.getDate() === Number(day) ? date : void 0;
+}
+function parseBoolean(text) {
+  if (text === "true") {
+    return true;
+  }
+  return text === "false" ? false : void 0;
+}
+function parseFilterOperand(text, type) {
+  if (text === "") {
+    return void 0;
+  }
+  switch (filterOperatorFamily(type)) {
+    case "text":
+      return text;
+    case "number":
+      return parseNumber(text.trim());
+    case "date":
+      return parseDate(text.trim());
+    case "boolean":
+      return parseBoolean(text.trim());
+  }
+}
+function pad(value, width = 2) {
+  return String(value).padStart(width, "0");
+}
+function dayInput(date) {
+  return `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function momentInput(date) {
+  const minute = `${dayInput(date)}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  const seconds = date.getSeconds();
+  const milliseconds = date.getMilliseconds();
+  if (seconds === 0 && milliseconds === 0) {
+    return minute;
+  }
+  const second = `${minute}:${pad(seconds)}`;
+  return milliseconds === 0 ? second : `${second}.${pad(milliseconds, 3)}`;
+}
+function formatFilterOperand(value, type) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const date = filterOperatorFamily(type) === "date" ? toDate(value) : void 0;
+  if (date === void 0) {
+    return String(value);
+  }
+  return type === "date" ? dayInput(date) : momentInput(date);
+}
+
+// src/filterMenu/options.ts
+var DEFAULT_FILTER_VALUE_LIMIT = 1e4;
+function conditionOperators(operators) {
+  return operators.includes("in") ? operators.filter((operator) => operator !== "in") : operators;
+}
+function resolveColumnFilterMenu(options, column) {
+  if (!(column.filterable ?? options.filterableColumns ?? false)) {
+    return null;
+  }
+  const grid = options.filterMenu;
+  const own = column.filterMenu;
+  return {
+    ui: own?.ui ?? grid?.ui ?? "simple",
+    operators: conditionOperators(
+      own?.operators ?? defaultFilterOperators(column.type)
+    ),
+    family: filterOperatorFamily(column.type),
+    showCounts: grid?.showCounts ?? false,
+    valueLimit: grid?.valueLimit ?? DEFAULT_FILTER_VALUE_LIMIT
+  };
+}
+
+// src/messages.ts
+function localeKey2(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
+}
+var countFormats = /* @__PURE__ */ new Map();
+function countFormat(locale) {
+  const key = localeKey2(locale);
+  let format = countFormats.get(key);
+  if (format === void 0) {
+    const numberFormat = new Intl.NumberFormat(locale, {
+      maximumFractionDigits: 0
+    });
+    format = (count) => numberFormat.format(count);
+    countFormats.set(key, format);
+  }
+  return format;
+}
+function columnCount(n, count, change) {
+  return count === 1 ? `1 column ${change}` : `${n(count)} columns ${change}`;
+}
+function searchResults(n, count) {
+  if (count === 0) {
+    return "No rows found";
+  }
+  return count === 1 ? "1 row found" : `${n(count)} rows found`;
+}
+function selectedCount(n, count, target) {
+  const noun = target === "rows" ? "row" : "column";
+  if (count === 0) {
+    return `No ${noun}s selected`;
+  }
+  return count === 1 ? `1 ${noun} selected` : `${n(count)} ${noun}s selected`;
+}
+var operatorLabels = {
+  eq: "Equals",
+  ne: "Does not equal",
+  contains: "Contains",
+  notContains: "Does not contain",
+  startsWith: "Starts with",
+  endsWith: "Ends with",
+  gt: "Greater than",
+  gte: "Greater than or equal to",
+  lt: "Less than",
+  lte: "Less than or equal to",
+  between: "Between",
+  in: "Is one of",
+  isEmpty: "Is blank",
+  isNotEmpty: "Is not blank"
+};
+var dateOperatorLabels = {
+  lt: "Before",
+  lte: "On or before",
+  gt: "After",
+  gte: "On or after"
+};
+function filterOperatorLabel(operator, family) {
+  return (family === "date" ? dateOperatorLabels[operator] : void 0) ?? operatorLabels[operator];
+}
+function filterSearchFirst(n, total) {
+  return total === 1 ? "Type to search 1 value" : `Type to search ${n(total)} values`;
+}
+function filterResults(n, shown, total) {
+  return `${n(shown)} of ${n(total)} ${total === 1 ? "row" : "rows"}`;
+}
+var filterValueRequests = {
+  text: "Enter a value",
+  number: "Enter a number",
+  date: "Enter a date",
+  boolean: "Choose a value"
+};
+var filterOperatorMenus = {
+  text: "Text filters",
+  number: "Number filters",
+  date: "Date filters",
+  boolean: "Boolean filters"
+};
+function copied(n, count, unit) {
+  return count === 1 ? `1 ${unit.slice(0, -1)} copied` : `${n(count)} ${unit} copied`;
+}
+function createDefaultMessages(locale) {
+  const n = countFormat(locale);
+  return {
+    pagerLabel: "Pagination",
+    firstPage: "First",
+    previousPage: "Previous",
+    nextPage: "Next",
+    lastPage: "Last",
+    pageSizeLabel: "Rows per page",
+    pageButtonLabel: (page) => `Page ${n(page)}`,
+    pageStatus: (page, pageCount) => `Page ${n(page)} of ${n(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 ${n(level)} of ${n(levelCount)}` : columnName2,
+    removeGroupBy: (columnName2) => `Stop grouping by ${columnName2}`,
+    columnResized: (columnName2, width) => `${columnName2}, ${n(width)} pixels wide`,
+    columnMoved: (columnName2, position, columnCount2) => `${columnName2}, column ${n(position)} of ${n(columnCount2)}`,
+    columnSorted: (columnName2, direction, key, keyCount) => {
+      const sorted = `${columnName2} sorted ${direction === "asc" ? "ascending" : "descending"}`;
+      return keyCount > 1 ? `${sorted}, key ${n(key)} of ${n(keyCount)}` : sorted;
+    },
+    sortCleared: (columnName2) => `${columnName2}, sort cleared`,
+    groupedBy: (columnName2, level, levelCount) => levelCount > 1 ? `Grouped by ${columnName2}, level ${n(level)} of ${n(levelCount)}` : `Grouped by ${columnName2}`,
+    groupingRemoved: (columnName2) => `${columnName2}, grouping removed`,
+    groupExpanded: "Group expanded",
+    groupCollapsed: "Group collapsed",
+    allGroupsExpanded: "All groups expanded",
+    allGroupsCollapsed: "All groups collapsed",
+    selectedCount: (count, target) => selectedCount(n, count, target),
+    cellSelected: (columnName2, rowNumber) => `${columnName2}, row ${n(rowNumber)}, selected`,
+    columnHidden: (columnName2) => `${columnName2}, column hidden`,
+    columnShown: (columnName2) => `${columnName2}, column shown`,
+    columnsHidden: (count) => columnCount(n, count, "hidden"),
+    columnsShown: (count) => columnCount(n, count, "shown"),
+    columnsAutoFitted: (count) => columnCount(n, 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: (count) => searchResults(n, count),
+    columnChooserLabel: "Columns",
+    columnChooserSearchLabel: "Search columns",
+    showAllColumns: "Show all",
+    noMatchingColumns: "No matching columns",
+    filterOperatorLabel,
+    filterBlanks: "(Blanks)",
+    filterSearchFirst: (total) => filterSearchFirst(n, total),
+    filterMoreValues: (count) => `${n(count)} more, refine the search`,
+    openFilter: "Filter\u2026",
+    clearColumnFilter: "Clear filter",
+    filterMenuLabel: (columnName2) => `${columnName2} filter`,
+    columnFiltered: "Filtered",
+    applyFilter: "OK",
+    cancelFilter: "Cancel",
+    customFilter: "Custom filter",
+    filterResults: (shown, total) => filterResults(n, shown, total),
+    filterConditionLabel: (position) => `Condition ${n(position)}`,
+    filterOperatorFieldLabel: "Operator",
+    filterValueLabel: "Value",
+    filterFromLabel: "From",
+    filterToLabel: "To",
+    filterCombinatorLabel: "Combine conditions",
+    filterAnd: "And",
+    filterOr: "Or",
+    filterValueInvalid: (family) => filterValueRequests[family],
+    filterSearchLabel: "Search values",
+    filterSelectAll: "Select all",
+    filterValuesLabel: "Values",
+    filterByCondition: "Filtered by condition",
+    filterOperatorMenu: (family) => filterOperatorMenus[family],
+    filterBackToValues: "Back to values",
+    exportMenu: "Export",
+    exportCsv: "Export to CSV",
+    exportJson: "Export to JSON",
+    exportXlsx: "Export to Excel",
+    exportPdf: "Export to PDF",
+    exportSelectionCsv: "Export selection to CSV",
+    exportSelectionJson: "Export selection to JSON",
+    exportSelectionXlsx: "Export selection to Excel",
+    exportFailed: "Export failed",
+    copyCell: "Copy cell",
+    copyRow: "Copy row",
+    copySelection: "Copy selection",
+    copied: (count, unit) => copied(n, count, unit),
+    copyFailed: "Copy failed",
+    print: "Print"
+  };
+}
+var defaultMessages = createDefaultMessages();
+var localeDefaults = /* @__PURE__ */ new Map();
+function defaultsFor(locale) {
+  if (locale === void 0) {
+    return defaultMessages;
+  }
+  const key = localeKey2(locale);
+  let defaults = localeDefaults.get(key);
+  if (defaults === void 0) {
+    defaults = createDefaultMessages(locale);
+    localeDefaults.set(key, defaults);
+  }
+  return defaults;
+}
+function resolveMessages(messages, locale) {
+  const defaults = defaultsFor(locale);
+  return messages === void 0 ? defaults : { ...defaults, ...messages };
+}
+
+// src/util/filterEditor.ts
+function touchesColumn(entry, columnId) {
+  return "combinator" in entry ? entry.entries.some((nested) => touchesColumn(nested, columnId)) : entry.columnId === columnId;
+}
+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 isColumnFiltered(filter, columnId) {
+  return filter.some((entry) => touchesColumn(entry, columnId));
+}
+function isOfferable(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date;
+}
+function matchesSearch(label, search) {
+  return label.toLowerCase().includes(search.toLowerCase());
+}
+function columnValueOptions(rows, dataColumns, filter, columnId, query = {}) {
+  const column = dataColumns.find((entry) => entry.id === columnId)?.column;
+  if (column === void 0) {
+    return { options: [], total: 0, truncated: false, blanks: 0 };
+  }
+  const keep = compileFilter(
+    filter.filter((entry) => !touchesColumn(entry, columnId)),
+    dataColumns
+  );
+  const buckets = /* @__PURE__ */ new Map();
+  let blanks = 0;
+  for (const row of rows) {
+    if (keep !== void 0 && !keep(row)) {
+      continue;
+    }
+    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 { search = "", limit, locale } = query;
+  const messages = resolveMessages(query.messages, locale);
+  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) => matchesSearch(option.label, search));
+  const shown = limit === void 0 ? options : options.slice(0, limit);
+  return {
+    options: shown,
+    total: options.length,
+    truncated: shown.length < options.length,
+    blanks,
+    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
+      };
+    case "conditions":
+      return {
+        ...draft,
+        mode: "conditions",
+        conditions: shape.conditions,
+        combinator: shape.combinator
+      };
+    case "none":
+    case "custom":
+      return draft;
+  }
+}
+function visibleFilterOptions(draft) {
+  return draft.search === "" ? draft.options : draft.options.filter(
+    (option) => matchesSearch(option.label, draft.search)
+  );
+}
+function selectAllCoversBlanks(draft) {
+  return draft.search === "" && draft.blanks > 0;
+}
+function selectAllState(draft) {
+  const states = visibleFilterOptions(draft).map(
+    (option) => draft.checked.has(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 {
+    ...draft,
+    mode: "values",
+    checked,
+    includeBlanks: selectAllCoversBlanks(draft) ? check : draft.includeBlanks
+  };
+}
+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: []
+      };
+  }
+}
+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" }]
+    }
+  ] : [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/commands/builtInCommands.ts
+function isOn(context, areas) {
+  return areas.includes(context.target.area);
+}
+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 filterableColumn(context) {
+  const column = columnOn(context, ["header"]);
+  return column !== null && resolveColumnFilterMenu(context.options, column.column) !== null ? 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;
+  }
+  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);
+      }
+    }
+  };
+}
+var EXPORT_AREAS = ["grid", "toolbar", "body", "cell"];
+function exportCommand({
+  id,
+  format,
+  label,
+  selection = false
+}) {
+  return {
+    id,
+    label: ({ messages }) => label(messages),
+    isVisible: (context) => isOn(context, EXPORT_AREAS) && resolveExportWriters(context.options.exportWriters).has(format) && (!selection || context.state.rowSelection.length > 0),
+    isEnabled: (context) => (selection ? context.selectedRows() : context.view.rows).length > 0,
+    execute: (context) => {
+      const { export: defaults = {}, exportWriters } = context.options;
+      const file = exportFile(
+        context,
+        format,
+        selection ? { ...defaults, scope: "selection" } : defaults,
+        resolveExportWriters(exportWriters)
+      );
+      if (file !== null) {
+        context.host.saveFile(file);
+      }
+    }
+  };
+}
+function cellRequest(context, kind) {
+  const { target } = context;
+  if (target.area !== "cell") {
+    return null;
+  }
+  return kind === "cell" ? { kind, rowId: target.rowId, columnId: target.columnId } : { kind, rowId: target.rowId };
+}
+function copyCommand({
+  id,
+  label,
+  request,
+  isEnabled
+}) {
+  function contentFor(context) {
+    const asked = request(context);
+    return asked === null ? null : copyContent(context, asked);
+  }
+  return {
+    id,
+    label: ({ messages }) => label(messages),
+    icon: "copy",
+    isVisible: (context) => request(context) !== null,
+    isEnabled: isEnabled ?? ((context) => contentFor(context) !== null),
+    execute: (context) => {
+      const content = contentFor(context);
+      if (content !== null) {
+        context.host.writeClipboard(content);
+      }
+    }
+  };
+}
+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 }]);
+    }
+  });
+}
+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);
+      }
+    },
+    // Opened below the header it was asked for, as the chooser is.
+    columnCommand({
+      id: "filter.open",
+      label: ({ messages }) => messages.openFilter,
+      find: filterableColumn,
+      execute: (_column, { host, target }) => {
+        host.openPanel("filter", target);
+      }
+    }),
+    // Every entry about the column goes, whichever editor wrote it — or
+    // none did, as with a predicate set in code — as applying an editor
+    // replaces them all.
+    columnCommand({
+      id: "filter.clear",
+      label: ({ messages }) => messages.clearColumnFilter,
+      find: filterableColumn,
+      isEnabled: (column, { state }) => isColumnFiltered(state.filter, column.id),
+      execute: (column, { actions, state }) => {
+        actions.setFilter(
+          state.filter.filter((entry) => !touchesColumn(entry, column.id))
+        );
+      }
+    }),
+    {
+      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([]);
+      }
+    },
+    exportCommand({
+      id: "export.csv",
+      format: "csv",
+      label: ({ exportCsv }) => exportCsv
+    }),
+    exportCommand({
+      id: "export.json",
+      format: "json",
+      label: ({ exportJson }) => exportJson
+    }),
+    exportCommand({
+      id: "export.xlsx",
+      format: "xlsx",
+      label: ({ exportXlsx }) => exportXlsx
+    }),
+    exportCommand({
+      id: "export.pdf",
+      format: "pdf",
+      label: ({ exportPdf }) => exportPdf
+    }),
+    exportCommand({
+      id: "exportSelection.csv",
+      format: "csv",
+      label: ({ exportSelectionCsv }) => exportSelectionCsv,
+      selection: true
+    }),
+    exportCommand({
+      id: "exportSelection.json",
+      format: "json",
+      label: ({ exportSelectionJson }) => exportSelectionJson,
+      selection: true
+    }),
+    exportCommand({
+      id: "exportSelection.xlsx",
+      format: "xlsx",
+      label: ({ exportSelectionXlsx }) => exportSelectionXlsx,
+      selection: true
+    }),
+    copyCommand({
+      id: "copy.cell",
+      label: ({ copyCell }) => copyCell,
+      request: (context) => cellRequest(context, "cell")
+    }),
+    copyCommand({
+      id: "copy.row",
+      label: ({ copyRow }) => copyRow,
+      request: (context) => cellRequest(context, "row")
+    }),
+    // Shown wherever the grid as a whole is asked for, as the exports are,
+    // once anything can be selected; enabled once something is.
+    copyCommand({
+      id: "copy.selection",
+      label: ({ copySelection }) => copySelection,
+      request: (context) => isOn(context, EXPORT_AREAS) && isAnythingSelectable(context.options.selectable) ? { kind: "selection" } : null,
+      isEnabled: canCopySelection
+    }),
+    // Shown where the exports are, under the grid's `print` defaults. A grid
+    // with no rows still prints its header; one with no columns, nothing.
+    {
+      id: "print",
+      label: ({ messages }) => messages.print,
+      icon: "print",
+      isVisible: (context) => isOn(context, EXPORT_AREAS),
+      isEnabled: ({ view }) => view.columns.length > 0,
+      execute: (context) => {
+        const { print: options = {} } = context.options;
+        context.host.print(exportPrintDocument(context, options), options);
+      }
+    }
+  ];
+}
+
+// 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 runCommand(command, context) {
+  if (!isCommandVisible(command, context) || !isCommandEnabled(command, context)) {
+    return false;
+  }
+  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;
+  }
+  reported.add(id);
+  reportError(
+    `the menu or toolbar entry \`${id}\` names no command, so it is left out.`
+  );
+}
+function evaluate(value, context) {
+  return typeof value === "function" ? value(context) : value;
+}
+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 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 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);
+    }
+  }
+  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
+  };
+}
+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",
+    "filter.open",
+    "filter.clear",
+    "separator",
+    "group.add",
+    "group.remove",
+    "separator",
+    "column.autoFit",
+    "column.autoFitAll",
+    "separator",
+    "column.hide",
+    "column.choose"
+  ],
+  cell: [
+    "copy.cell",
+    "copy.row",
+    "copy.selection",
+    "separator",
+    "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 entries = (contextMenu === true ? void 0 : contextMenu[area]) ?? defaultContextMenu[area];
+  return typeof entries === "function" || entries.length > 0;
+}
+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/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 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;
+}
+
+// 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;
+}
+
+// src/toolbar/resolveToolbar.ts
+function isSpacer(entry) {
+  return entry.type === "spacer";
+}
+function exportMenu() {
+  return {
+    type: "submenu",
+    id: "export",
+    label: ({ messages }) => messages.exportMenu,
+    items: [
+      "export.csv",
+      "export.json",
+      "export.xlsx",
+      "export.pdf",
+      "separator",
+      "exportSelection.csv",
+      "exportSelection.json",
+      "exportSelection.xlsx"
+    ]
+  };
+}
+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 menuEntry = entry === "export" ? exportMenu() : entry;
+    const resolved = resolveMenuEntry(menuEntry, index, {
+      commands,
+      context: contextFor({
+        area: "toolbar",
+        itemId: typeof menuEntry === "string" ? menuEntry : menuEntry.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 };
+  }
+  return collapseSeparators(
+    entries.map(resolveEntry).filter((entry) => entry !== null),
+    isSpacer
+  );
+}
+
+// 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 {
+    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/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;
+  }
+  return next;
+}
+function nextFocusForKey(key, modifiers, focus, rowCount, columnCount2, pageSize, isSkippableRow = noRowsSkippable) {
+  if (modifiers.altKey) {
+    return null;
+  }
+  const { rowIndex, columnIndex } = focus;
+  switch (key) {
+    case "ArrowLeft":
+      if (modifiers.ctrlKey) return null;
+      return { rowIndex, columnIndex: columnIndex - 1 };
+    case "ArrowRight":
+      if (modifiers.ctrlKey) return null;
+      return { rowIndex, columnIndex: columnIndex + 1 };
+    case "ArrowUp":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    case "ArrowDown":
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex + 1,
+          1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
+    // Ctrl takes Home and End to the grid's ends rather than the row's, which
+    // is the one place Ctrl is navigation rather than reorder.
+    case "Home":
+      return modifiers.ctrlKey ? { rowIndex: HEADER_ROW, columnIndex: 0 } : { rowIndex, columnIndex: 0 };
+    case "End":
+      return modifiers.ctrlKey ? {
+        rowIndex: skipSkippableRows(
+          rowCount - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex: 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;
+  }
+}
+
+// src/util/paginationWindow.ts
+function paginationWindow(currentPage, pageCount, options) {
+  if (pageCount <= 0) {
+    return [];
+  }
+  const boundaryCount = Math.max(0, Math.floor(options?.boundaryCount ?? 1));
+  const siblingCount = Math.max(0, Math.floor(options?.siblingCount ?? 1));
+  const slotCount = 2 * boundaryCount + 2 * siblingCount + 3;
+  if (pageCount <= slotCount) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const current = Math.min(Math.max(currentPage, 1), pageCount);
+  const runStart = Math.min(
+    Math.max(current - siblingCount, boundaryCount + 2),
+    pageCount - boundaryCount - 1 - 2 * siblingCount
+  );
+  const runEnd = runStart + 2 * siblingCount;
+  const entries = [];
+  for (let page = 1; page <= boundaryCount; page++) {
+    entries.push(page);
+  }
+  entries.push(runStart === boundaryCount + 2 ? boundaryCount + 1 : "ellipsis");
+  for (let page = runStart; page <= runEnd; page++) {
+    entries.push(page);
+  }
+  entries.push(
+    runEnd === pageCount - boundaryCount - 1 ? pageCount - boundaryCount : "ellipsis"
+  );
+  for (let page = pageCount - boundaryCount + 1; page <= pageCount; page++) {
+    entries.push(page);
+  }
+  return entries;
+}
+
+// src/util/columnChooser.ts
+function isHideable(column) {
+  return column.column.hideable !== false;
+}
+function matchesSearch2(label, search) {
+  return label.toLowerCase().includes(search.toLowerCase());
+}
+function selectAllStateOf(states) {
+  if (states.length > 0 && states.every(Boolean)) {
+    return "checked";
+  }
+  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 }) => matchesSearch2(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/filterMenu/conditions.ts
+var ROW_COUNT = 2;
+function rowOf(condition, type) {
+  const { operator, value } = condition;
+  if (isScalarList(value)) {
+    const [low, high] = value;
+    return {
+      operator,
+      text: formatFilterOperand(low, type),
+      textTo: formatFilterOperand(high, type)
+    };
+  }
+  return { operator, text: formatFilterOperand(value, type), textTo: "" };
+}
+function conditionRowsFrom(shape, operators, type) {
+  const filled = shape.kind === "conditions" ? shape.conditions.map((condition) => rowOf(condition, type)) : [];
+  const [first] = operators;
+  if (first === void 0) {
+    return filled;
+  }
+  const blank = { operator: first, text: "", textTo: "" };
+  return Array.from(
+    { length: ROW_COUNT },
+    (_, index) => filled[index] ?? blank
+  );
+}
+function isEmptyRow(row) {
+  switch (filterOperandArity(row.operator)) {
+    case 0:
+      return false;
+    case 1:
+      return row.text === "";
+    case 2:
+      return row.text === "" && row.textTo === "";
+  }
+}
+function conditionOf(row, columnId, type) {
+  const { operator } = row;
+  switch (filterOperandArity(operator)) {
+    case 0:
+      return { columnId, operator };
+    case 1: {
+      const value = parseFilterOperand(row.text, type);
+      return value === void 0 ? void 0 : { columnId, operator, value };
+    }
+    case 2: {
+      const low = parseFilterOperand(row.text, type);
+      const high = parseFilterOperand(row.textTo, type);
+      return low === void 0 || high === void 0 ? void 0 : { columnId, operator, value: [low, high] };
+    }
+  }
+}
+function conditionsFromRows(rows, columnId, type) {
+  const conditions = [];
+  const invalid = [];
+  for (const [index, row] of rows.entries()) {
+    if (index > 0 && isEmptyRow(row)) {
+      continue;
+    }
+    const condition = conditionOf(row, columnId, type);
+    if (condition === void 0) {
+      invalid.push(index);
+    } else {
+      conditions.push(condition);
+    }
+  }
+  return { conditions, invalid };
+}
+
+// src/filterMenu/valueCache.ts
+function sameSource(a, b) {
+  return a.rows === b.rows && a.dataColumns === b.dataColumns && a.locale === b.locale && a.messages === b.messages;
+}
+function sameEntries(a, b) {
+  return a.length === b.length && a.every((entry, index) => entry === b[index]);
+}
+function createColumnValueOptionsCache() {
+  let source;
+  const lists = /* @__PURE__ */ new Map();
+  return {
+    get: (rows, dataColumns, filter, columnId, query = {}) => {
+      const { locale, messages } = query;
+      const current = { rows, dataColumns, locale, messages };
+      if (source === void 0 || !sameSource(source, current)) {
+        lists.clear();
+        source = current;
+      }
+      const others = filter.filter((entry) => !touchesColumn(entry, columnId));
+      const cached2 = lists.get(columnId);
+      if (cached2 !== void 0 && sameEntries(cached2.others, others)) {
+        return cached2.values;
+      }
+      const values = columnValueOptions(
+        rows,
+        dataColumns,
+        filter,
+        columnId,
+        messages === void 0 ? { locale } : { locale, messages }
+      );
+      lists.set(columnId, { others, values });
+      return values;
+    }
+  };
+}
+
+// src/filterMenu/checklist.ts
+function filterChecklist(draft, { valueLimit, blanksLabel }) {
+  const visible = visibleFilterOptions(draft);
+  const total = visible.length;
+  if (draft.search === "" && total > valueLimit) {
+    return { items: [], needsSearch: true, hiddenCount: 0, total };
+  }
+  const items = visible.slice(0, valueLimit).map(({ value, label, count }) => {
+    const key = keyOf2(draft, value);
+    const checked = draft.checked.has(key);
+    return { kind: "value", key, value, label, count, checked };
+  });
+  const hiddenCount = total - items.length;
+  if (selectAllCoversBlanks(draft)) {
+    items.push({
+      kind: "blanks",
+      // Blank cells' own key, which no offered value has.
+      key: keyOf2(draft, null),
+      label: blanksLabel,
+      count: draft.blanks,
+      checked: draft.includeBlanks
+    });
+  }
+  return { items, needsSearch: false, hiddenCount, total };
+}
+
+// src/util/virtualization.ts
+function visibleRange(heights, estimatedHeight, scrollTop, viewportHeight, overscan) {
+  const rowCount = heights.length;
+  if (rowCount === 0) {
+    return { startIndex: 0, endIndex: -1, offsetBefore: 0, offsetAfter: 0 };
+  }
+  function heightAt(index) {
+    return heights[index] ?? estimatedHeight;
+  }
+  const viewportBottom = scrollTop + viewportHeight;
+  let start = 0;
+  let top = 0;
+  while (start < rowCount - 1 && top + heightAt(start) <= scrollTop) {
+    top += heightAt(start);
+    start += 1;
+  }
+  const startTop = top;
+  let end = start;
+  let bottom = startTop + heightAt(start);
+  while (end < rowCount - 1 && bottom < viewportBottom) {
+    end += 1;
+    bottom += heightAt(end);
+  }
+  const overscanStart = Math.max(0, start - overscan);
+  const overscanEnd = Math.min(rowCount - 1, end + overscan);
+  let offsetBefore = 0;
+  for (let index = 0; index < overscanStart; index++) {
+    offsetBefore += heightAt(index);
+  }
+  let offsetAfter = 0;
+  for (let index = overscanEnd + 1; index < rowCount; index++) {
+    offsetAfter += heightAt(index);
+  }
+  return {
+    startIndex: overscanStart,
+    endIndex: overscanEnd,
+    offsetBefore,
+    offsetAfter
+  };
+}
+
+// src/presets.ts
+var excelFilter = {
+  filterableColumns: true,
+  filterMenu: { ui: "excel", showCounts: true }
+};
+export {
+  DEFAULT_COLUMN_SIZES,
+  DEFAULT_FILTER_VALUE_LIMIT,
+  HEADER_ROW,
+  KEYBOARD_STEP,
+  accessDotted,
+  alignmentForType,
+  applyColumnOrder,
+  applyColumnResize,
+  applyColumnVisibility,
+  applySelectionIntent,
+  beginColumnResize,
+  buildExportTable,
+  buildKeyShortcuts,
+  buildPrintDocument,
+  builtInCommands,
+  clampColumnWidth,
+  clampFocus,
+  clearAllFilters,
+  clearSelection,
+  collapseAllGroups,
+  columnValueOptions,
+  compareValues,
+  computeAggregates,
+  conditionRowsFrom,
+  conditionsFromRows,
+  contextMenuEntries,
+  copyContent,
+  createColumnValueOptionsCache,
+  createCommandContext,
+  createDefaultMessages,
+  createGridController,
+  createGridViewResolver,
+  csvWriter,
+  defaultContextMenu,
+  defaultFilterOperators,
+  defaultMessages,
+  defaultToolbar,
+  defineColumnsFromRows,
+  describeColumnFilter,
+  diffSelection,
+  draftToFilter,
+  excelFilter,
+  expandAllGroups,
+  exportFile,
+  exportPrintDocument,
+  filterChecklist,
+  filterEditorReducer,
+  filterOperandArity,
+  filterOperatorFamily,
+  filterQueryFor,
+  filterRows,
+  fitColumnsToWidth,
+  fitToolbarItems,
+  formatAggregateValue,
+  formatCellValue,
+  formatFilterOperand,
+  formatGroupValue,
+  getColumnId,
+  groupRowId,
+  groupRows,
+  hasContextMenu,
+  initialFilterEditorDraft,
+  intentOf,
+  isColumnFiltered,
+  isColumnVisible,
+  isPinnedToolbarItem,
+  isSameCell,
+  jsonWriter,
+  matchesQuery,
+  moveColumnBefore,
+  moveGroupByBefore,
+  movesColumn,
+  movesGroupBy,
+  nextFocusForKey,
+  nextMenuIndex,
+  paginateRows,
+  paginationWindow,
+  parseFilterOperand,
+  resolveCell,
+  resolveColumnChooser,
+  resolveColumnConstraints,
+  resolveColumnFilterMenu,
+  resolveColumnHeaderText,
+  resolveColumnLabel,
+  resolveColumnWidths,
+  resolveColumns,
+  resolveCommands,
+  resolveDataColumns,
+  resolveDropBefore,
+  resolveExportWriters,
+  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,
+  toCsv,
+  toHtmlTable,
+  toJson,
+  toTsv,
+  toggleCellSelection,
+  toggleColumnSort,
+  toggleGroupExpansion,
+  toggleSelection,
+  toolbarEntries,
+  totalColumnWidth,
+  typeaheadIndex,
+  visibleFilterOptions,
+  visibleRange,
+  withGroupAggregates
+};
+//# sourceMappingURL=index.js.map