@gridkitjs/core 0.12.1 → 0.13.0

package/dist/index.js

@@ -91,6 +91,9 @@ function buildKeyShortcuts(capabilities) {
     // 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(" ");
@@ -2185,807 +2188,856 @@ function createCommandContext({
   };
 }
 
-// src/commands/builtInCommands.ts
-function isOn(context, areas) {
-  return areas.includes(context.target.area);
+// 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 columnOn(context, areas) {
-  return isOn(context, areas) ? context.column : null;
+function localeKey(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
 }
-function isGroupedBy(context, columnId) {
-  return context.state.groupBy.some((entry) => entry.columnId === columnId);
+function isNumericType(type) {
+  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
 }
-function sortableColumn(context) {
-  const column = columnOn(context, ["header"]);
-  return column !== null && (column.column.sortable ?? context.options.sortableColumns ?? false) ? column : null;
+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 groupableColumn(context) {
-  const column = columnOn(context, ["header"]);
-  return column !== null && (column.column.groupable ?? context.options.groupableColumns ?? false) && !isGroupedBy(context, column.id) ? column : null;
+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 groupedColumn(context) {
-  const column = columnOn(context, ["header", "group"]);
-  return column !== null && isGroupedBy(context, column.id) ? column : null;
+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 hideableColumn(context) {
-  const column = columnOn(context, ["header"]);
-  return column !== null && column.column.hideable !== false ? column : null;
+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 resizableColumn(context) {
-  const column = columnOn(context, ["header"]);
-  if (column === null) {
-    return null;
+function formatOther(value) {
+  if (typeof value === "function") {
+    return "(function)";
   }
-  return context.view.columns.find(
-    (entry) => entry.id === column.id && entry.resizable
-  ) ?? null;
+  if (typeof value === "object" && value !== null) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return Object.prototype.toString.call(value);
+    }
+  }
+  return String(value);
 }
-function resizableColumnIds(context) {
-  return context.view.columns.filter((entry) => entry.resizable).map((entry) => entry.id);
+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 isAnythingSelectable(selectable) {
-  return [selectable?.rows, selectable?.columns, selectable?.cells].some(
-    (mode) => mode !== void 0 && mode !== false
+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 columnName(context) {
-  return context.column === null ? "" : resolveColumnHeaderText(context.column.column);
+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 columnCommand({
-  id,
-  label,
-  icon,
-  find,
-  isEnabled,
-  isChecked,
-  execute
-}) {
-  function test(predicate) {
-    return (context) => {
-      const column = find(context);
-      return column !== null && predicate(column, context);
+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 {
-    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);
-      }
-    }
+    kind: "groupSummary",
+    level: entry.level,
+    cells: aggregateCells(entry.aggregates, context)
   };
 }
-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 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 builtInCommands() {
-  return [
-    sortCommand("asc"),
-    sortCommand("desc"),
-    // Cleared rather than set, so the change reports this column — the one
-    // the announcement names — rather than a key that moved up past it.
-    columnCommand({
-      id: "sort.clear",
-      label: ({ messages }) => messages.clearSort,
-      find: sortableColumn,
-      isEnabled: (column, { state }) => sortDirectionFor(state.columnSort, column.id) !== null,
-      execute: (column, { actions }) => {
-        actions.clearColumnSort(column.id);
-      }
-    }),
-    {
-      id: "sort.clearAll",
-      label: ({ messages }) => messages.clearAllSorting,
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
-      isEnabled: ({ state }) => state.columnSort.length > 0,
-      execute: ({ actions }) => {
-        actions.setColumnSort([]);
-      }
-    },
-    columnCommand({
-      id: "group.add",
-      label: (context) => context.messages.groupByColumn(columnName(context)),
-      icon: "group",
-      find: groupableColumn,
-      execute: (column, { actions }) => {
-        actions.toggleGroupBy(column.id);
-      }
-    }),
-    // Toggled rather than set, so the change reports this column — the one
-    // the announcement names — rather than the level that moved up.
-    columnCommand({
-      id: "group.remove",
-      label: (context) => context.messages.removeGroupBy(columnName(context)),
-      icon: "group",
-      find: groupedColumn,
-      execute: (column, { actions }) => {
-        actions.toggleGroupBy(column.id);
-      }
-    }),
-    {
-      id: "group.clearAll",
-      label: ({ messages }) => messages.ungroupAll,
-      isVisible: (context) => isOn(context, ["grid", "toolbar"]) && context.state.groupBy.length > 0,
-      execute: ({ actions }) => {
-        actions.setGroupBy([]);
-      }
-    },
-    {
-      id: "group.expandAll",
-      label: ({ messages }) => messages.expandAllGroups,
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "group", "cell"]) && context.state.groupBy.length > 0,
-      execute: ({ actions }) => {
-        actions.expandAllGroups();
-      }
-    },
-    {
-      id: "group.collapseAll",
-      label: ({ messages }) => messages.collapseAllGroups,
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "group", "cell"]) && context.state.groupBy.length > 0,
-      execute: ({ actions }) => {
-        actions.collapseAllGroups();
-      }
-    },
-    columnCommand({
-      id: "column.hide",
-      label: ({ messages }) => messages.hideColumn,
-      icon: "hide",
-      find: hideableColumn,
-      // The last column shown stays: a grid with none has no header left to
-      // bring one back from.
-      isEnabled: (column, { view }) => view.columns.some((entry) => entry.id !== column.id),
-      execute: (column, { actions }) => {
-        actions.hideColumns([column.id]);
-      }
-    }),
-    columnCommand({
-      id: "column.autoFit",
-      label: ({ messages }) => messages.autoFitColumn,
-      icon: "autoFit",
-      find: resizableColumn,
-      execute: (column, { host }) => {
-        host.autoFitColumns([column.id]);
-      }
-    }),
-    {
-      id: "column.autoFitAll",
-      label: ({ messages }) => messages.autoFitAllColumns,
-      icon: "autoFit",
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]) && resizableColumnIds(context).length > 0,
-      execute: (context) => {
-        context.host.autoFitColumns(resizableColumnIds(context));
-      }
-    },
-    // The target goes along, so the renderer opens the chooser where it was
-    // asked for: beside the toolbar button, below the header, or at the
-    // grid's corner for a call from nowhere in particular.
-    {
-      id: "column.choose",
-      label: ({ messages }) => messages.chooseColumns,
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
-      execute: ({ host, target }) => {
-        host.openPanel("columnChooser", target);
-      }
-    },
-    {
-      id: "selection.selectAllRows",
-      label: ({ messages }) => messages.selectAllRows,
-      isVisible: (context) => isOn(context, ["grid", "cell"]) && context.options.selectable?.rows === "multiple",
-      isEnabled: ({ view }) => view.displayDataRows.length > 0,
-      execute: ({ actions }) => {
-        actions.selectAllRows();
-      }
-    },
-    {
-      id: "selection.clear",
-      label: ({ messages }) => messages.clearSelection,
-      isVisible: (context) => isOn(context, ["grid", "cell", "header"]) && isAnythingSelectable(context.options.selectable),
-      isEnabled: ({ state }) => state.rowSelection.length > 0 || state.columnSelection.length > 0 || state.cellSelection !== null,
-      execute: ({ actions }) => {
-        actions.clearSelection();
-      }
-    },
-    {
-      id: "filter.clearAll",
-      label: ({ messages }) => messages.clearFilters,
-      isVisible: (context) => isOn(context, ["grid", "toolbar", "header"]),
-      isEnabled: ({ state }) => state.filter.length > 0,
-      execute: ({ actions }) => {
-        actions.setFilter([]);
-      }
-    }
-  ];
+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/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])
+// src/export/htmlTable.ts
+var ENTITIES = {
+  "&": "&",
+  "<": "&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
   );
-  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);
+  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>`;
   }
-  return registry;
 }
-function runCommand(command, context) {
-  if (!isCommandVisible(command, context) || !isCommandEnabled(command, context)) {
-    return false;
-  }
-  command.execute(context);
-  return true;
+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/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);
+// src/export/records.ts
+function rawText(value) {
+  if (value === null) {
+    return "";
   }
-  if (reported.has(id)) {
-    return;
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "" : value.toISOString();
   }
-  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;
+  return String(value);
 }
-function commandItem(command, context) {
-  if (!isCommandVisible(command, context)) {
-    return null;
-  }
+function cellField(cell, values) {
   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)
+    text: values === "raw" ? rawText(cell.value) : cell.text,
+    isNumber: typeof cell.value === "number"
   };
 }
-function inlineItem(entry, context) {
-  if (evaluate(entry.hidden ?? false, context)) {
+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;
   }
-  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;
-    }
+    text: toTsv(table),
+    html: toHtmlTable(table),
+    count: unit === "columns" ? table.columns.length : table.rows.length,
+    unit
   };
 }
-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();
+function cellContent(source, rowId, columnId) {
+  if (!hasRow(source, rowId) || !hasColumn(source, columnId)) {
+    return null;
   }
-  return collapsed;
+  return contentOf(
+    withRows(source, [rowId]),
+    { scope: "selection", columns: [columnId], header: false },
+    "cells"
+  );
 }
-function resolveMenuEntry(entry, index, options) {
-  const { commands, context } = options;
-  if (entry === "separator") {
-    return { type: "separator", key: `separator-${String(index)}` };
+function rowContent(source, rowId) {
+  if (!hasRow(source, rowId)) {
+    return null;
   }
-  if (typeof entry === "string") {
-    const command = commands.get(entry);
-    if (command === void 0) {
-      reportUnknownId(commands, entry);
+  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;
-    }
-    return commandItem(command, context);
+    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);
   }
-  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 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);
+  }
 }
-function resolveMenu(entries, options) {
-  return collapseSeparators(
-    entries.map((entry, index) => resolveMenuEntry(entry, index, options)).filter((entry) => entry !== null)
+
+// 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/menu/contextMenu.ts
-var defaultContextMenu = {
-  header: [
-    "sort.ascending",
-    "sort.descending",
-    "sort.clear",
-    "separator",
-    "group.add",
-    "group.remove",
-    "separator",
-    "column.autoFit",
-    "column.autoFitAll",
-    "separator",
-    "column.hide",
-    "column.choose"
+// 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"
   ],
-  cell: [
-    "selection.selectAllRows",
-    "selection.clear",
-    "separator",
-    "group.expandAll",
-    "group.collapseAll"
+  number: [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "isEmpty",
+    "isNotEmpty"
   ],
-  group: ["group.expandAll", "group.collapseAll", "separator", "group.remove"],
-  body: []
+  date: ["eq", "ne", "lt", "gt", "between", "isEmpty", "isNotEmpty"],
+  boolean: ["eq", "isEmpty", "isNotEmpty"]
 };
-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;
+var instantOperators = [
+  "lt",
+  "gt",
+  "between",
+  "isEmpty",
+  "isNotEmpty"
+];
+function defaultFilterOperators(type) {
+  return type === "dateTime" || type === "time" ? instantOperators : familyOperators[filterOperatorFamily(type)];
 }
-function entriesFor(given, request) {
-  if (given === void 0) {
-    return request.defaults;
+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;
   }
-  return typeof given === "function" ? given(request) ?? [] : given;
 }
-function contextMenuEntries(contextMenu, context) {
-  if (contextMenu === void 0 || contextMenu === false) {
-    return [];
+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 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 [];
+  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;
 }
-
-// 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 parseBoolean(text) {
+  if (text === "true") {
+    return true;
   }
+  return text === "false" ? false : void 0;
 }
-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;
-    }
+function parseFilterOperand(text, type) {
+  if (text === "") {
+    return void 0;
   }
-  return -1;
-}
-function typeaheadIndex(labels, from, query) {
-  const typed = query.toLowerCase();
-  const firstCodePoint = typed.codePointAt(0);
-  if (firstCodePoint === void 0) {
-    return -1;
+  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());
   }
-  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;
-    }
+}
+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;
   }
-  return -1;
+  const second = `${minute}:${pad(seconds)}`;
+  return milliseconds === 0 ? second : `${second}.${pad(milliseconds, 3)}`;
 }
-
-// src/toolbar/options.ts
-var defaultToolbar = ["search", "spacer", "filter.clearAll", "column.choose"];
-function toolbarEntries(toolbar) {
-  if (toolbar === void 0 || toolbar === false) {
-    return [];
+function formatFilterOperand(value, type) {
+  if (value === null || value === void 0) {
+    return "";
   }
-  return (toolbar === true ? void 0 : toolbar.items) ?? defaultToolbar;
+  const date = filterOperatorFamily(type) === "date" ? toDate(value) : void 0;
+  if (date === void 0) {
+    return String(value);
+  }
+  return type === "date" ? dayInput(date) : momentInput(date);
 }
 
-// src/toolbar/resolveToolbar.ts
-function isSpacer(entry) {
-  return entry.type === "spacer";
+// src/filterMenu/options.ts
+var DEFAULT_FILTER_VALUE_LIMIT = 1e4;
+function conditionOperators(operators) {
+  return operators.includes("in") ? operators.filter((operator) => operator !== "in") : operators;
 }
-function resolveToolbar(entries, options) {
-  const { commands, contextFor } = options;
-  function resolveEntry(entry, index) {
-    if (entry === "search") {
-      return { type: "search", key: "search" };
-    }
-    if (entry === "spacer") {
-      return { type: "spacer", key: `spacer-${String(index)}` };
-    }
-    if (typeof entry === "object" && entry.type === "custom") {
-      return { type: "custom", id: entry.id, key: entry.id };
-    }
-    if (entry === "separator") {
-      return { type: "separator", key: `separator-${String(index)}` };
-    }
-    const resolved = resolveMenuEntry(entry, index, {
-      commands,
-      context: contextFor({
-        area: "toolbar",
-        itemId: typeof entry === "string" ? entry : entry.id
-      })
-    });
-    if (resolved === null || resolved.type === "separator") {
-      return resolved;
-    }
-    if (resolved.type === "submenu") {
-      return { ...resolved, type: "menu", key: resolved.id };
-    }
-    const { checked, ...item } = resolved;
-    return { ...item, type: "button", key: item.id, pressed: checked };
+function resolveColumnFilterMenu(options, column) {
+  if (!(column.filterable ?? options.filterableColumns ?? false)) {
+    return null;
   }
-  return collapseSeparators(
-    entries.map(resolveEntry).filter((entry) => entry !== null),
-    isSpacer
-  );
+  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/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;
+// src/messages.ts
+function columnCount(count, change) {
+  return count === 1 ? `1 column ${change}` : `${String(count)} columns ${change}`;
 }
-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, options?.boundaryCount ?? 1);
-  const siblingCount = Math.max(0, options?.siblingCount ?? 1);
-  const current = Math.min(Math.max(currentPage, 1), pageCount);
-  const pages = /* @__PURE__ */ new Set();
-  for (let page = 1; page <= Math.min(boundaryCount, pageCount); page++) {
-    pages.add(page);
-  }
-  for (let page = Math.max(pageCount - boundaryCount + 1, 1); page <= pageCount; page++) {
-    pages.add(page);
-  }
-  for (let page = Math.max(current - siblingCount, 1); page <= Math.min(current + siblingCount, pageCount); page++) {
-    pages.add(page);
-  }
-  const sorted = Array.from(pages).sort((a, b) => a - b);
-  const entries = [];
-  let previous;
-  for (const page of sorted) {
-    if (previous !== void 0) {
-      if (page - previous === 2) {
-        entries.push(previous + 1);
-      } else if (page - previous > 2) {
-        entries.push("ellipsis");
-      }
-    }
-    entries.push(page);
-    previous = page;
-  }
-  return entries;
-}
-
-// src/util/columnChooser.ts
-function isHideable(column) {
-  return column.column.hideable !== false;
-}
-function matchesSearch(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 }) => matchesSearch(label, search));
-  const entries = matched.map(
-    ({ column, label, visible }) => ({
-      columnId: column.id,
-      label,
-      visible,
-      disabled: visible && (!isHideable(column) || shownCount === 1)
-    })
-  );
-  const covered = matched.filter(({ column }) => isHideable(column));
-  const selectAll2 = selectAllStateOf(covered.map(({ visible }) => visible));
-  return {
-    entries,
-    selectAll: selectAll2,
-    toggleAll: toggleAllOf(covered, selectAll2, shownCount)
-  };
-}
-function toggleAllOf(covered, selectAll2, shownCount) {
-  const show = selectAll2 !== "checked";
-  const changing = covered.filter(({ visible }) => visible !== show).map(({ column }) => column.id);
-  const columnIds = !show && changing.length === shownCount ? changing.slice(1) : changing;
-  return columnIds.length === 0 ? null : { visible: show, columnIds };
-}
-
-// src/messages.ts
-function columnCount(count, change) {
-  return count === 1 ? `1 column ${change}` : `${String(count)} columns ${change}`;
-}
-function searchResults(count) {
-  if (count === 0) {
-    return "No rows found";
-  }
-  return count === 1 ? "1 row found" : `${String(count)} rows found`;
+function searchResults(count) {
+  if (count === 0) {
+    return "No rows found";
+  }
+  return count === 1 ? "1 row found" : `${String(count)} rows found`;
 }
 function selectedCount(count, target) {
   const noun = target === "rows" ? "row" : "column";
@@ -2994,6 +3046,52 @@ function selectedCount(count, target) {
   }
   return count === 1 ? `1 ${noun} selected` : `${String(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(total) {
+  return total === 1 ? "Type to search 1 value" : `Type to search ${String(total)} values`;
+}
+function filterResults(shown, total) {
+  return `${String(shown)} of ${String(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(count, unit) {
+  return count === 1 ? `1 ${unit.slice(0, -1)} copied` : `${String(count)} ${unit} copied`;
+}
 var defaultMessages = {
   pagerLabel: "Pagination",
   previousPage: "Previous",
@@ -3056,152 +3154,54 @@ var defaultMessages = {
   columnChooserLabel: "Columns",
   columnChooserSearchLabel: "Search columns",
   showAllColumns: "Show all",
-  noMatchingColumns: "No matching columns"
+  noMatchingColumns: "No matching columns",
+  filterOperatorLabel,
+  filterBlanks: "(Blanks)",
+  filterSearchFirst,
+  filterMoreValues: (count) => `${String(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,
+  filterConditionLabel: (position) => `Condition ${String(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,
+  copyFailed: "Copy failed",
+  print: "Print"
 };
 function resolveMessages(messages) {
   return messages === void 0 ? defaultMessages : { ...defaultMessages, ...messages };
 }
 
-// src/util/format.ts
-var DATE_FIELDS = {
-  year: "numeric",
-  month: "numeric",
-  day: "numeric"
-};
-var TIME_FIELDS = {
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric"
-};
-var DATE_TIME_FIELDS = {
-  ...DATE_FIELDS,
-  ...TIME_FIELDS
-};
-var CURRENCY_DIGITS = {
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2
-};
-var NO_FORMAT = {};
-var formatters = /* @__PURE__ */ new WeakMap();
-function cached(format, key, create) {
-  const owner = format ?? NO_FORMAT;
-  let byKey = formatters.get(owner);
-  if (byKey === void 0) {
-    byKey = /* @__PURE__ */ new Map();
-    formatters.set(owner, byKey);
-  }
-  const existing = byKey.get(key);
-  if (existing !== void 0) {
-    return existing;
-  }
-  const formatter = create();
-  byKey.set(key, formatter);
-  return formatter;
-}
-function localeKey(locale) {
-  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
-}
-function isNumericType(type) {
-  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
-}
-function numberOptions(type, format) {
-  switch (type) {
-    case "currency":
-      return format?.currency === void 0 ? { ...CURRENCY_DIGITS, ...format } : { style: "currency", ...format };
-    case "percent":
-      return { style: "percent", ...format };
-    default:
-      return 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);
-}
-
 // src/util/filterEditor.ts
 function touchesColumn(entry, columnId) {
   return "combinator" in entry ? entry.entries.some((nested) => touchesColumn(nested, columnId)) : entry.columnId === columnId;
@@ -3234,217 +3234,1321 @@ function conditionsShape(touching, columnId) {
   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" };
+  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);
+  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, options?.boundaryCount ?? 1);
+  const siblingCount = Math.max(0, options?.siblingCount ?? 1);
+  const current = Math.min(Math.max(currentPage, 1), pageCount);
+  const pages = /* @__PURE__ */ new Set();
+  for (let page = 1; page <= Math.min(boundaryCount, pageCount); page++) {
+    pages.add(page);
+  }
+  for (let page = Math.max(pageCount - boundaryCount + 1, 1); page <= pageCount; page++) {
+    pages.add(page);
+  }
+  for (let page = Math.max(current - siblingCount, 1); page <= Math.min(current + siblingCount, pageCount); page++) {
+    pages.add(page);
+  }
+  const sorted = Array.from(pages).sort((a, b) => a - b);
+  const entries = [];
+  let previous;
+  for (const page of sorted) {
+    if (previous !== void 0) {
+      if (page - previous === 2) {
+        entries.push(previous + 1);
+      } else if (page - previous > 2) {
+        entries.push("ellipsis");
+      }
+    }
+    entries.push(page);
+    previous = page;
   }
-  return (touching.length === 1 ? valuesShape(only, columnId) : void 0) ?? conditionsShape(touching, columnId) ?? { kind: "custom" };
+  return entries;
 }
-function isOfferable(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date;
+
+// src/util/columnChooser.ts
+function isHideable(column) {
+  return column.column.hideable !== false;
 }
 function matchesSearch2(label, search) {
   return label.toLowerCase().includes(search.toLowerCase());
 }
-function columnValueOptions(rows, dataColumns, filter, columnId, query = {}) {
-  const column = dataColumns.find((entry) => entry.id === columnId)?.column;
-  if (column === void 0) {
-    return { options: [], total: 0, truncated: false, blanks: 0 };
+function selectAllStateOf(states) {
+  if (states.length > 0 && states.every(Boolean)) {
+    return "checked";
   }
-  const keep = compileFilter(
-    filter.filter((entry) => !touchesColumn(entry, columnId)),
-    dataColumns
+  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 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);
-  const options = [...buckets.values()].sort((a, b) => compareValues(a.value, b.value, column.type)).map(({ value, row, count }) => ({
-    value,
-    label: formatCellValue(value, column, locale, row, messages),
-    count
-  })).filter((option) => matchesSearch2(option.label, search));
-  const shown = limit === void 0 ? options : options.slice(0, limit);
+  const covered = matched.filter(({ column }) => isHideable(column));
+  const selectAll2 = selectAllStateOf(covered.map(({ visible }) => visible));
   return {
-    options: shown,
-    total: options.length,
-    truncated: shown.length < options.length,
-    blanks,
-    columnType: column.type
+    entries,
+    selectAll: selectAll2,
+    toggleAll: toggleAllOf(covered, selectAll2, shownCount)
   };
 }
-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 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 };
 }
-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;
+
+// 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 visibleFilterOptions(draft) {
-  return draft.search === "" ? draft.options : draft.options.filter(
-    (option) => matchesSearch2(option.label, draft.search)
+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 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";
+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] };
+    }
   }
-  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);
+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 {
-      checked.delete(key);
+      conditions.push(condition);
     }
   }
-  return {
-    ...draft,
-    mode: "values",
-    checked,
-    includeBlanks: selectAllCoversBlanks(draft) ? check : draft.includeBlanks
-  };
+  return { conditions, invalid };
 }
-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: []
-      };
-  }
+
+// 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 checksEverything(draft) {
-  return draft.options.every(
-    (option) => draft.checked.has(keyOf2(draft, option.value))
-  ) && (draft.includeBlanks || draft.blanks === 0);
+function sameEntries(a, b) {
+  return a.length === b.length && a.every((entry, index) => entry === b[index]);
 }
-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" }]
+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;
     }
-  ] : [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];
+
+// 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
+    });
   }
-  const kept = current.filter((entry) => !touchesColumn(entry, columnId));
-  return [...kept.slice(0, first), ...replacement, ...kept.slice(first)];
+  return { items, needsSearch: false, hiddenCount, total };
 }
 
 // src/util/virtualization.ts
@@ -3487,8 +4591,15 @@ function visibleRange(heights, estimatedHeight, scrollTop, viewportHeight, overs
     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,
@@ -3498,7 +4609,9 @@ export {
   applyColumnVisibility,
   applySelectionIntent,
   beginColumnResize,
+  buildExportTable,
   buildKeyShortcuts,
+  buildPrintDocument,
   builtInCommands,
   clampColumnWidth,
   clampFocus,
@@ -3508,34 +4621,50 @@ export {
   columnValueOptions,
   compareValues,
   computeAggregates,
+  conditionRowsFrom,
+  conditionsFromRows,
   contextMenuEntries,
+  copyContent,
+  createColumnValueOptionsCache,
   createCommandContext,
   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,
@@ -3545,9 +4674,11 @@ export {
   nextMenuIndex,
   paginateRows,
   paginationWindow,
+  parseFilterOperand,
   resolveCell,
   resolveColumnChooser,
   resolveColumnConstraints,
+  resolveColumnFilterMenu,
   resolveColumnHeaderText,
   resolveColumnLabel,
   resolveColumnWidths,
@@ -3555,6 +4686,7 @@ export {
   resolveCommands,
   resolveDataColumns,
   resolveDropBefore,
+  resolveExportWriters,
   resolveGridView,
   resolveKeyboardDropTarget,
   resolveMenu,
@@ -3580,6 +4712,10 @@ export {
   sortPriorityFor,
   sortRows,
   splitToolbarItems,
+  toCsv,
+  toHtmlTable,
+  toJson,
+  toTsv,
   toggleCellSelection,
   toggleColumnSort,
   toggleGroupExpansion,