@gridkitjs/core 0.12.1 → 0.14.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,6 +2188,1304 @@ function createCommandContext({
   };
 }
 
+// src/util/format.ts
+var DATE_FIELDS = {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric"
+};
+var TIME_FIELDS = {
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+};
+var DATE_TIME_FIELDS = {
+  ...DATE_FIELDS,
+  ...TIME_FIELDS
+};
+var CURRENCY_DIGITS = {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+};
+var NO_FORMAT = {};
+var formatters = /* @__PURE__ */ new WeakMap();
+function cached(format, key, create) {
+  const owner = format ?? NO_FORMAT;
+  let byKey = formatters.get(owner);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    formatters.set(owner, byKey);
+  }
+  const existing = byKey.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const formatter = create();
+  byKey.set(key, formatter);
+  return formatter;
+}
+function localeKey(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
+}
+function isNumericType(type) {
+  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
+}
+function numberOptions(type, format) {
+  switch (type) {
+    case "currency":
+      return format?.currency === void 0 ? { ...CURRENCY_DIGITS, ...format } : { style: "currency", ...format };
+    case "percent":
+      return { style: "percent", ...format };
+    default:
+      return format ?? {};
+  }
+}
+function dateOptions(type, format) {
+  if (format !== void 0) {
+    return format;
+  }
+  if (type === "date") return DATE_FIELDS;
+  if (type === "time") return TIME_FIELDS;
+  return DATE_TIME_FIELDS;
+}
+function formatNumber(value, type, format, locale) {
+  const formatter = cached(
+    format,
+    `number|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.NumberFormat(
+      locale,
+      numberOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatDate(value, type, format, locale) {
+  if (Number.isNaN(value.getTime())) {
+    return String(value);
+  }
+  const formatter = cached(
+    format,
+    `date|${type ?? ""}|${localeKey(locale)}`,
+    () => new Intl.DateTimeFormat(
+      locale,
+      dateOptions(type, format)
+    )
+  );
+  return formatter.format(value);
+}
+function formatOther(value) {
+  if (typeof value === "function") {
+    return "(function)";
+  }
+  if (typeof value === "object" && value !== null) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return Object.prototype.toString.call(value);
+    }
+  }
+  return String(value);
+}
+function formatCellValue(value, column, locale, row, messages) {
+  if (column.valueFormatter !== void 0) {
+    return column.valueFormatter(value, row);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "boolean" && messages !== void 0) {
+    return value ? messages.booleanTrue : messages.booleanFalse;
+  }
+  const { type, format } = column;
+  const formatted = format !== void 0 || locale !== void 0;
+  if (value instanceof Date) {
+    return formatted ? formatDate(value, type, format, locale) : value.toLocaleString();
+  }
+  if (formatted && (typeof value === "number" || typeof value === "bigint") && isNumericType(type)) {
+    return formatNumber(value, type, format, locale);
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return formatOther(value);
+}
+function aggregateFormatColumn(value, spec, column) {
+  const plain = {
+    field: spec.columnId,
+    type: "number"
+  };
+  if (column === void 0 || spec.fn === "count" || spec.fn === "countDistinct") {
+    return plain;
+  }
+  const numeric = typeof value === "number" || typeof value === "bigint";
+  return column.valueFormatter === void 0 && numeric && !isNumericType(column.type) ? plain : column;
+}
+function formatAggregateValue(value, spec, column, locale) {
+  const target = aggregateFormatColumn(value, spec, column);
+  if (typeof value === "number" && target.valueFormatter === void 0 && target.format === void 0 && locale === void 0) {
+    return value.toLocaleString();
+  }
+  return formatCellValue(value, target, locale);
+}
+function formatGroupValue(value, column, locale, messages) {
+  return value === null || value === void 0 ? messages.blankGroupValue : formatCellValue(value, column, locale, void 0, messages);
+}
+
+// src/export/buildExportTable.ts
+var EMPTY_CELL = { value: null, text: "" };
+function isDataRow(entry) {
+  return !("kind" in entry);
+}
+function pickColumns(view, selection) {
+  let picked;
+  if (selection === "visible") {
+    picked = view.columns;
+  } else if (selection === "all") {
+    picked = view.dataColumns;
+  } else {
+    const byId = new Map(view.dataColumns.map((entry) => [entry.id, entry]));
+    picked = [...new Set(selection)].flatMap((id) => byId.get(id) ?? []);
+  }
+  return picked.filter((entry) => entry.column.exportable !== false);
+}
+function describeColumns(picked, source) {
+  const shown = new Map(source.view.columns.map((entry) => [entry.id, entry]));
+  const resolved = resolveColumnWidths(
+    picked.map((entry) => entry.column),
+    source.state.columnSizing,
+    { sizes: source.options.columnSizeDefaults }
+  );
+  return resolved.map((entry) => {
+    const rendered = shown.get(entry.id) ?? entry;
+    return {
+      id: rendered.id,
+      header: resolveColumnHeaderText(rendered.column),
+      type: rendered.column.type ?? "string",
+      format: rendered.column.format,
+      alignment: rendered.alignment,
+      width: rendered.width
+    };
+  });
+}
+function scopedRows(source, scope) {
+  const { view, state } = source;
+  switch (scope) {
+    case "all":
+      return view.rows;
+    case "page":
+      return view.displayDataRows;
+    case "selection": {
+      const selected = new Set(state.rowSelection);
+      return view.rows.filter((entry) => selected.has(entry.rowId));
+    }
+  }
+}
+function typedValue(value, text) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date ? value : text;
+}
+function dataCell(row, column, context) {
+  const raw = accessDotted(row, column.field);
+  const text = formatCellValue(
+    raw,
+    column,
+    context.locale,
+    row,
+    context.messages
+  );
+  return {
+    value: column.exportValue === void 0 ? typedValue(raw, text) : column.exportValue(raw, row),
+    text
+  };
+}
+function aggregateCell(results, specs, column, locale) {
+  const parts = specs.flatMap((spec) => {
+    const value = results.get(spec.id ?? spec.columnId);
+    return value === null || value === void 0 ? [] : [{ value, text: formatAggregateValue(value, spec, column, locale) }];
+  });
+  const [only] = parts;
+  if (only === void 0) {
+    return EMPTY_CELL;
+  }
+  if (parts.length === 1) {
+    return { value: typedValue(only.value, only.text), text: only.text };
+  }
+  const text = parts.map((part) => part.text).join(", ");
+  return { value: text, text };
+}
+function aggregateCells(results, context) {
+  return context.columns.map((entry) => {
+    const specs = context.specsByColumn.get(entry.id);
+    return specs === void 0 ? EMPTY_CELL : aggregateCell(results, specs, entry.column, context.locale);
+  });
+}
+function groupLabel(entry, source) {
+  const column = source.view.dataColumns.find(
+    (candidate) => candidate.id === entry.columnId
+  )?.column ?? { field: entry.columnId };
+  const value = formatGroupValue(
+    entry.value,
+    column,
+    source.options.locale,
+    source.messages
+  );
+  return `${resolveColumnHeaderText(column)}: ${value}`;
+}
+function toExportRow(entry, source, context) {
+  if (isDataRow(entry)) {
+    return {
+      kind: "data",
+      rowId: entry.rowId,
+      cells: context.columns.map(
+        (column) => dataCell(entry.row, column.column, context)
+      )
+    };
+  }
+  if (entry.kind === "group") {
+    return {
+      kind: "group",
+      level: entry.level,
+      groupId: entry.groupId,
+      label: groupLabel(entry, source),
+      count: entry.count,
+      cells: context.display === "inline" ? aggregateCells(entry.aggregates, context) : context.columns.map(() => EMPTY_CELL)
+    };
+  }
+  return {
+    kind: "groupSummary",
+    level: entry.level,
+    cells: aggregateCells(entry.aggregates, context)
+  };
+}
+function specsByColumnOf(specs) {
+  const byColumn = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const owned = byColumn.get(spec.columnId);
+    if (owned === void 0) {
+      byColumn.set(spec.columnId, [spec]);
+    } else {
+      owned.push(spec);
+    }
+  }
+  return byColumn;
+}
+function buildExportTable(source, options = {}) {
+  const { view, state } = source;
+  const specs = options.includeAggregates ?? true ? source.options.aggregates ?? [] : [];
+  const columns = pickColumns(view, options.columns ?? "visible");
+  const context = {
+    columns,
+    specsByColumn: specsByColumnOf(specs),
+    display: source.options.groupAggregateDisplay ?? "inline",
+    locale: source.options.locale,
+    messages: source.messages
+  };
+  const rows = scopedRows(source, options.scope ?? "all");
+  const grouped = groupRows(rows, state.groupBy, [], view.dataColumns);
+  const displayRows = options.includeGroups ?? true ? withGroupAggregates(
+    grouped,
+    rows,
+    state.groupBy,
+    specs,
+    view.dataColumns,
+    context.display
+  ) : grouped.filter(isDataRow);
+  let footer = null;
+  if (specs.length > 0) {
+    const totals = rows === view.rows ? view.grandTotal : computeAggregates(
+      rows.map((entry) => entry.row),
+      specs,
+      view.dataColumns
+    );
+    footer = { kind: "total", cells: aggregateCells(totals, context) };
+  }
+  return {
+    columns: describeColumns(columns, source),
+    header: options.includeHeader ?? true,
+    rows: displayRows.map((entry) => toExportRow(entry, source, context)),
+    footer
+  };
+}
+
+// src/export/htmlTable.ts
+var ENTITIES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(text) {
+  return text.replace(/[&<>"']/g, (char) => ENTITIES[char] ?? char);
+}
+function cellHtml(tag, text, column) {
+  const alignment = column?.alignment ?? "left";
+  const style = alignment === "left" ? "" : ` style="text-align:${alignment}"`;
+  return `<${tag}${style}>${escapeHtml(text)}</${tag}>`;
+}
+function cellsHtml(cells, columns) {
+  return cells.map((cell, index) => cellHtml("td", cell.text, columns[index])).join("");
+}
+function groupRowHtml(row, columns) {
+  const firstAggregate = row.cells.findIndex((cell) => cell.text !== "");
+  const span = Math.max(
+    1,
+    firstAggregate === -1 ? row.cells.length : firstAggregate
+  );
+  const colspan = span > 1 ? ` colspan="${String(span)}"` : "";
+  const label = `<td${colspan}>${escapeHtml(row.label)}</td>`;
+  const aggregates = row.cells.slice(span).map((cell, index) => cellHtml("td", cell.text, columns[span + index])).join("");
+  return `<tr class="export-group" data-level="${String(row.level)}">${label}${aggregates}</tr>`;
+}
+function rowHtml(row, columns) {
+  switch (row.kind) {
+    case "data":
+      return `<tr>${cellsHtml(row.cells, columns)}</tr>`;
+    case "group":
+      return groupRowHtml(row, columns);
+    case "groupSummary":
+      return `<tr class="export-group-summary" data-level="${String(row.level)}">${cellsHtml(row.cells, columns)}</tr>`;
+  }
+}
+function toHtmlTable(table, options = {}) {
+  const { columns } = table;
+  const caption = options.caption === void 0 ? "" : `<caption>${escapeHtml(options.caption)}</caption>`;
+  const head = table.header ? `<thead><tr>${columns.map((column) => cellHtml("th", column.header, column)).join("")}</tr></thead>` : "";
+  const body = `<tbody>${table.rows.map((row) => rowHtml(row, columns)).join("")}</tbody>`;
+  const foot = table.footer === null ? "" : `<tfoot><tr>${cellsHtml(table.footer.cells, columns)}</tr></tfoot>`;
+  return `<table class="gridkit-export-table">${caption}${head}${body}${foot}</table>`;
+}
+
+// src/export/records.ts
+function rawText(value) {
+  if (value === null) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  }
+  return String(value);
+}
+function cellField(cell, values) {
+  return {
+    text: values === "raw" ? rawText(cell.value) : cell.text,
+    isNumber: typeof cell.value === "number"
+  };
+}
+function textField(text) {
+  return { text, isNumber: false };
+}
+function textRecords(table, values) {
+  const records = [];
+  if (table.header) {
+    records.push(table.columns.map((column) => textField(column.header)));
+  }
+  for (const row of table.rows) {
+    records.push(
+      row.cells.map(
+        (cell, index) => row.kind === "group" && index === 0 ? textField(row.label) : cellField(cell, values)
+      )
+    );
+  }
+  if (table.footer !== null) {
+    records.push(table.footer.cells.map((cell) => cellField(cell, values)));
+  }
+  return records;
+}
+
+// src/export/tsv.ts
+var SEPARATORS = /\r\n|[\t\r\n]/g;
+function toTsv(table, options = {}) {
+  return textRecords(table, options.values ?? "text").map(
+    (record) => record.map((field) => field.text.replace(SEPARATORS, " ")).join("	")
+  ).join("\n");
+}
+
+// src/export/copy.ts
+function isCopyable(column) {
+  return column.column.exportable !== false;
+}
+function hasRow(source, rowId) {
+  return source.view.rows.some((entry) => entry.rowId === rowId);
+}
+function hasColumn(source, columnId) {
+  return source.view.columns.some(
+    (entry) => entry.id === columnId && isCopyable(entry)
+  );
+}
+function selectionCopy(source) {
+  const { state, view } = source;
+  const selectedRows = new Set(state.rowSelection);
+  const count = view.rows.filter(
+    (entry) => selectedRows.has(entry.rowId)
+  ).length;
+  if (count > 0) {
+    return { kind: "rows", count };
+  }
+  const selectedColumns = new Set(state.columnSelection);
+  const columnIds = view.columns.filter((entry) => selectedColumns.has(entry.id) && isCopyable(entry)).map((entry) => entry.id);
+  if (columnIds.length > 0 && view.rows.length > 0) {
+    return { kind: "columns", columnIds };
+  }
+  const cell = state.cellSelection;
+  if (cell !== null && hasRow(source, cell.rowId) && hasColumn(source, cell.columnId)) {
+    return { kind: "cell", rowId: cell.rowId, columnId: cell.columnId };
+  }
+  return null;
+}
+function canCopySelection(source) {
+  return selectionCopy(source) !== null;
+}
+function withRows(source, rowIds) {
+  return { ...source, state: { ...source.state, rowSelection: rowIds } };
+}
+function contentOf(source, { scope, columns, header }, unit) {
+  const table = buildExportTable(source, {
+    scope,
+    columns: columns ?? "visible",
+    includeHeader: header,
+    includeGroups: false,
+    includeAggregates: false
+  });
+  if (table.columns.length === 0 || table.rows.length === 0) {
+    return null;
+  }
+  return {
+    text: toTsv(table),
+    html: toHtmlTable(table),
+    count: unit === "columns" ? table.columns.length : table.rows.length,
+    unit
+  };
+}
+function cellContent(source, rowId, columnId) {
+  if (!hasRow(source, rowId) || !hasColumn(source, columnId)) {
+    return null;
+  }
+  return contentOf(
+    withRows(source, [rowId]),
+    { scope: "selection", columns: [columnId], header: false },
+    "cells"
+  );
+}
+function rowContent(source, rowId) {
+  if (!hasRow(source, rowId)) {
+    return null;
+  }
+  return contentOf(
+    withRows(source, [rowId]),
+    { scope: "selection", header: false },
+    "rows"
+  );
+}
+function selectionContent(source) {
+  const selection = selectionCopy(source);
+  switch (selection?.kind) {
+    case void 0:
+      return null;
+    case "rows":
+      return contentOf(
+        source,
+        { scope: "selection", header: selection.count > 1 },
+        "rows"
+      );
+    case "columns":
+      return contentOf(
+        source,
+        { scope: "all", columns: selection.columnIds, header: true },
+        "columns"
+      );
+    case "cell":
+      return cellContent(source, selection.rowId, selection.columnId);
+  }
+}
+function copyContent(source, request) {
+  switch (request.kind) {
+    case "cell":
+      return cellContent(source, request.rowId, request.columnId);
+    case "row":
+      return rowContent(source, request.rowId);
+    case "selection":
+      return selectionContent(source);
+  }
+}
+
+// src/export/exportFile.ts
+function withExtension(fileName, extension) {
+  const suffix = `.${extension}`;
+  return fileName.toLowerCase().endsWith(suffix.toLowerCase()) ? fileName : fileName + suffix;
+}
+function writerFor(format, writers) {
+  if (typeof format !== "string") {
+    return format;
+  }
+  const writer = writers.get(format);
+  if (writer === void 0) {
+    reportError(
+      `there is no export writer for \`${format}\` \u2014 register one through \`exportWriters\`.`
+    );
+    return null;
+  }
+  return writer;
+}
+function fileNameFor(options, writer) {
+  const { fileName = "export" } = options;
+  const name = typeof fileName === "function" ? fileName(writer.format) : fileName;
+  return withExtension(name, writer.fileExtension);
+}
+function exportFile(source, format, options, writers) {
+  const writer = writerFor(format, writers);
+  if (writer === null) {
+    return null;
+  }
+  const content = writer.write(buildExportTable(source, options), {
+    locale: source.options.locale,
+    messages: source.messages,
+    options
+  });
+  const fileName = fileNameFor(options, writer);
+  const { mimeType } = writer;
+  return content instanceof Promise ? content.then((resolved) => ({ fileName, mimeType, content: resolved })) : { fileName, mimeType, content };
+}
+
+// src/export/print.ts
+var PORTRAIT_COLUMN_LIMIT = 6;
+function resolveOrientation(table, options) {
+  return options.orientation ?? (table.columns.length > PORTRAIT_COLUMN_LIMIT ? "landscape" : "portrait");
+}
+function timestampText(timestamp, locale) {
+  const date = timestamp === true ? /* @__PURE__ */ new Date() : timestamp;
+  return new Intl.DateTimeFormat(locale, {
+    dateStyle: "medium",
+    timeStyle: "short"
+  }).format(date);
+}
+function line(tag, className, text) {
+  return text === void 0 || text === "" ? "" : `<${tag} class="${className}">${escapeHtml(text)}</${tag}>`;
+}
+function headerHtml(options) {
+  const { timestamp = false } = options;
+  const lines = line("h1", "print-title", options.title) + line("p", "print-subtitle", options.subtitle) + (timestamp === false ? "" : line("p", "print-timestamp", timestampText(timestamp, options.locale)));
+  return lines === "" ? "" : `<header class="gridkit-print-header">${lines}</header>`;
+}
+function buildPrintDocument(table, options = {}) {
+  const footer = line("footer", "gridkit-print-footer", options.footer);
+  return {
+    title: options.title ?? "",
+    bodyHtml: `${headerHtml(options)}${toHtmlTable(table)}${footer}`,
+    page: {
+      paperSize: options.paperSize ?? "A4",
+      orientation: resolveOrientation(table, options),
+      pageNumbers: options.pageNumbers ?? true,
+      fitToWidth: options.fitToWidth ?? false
+    }
+  };
+}
+function exportPrintDocument(source, options = {}) {
+  return buildPrintDocument(buildExportTable(source, options), {
+    ...options,
+    title: options.title ?? source.options.label,
+    locale: options.locale ?? source.options.locale
+  });
+}
+
+// src/export/csv.ts
+var BOM = "\uFEFF";
+var FORMULA_START = /^[=+\-@\t\r]/;
+var SIGN_START = /^[+-]/;
+var NEEDS_QUOTES = /["\r\n]/;
+function autoDelimiter(locale) {
+  const decimal = new Intl.NumberFormat(locale).formatToParts(1.5).find((part) => part.type === "decimal")?.value;
+  return decimal === "," ? ";" : ",";
+}
+function neutralize(field) {
+  const { text } = field;
+  if (!FORMULA_START.test(text) || field.isNumber && SIGN_START.test(text)) {
+    return text;
+  }
+  return `'${text}`;
+}
+function quote(text, delimiter) {
+  return text.includes(delimiter) || NEEDS_QUOTES.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function toCsv(table, options = {}) {
+  const delimiter = options.delimiter === "auto" ? autoDelimiter(options.locale) : options.delimiter ?? ",";
+  const guard = options.neutralizeFormulas ?? true;
+  const lines = textRecords(table, options.values ?? "text").map(
+    (record) => record.map((field) => quote(guard ? neutralize(field) : field.text, delimiter)).join(delimiter)
+  );
+  return (options.bom ?? true ? BOM : "") + lines.join(options.eol ?? "\r\n");
+}
+
+// src/export/json.ts
+function uniqueNames(names) {
+  const used = /* @__PURE__ */ new Set();
+  return names.map((name) => {
+    let unique = name;
+    for (let n = 2; used.has(unique); n += 1) {
+      unique = `${name} (${String(n)})`;
+    }
+    used.add(unique);
+    return unique;
+  });
+}
+function toJson(table, options = {}) {
+  const keys = options.keys === "header" ? uniqueNames(table.columns.map((column) => column.header)) : table.columns.map((column) => column.id);
+  const records = table.rows.flatMap(
+    (row) => row.kind === "data" ? [
+      Object.fromEntries(
+        keys.map((key, index) => [key, row.cells[index]?.value ?? null])
+      )
+    ] : []
+  );
+  return JSON.stringify(records, null, options.space);
+}
+
+// src/export/writer.ts
+var csvWriter = {
+  format: "csv",
+  fileExtension: "csv",
+  mimeType: "text/csv;charset=utf-8",
+  write: (table, { locale, options }) => toCsv(table, { locale, ...options.csv })
+};
+var jsonWriter = {
+  format: "json",
+  fileExtension: "json",
+  mimeType: "application/json",
+  write: (table, { options }) => toJson(table, options.json)
+};
+function resolveExportWriters(writers) {
+  return new Map(
+    [csvWriter, jsonWriter, ...writers ?? []].map((writer) => [
+      writer.format,
+      writer
+    ])
+  );
+}
+
+// src/filterMenu/operators.ts
+function filterOperatorFamily(type) {
+  return kindOf(type);
+}
+var familyOperators = {
+  text: [
+    "contains",
+    "notContains",
+    "eq",
+    "ne",
+    "startsWith",
+    "endsWith",
+    "isEmpty",
+    "isNotEmpty"
+  ],
+  number: [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "isEmpty",
+    "isNotEmpty"
+  ],
+  date: ["eq", "ne", "lt", "gt", "between", "isEmpty", "isNotEmpty"],
+  boolean: ["eq", "isEmpty", "isNotEmpty"]
+};
+var instantOperators = [
+  "lt",
+  "gt",
+  "between",
+  "isEmpty",
+  "isNotEmpty"
+];
+function defaultFilterOperators(type) {
+  return type === "dateTime" || type === "time" ? instantOperators : familyOperators[filterOperatorFamily(type)];
+}
+function filterOperandArity(operator) {
+  switch (operator) {
+    case "isEmpty":
+    case "isNotEmpty":
+      return 0;
+    case "between":
+      return 2;
+    case "eq":
+    case "ne":
+    case "contains":
+    case "notContains":
+    case "startsWith":
+    case "endsWith":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "in":
+      return 1;
+  }
+}
+var NUMBER_INPUT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+var DATE_INPUT = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?$/;
+function parseNumber(text) {
+  const value = Number(text);
+  return NUMBER_INPUT.test(text) && Number.isFinite(value) ? value : void 0;
+}
+function parseDate(text) {
+  const match = DATE_INPUT.exec(text);
+  if (match === null) {
+    return void 0;
+  }
+  const [
+    ,
+    year,
+    month,
+    day,
+    hours = "0",
+    minutes = "0",
+    seconds = "0",
+    fraction = ""
+  ] = match;
+  if (Number(hours) > 23 || Number(minutes) > 59 || Number(seconds) > 59) {
+    return void 0;
+  }
+  const date = new Date(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hours),
+    Number(minutes),
+    Number(seconds),
+    Number(fraction.padEnd(3, "0"))
+  );
+  return date.getFullYear() === Number(year) && date.getMonth() === Number(month) - 1 && date.getDate() === Number(day) ? date : void 0;
+}
+function parseBoolean(text) {
+  if (text === "true") {
+    return true;
+  }
+  return text === "false" ? false : void 0;
+}
+function parseFilterOperand(text, type) {
+  if (text === "") {
+    return void 0;
+  }
+  switch (filterOperatorFamily(type)) {
+    case "text":
+      return text;
+    case "number":
+      return parseNumber(text.trim());
+    case "date":
+      return parseDate(text.trim());
+    case "boolean":
+      return parseBoolean(text.trim());
+  }
+}
+function pad(value, width = 2) {
+  return String(value).padStart(width, "0");
+}
+function dayInput(date) {
+  return `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function momentInput(date) {
+  const minute = `${dayInput(date)}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  const seconds = date.getSeconds();
+  const milliseconds = date.getMilliseconds();
+  if (seconds === 0 && milliseconds === 0) {
+    return minute;
+  }
+  const second = `${minute}:${pad(seconds)}`;
+  return milliseconds === 0 ? second : `${second}.${pad(milliseconds, 3)}`;
+}
+function formatFilterOperand(value, type) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const date = filterOperatorFamily(type) === "date" ? toDate(value) : void 0;
+  if (date === void 0) {
+    return String(value);
+  }
+  return type === "date" ? dayInput(date) : momentInput(date);
+}
+
+// src/filterMenu/options.ts
+var DEFAULT_FILTER_VALUE_LIMIT = 1e4;
+function conditionOperators(operators) {
+  return operators.includes("in") ? operators.filter((operator) => operator !== "in") : operators;
+}
+function resolveColumnFilterMenu(options, column) {
+  if (!(column.filterable ?? options.filterableColumns ?? false)) {
+    return null;
+  }
+  const grid = options.filterMenu;
+  const own = column.filterMenu;
+  return {
+    ui: own?.ui ?? grid?.ui ?? "simple",
+    operators: conditionOperators(
+      own?.operators ?? defaultFilterOperators(column.type)
+    ),
+    family: filterOperatorFamily(column.type),
+    showCounts: grid?.showCounts ?? false,
+    valueLimit: grid?.valueLimit ?? DEFAULT_FILTER_VALUE_LIMIT
+  };
+}
+
+// src/messages.ts
+function localeKey2(locale) {
+  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
+}
+var countFormats = /* @__PURE__ */ new Map();
+function countFormat(locale) {
+  const key = localeKey2(locale);
+  let format = countFormats.get(key);
+  if (format === void 0) {
+    const numberFormat = new Intl.NumberFormat(locale, {
+      maximumFractionDigits: 0
+    });
+    format = (count) => numberFormat.format(count);
+    countFormats.set(key, format);
+  }
+  return format;
+}
+function columnCount(n, count, change) {
+  return count === 1 ? `1 column ${change}` : `${n(count)} columns ${change}`;
+}
+function searchResults(n, count) {
+  if (count === 0) {
+    return "No rows found";
+  }
+  return count === 1 ? "1 row found" : `${n(count)} rows found`;
+}
+function selectedCount(n, count, target) {
+  const noun = target === "rows" ? "row" : "column";
+  if (count === 0) {
+    return `No ${noun}s selected`;
+  }
+  return count === 1 ? `1 ${noun} selected` : `${n(count)} ${noun}s selected`;
+}
+var operatorLabels = {
+  eq: "Equals",
+  ne: "Does not equal",
+  contains: "Contains",
+  notContains: "Does not contain",
+  startsWith: "Starts with",
+  endsWith: "Ends with",
+  gt: "Greater than",
+  gte: "Greater than or equal to",
+  lt: "Less than",
+  lte: "Less than or equal to",
+  between: "Between",
+  in: "Is one of",
+  isEmpty: "Is blank",
+  isNotEmpty: "Is not blank"
+};
+var dateOperatorLabels = {
+  lt: "Before",
+  lte: "On or before",
+  gt: "After",
+  gte: "On or after"
+};
+function filterOperatorLabel(operator, family) {
+  return (family === "date" ? dateOperatorLabels[operator] : void 0) ?? operatorLabels[operator];
+}
+function filterSearchFirst(n, total) {
+  return total === 1 ? "Type to search 1 value" : `Type to search ${n(total)} values`;
+}
+function filterResults(n, shown, total) {
+  return `${n(shown)} of ${n(total)} ${total === 1 ? "row" : "rows"}`;
+}
+var filterValueRequests = {
+  text: "Enter a value",
+  number: "Enter a number",
+  date: "Enter a date",
+  boolean: "Choose a value"
+};
+var filterOperatorMenus = {
+  text: "Text filters",
+  number: "Number filters",
+  date: "Date filters",
+  boolean: "Boolean filters"
+};
+function copied(n, count, unit) {
+  return count === 1 ? `1 ${unit.slice(0, -1)} copied` : `${n(count)} ${unit} copied`;
+}
+function createDefaultMessages(locale) {
+  const n = countFormat(locale);
+  return {
+    pagerLabel: "Pagination",
+    firstPage: "First",
+    previousPage: "Previous",
+    nextPage: "Next",
+    lastPage: "Last",
+    pageSizeLabel: "Rows per page",
+    pageButtonLabel: (page) => `Page ${n(page)}`,
+    pageStatus: (page, pageCount) => `Page ${n(page)} of ${n(pageCount)}`,
+    loadingMore: "Loading more\u2026",
+    booleanTrue: "true",
+    booleanFalse: "false",
+    blankGroupValue: "(blank)",
+    groupByBarLabel: "Grouped by",
+    groupByBarPlaceholder: "Drag a column here to group by it",
+    groupByChipLabel: (columnName2, level, levelCount) => levelCount > 1 ? `${columnName2}, level ${n(level)} of ${n(levelCount)}` : columnName2,
+    removeGroupBy: (columnName2) => `Stop grouping by ${columnName2}`,
+    columnResized: (columnName2, width) => `${columnName2}, ${n(width)} pixels wide`,
+    columnMoved: (columnName2, position, columnCount2) => `${columnName2}, column ${n(position)} of ${n(columnCount2)}`,
+    columnSorted: (columnName2, direction, key, keyCount) => {
+      const sorted = `${columnName2} sorted ${direction === "asc" ? "ascending" : "descending"}`;
+      return keyCount > 1 ? `${sorted}, key ${n(key)} of ${n(keyCount)}` : sorted;
+    },
+    sortCleared: (columnName2) => `${columnName2}, sort cleared`,
+    groupedBy: (columnName2, level, levelCount) => levelCount > 1 ? `Grouped by ${columnName2}, level ${n(level)} of ${n(levelCount)}` : `Grouped by ${columnName2}`,
+    groupingRemoved: (columnName2) => `${columnName2}, grouping removed`,
+    groupExpanded: "Group expanded",
+    groupCollapsed: "Group collapsed",
+    allGroupsExpanded: "All groups expanded",
+    allGroupsCollapsed: "All groups collapsed",
+    selectedCount: (count, target) => selectedCount(n, count, target),
+    cellSelected: (columnName2, rowNumber) => `${columnName2}, row ${n(rowNumber)}, selected`,
+    columnHidden: (columnName2) => `${columnName2}, column hidden`,
+    columnShown: (columnName2) => `${columnName2}, column shown`,
+    columnsHidden: (count) => columnCount(n, count, "hidden"),
+    columnsShown: (count) => columnCount(n, count, "shown"),
+    columnsAutoFitted: (count) => columnCount(n, count, "autofitted"),
+    headerMenuLabel: (columnName2) => `${columnName2} column menu`,
+    cellMenuLabel: "Row menu",
+    groupMenuLabel: "Group menu",
+    bodyMenuLabel: "Grid menu",
+    sortAscending: "Sort ascending",
+    sortDescending: "Sort descending",
+    clearSort: "Clear sort",
+    clearAllSorting: "Clear all sorting",
+    groupByColumn: (columnName2) => `Group by ${columnName2}`,
+    ungroupAll: "Ungroup all",
+    expandAllGroups: "Expand all groups",
+    collapseAllGroups: "Collapse all groups",
+    hideColumn: "Hide column",
+    autoFitColumn: "Autofit column",
+    autoFitAllColumns: "Autofit all columns",
+    selectAllRows: "Select all rows",
+    clearSelection: "Clear selection",
+    clearFilters: "Clear filters",
+    chooseColumns: "Choose columns",
+    toolbarLabel: "Grid toolbar",
+    searchLabel: "Search",
+    searchPlaceholder: "Search\u2026",
+    moreToolbarItems: "More",
+    searchResults: (count) => searchResults(n, count),
+    columnChooserLabel: "Columns",
+    columnChooserSearchLabel: "Search columns",
+    showAllColumns: "Show all",
+    noMatchingColumns: "No matching columns",
+    filterOperatorLabel,
+    filterBlanks: "(Blanks)",
+    filterSearchFirst: (total) => filterSearchFirst(n, total),
+    filterMoreValues: (count) => `${n(count)} more, refine the search`,
+    openFilter: "Filter\u2026",
+    clearColumnFilter: "Clear filter",
+    filterMenuLabel: (columnName2) => `${columnName2} filter`,
+    columnFiltered: "Filtered",
+    applyFilter: "OK",
+    cancelFilter: "Cancel",
+    customFilter: "Custom filter",
+    filterResults: (shown, total) => filterResults(n, shown, total),
+    filterConditionLabel: (position) => `Condition ${n(position)}`,
+    filterOperatorFieldLabel: "Operator",
+    filterValueLabel: "Value",
+    filterFromLabel: "From",
+    filterToLabel: "To",
+    filterCombinatorLabel: "Combine conditions",
+    filterAnd: "And",
+    filterOr: "Or",
+    filterValueInvalid: (family) => filterValueRequests[family],
+    filterSearchLabel: "Search values",
+    filterSelectAll: "Select all",
+    filterValuesLabel: "Values",
+    filterByCondition: "Filtered by condition",
+    filterOperatorMenu: (family) => filterOperatorMenus[family],
+    filterBackToValues: "Back to values",
+    exportMenu: "Export",
+    exportCsv: "Export to CSV",
+    exportJson: "Export to JSON",
+    exportXlsx: "Export to Excel",
+    exportPdf: "Export to PDF",
+    exportSelectionCsv: "Export selection to CSV",
+    exportSelectionJson: "Export selection to JSON",
+    exportSelectionXlsx: "Export selection to Excel",
+    exportFailed: "Export failed",
+    copyCell: "Copy cell",
+    copyRow: "Copy row",
+    copySelection: "Copy selection",
+    copied: (count, unit) => copied(n, count, unit),
+    copyFailed: "Copy failed",
+    print: "Print"
+  };
+}
+var defaultMessages = createDefaultMessages();
+var localeDefaults = /* @__PURE__ */ new Map();
+function defaultsFor(locale) {
+  if (locale === void 0) {
+    return defaultMessages;
+  }
+  const key = localeKey2(locale);
+  let defaults = localeDefaults.get(key);
+  if (defaults === void 0) {
+    defaults = createDefaultMessages(locale);
+    localeDefaults.set(key, defaults);
+  }
+  return defaults;
+}
+function resolveMessages(messages, locale) {
+  const defaults = defaultsFor(locale);
+  return messages === void 0 ? defaults : { ...defaults, ...messages };
+}
+
+// src/util/filterEditor.ts
+function touchesColumn(entry, columnId) {
+  return "combinator" in entry ? entry.entries.some((nested) => touchesColumn(nested, columnId)) : entry.columnId === columnId;
+}
+function isOperatorOn(entry, columnId) {
+  return "operator" in entry && entry.columnId === columnId;
+}
+function isConditionOn(entry, columnId) {
+  return isOperatorOn(entry, columnId) && entry.operator !== "in";
+}
+function valuesShape(entry, columnId) {
+  const values = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "in" && isScalarList(candidate.value) ? candidate.value : void 0;
+  const blanks = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "isEmpty";
+  const alone = values(entry);
+  if (alone !== void 0) {
+    return { kind: "values", values: alone, includeBlanks: false };
+  }
+  if (!("combinator" in entry) || entry.combinator !== "or" || entry.entries.length !== 2) {
+    return void 0;
+  }
+  const [first, second] = entry.entries;
+  const listed = blanks(first) ? values(second) : values(first);
+  return listed !== void 0 && (blanks(first) || blanks(second)) ? { kind: "values", values: listed, includeBlanks: true } : void 0;
+}
+function conditionsShape(touching, columnId) {
+  const [only] = touching;
+  const grouped = touching.length === 1 && only !== void 0 && "combinator" in only;
+  const entries = grouped ? only.entries : touching;
+  const combinator = grouped ? only.combinator : "and";
+  if (entries.length === 0 || entries.length > 2) {
+    return void 0;
+  }
+  const conditions = entries.filter((entry) => isConditionOn(entry, columnId));
+  return conditions.length === entries.length ? { kind: "conditions", conditions, combinator } : void 0;
+}
+function describeColumnFilter(filter, columnId) {
+  const touching = filter.filter((entry) => touchesColumn(entry, columnId));
+  const [only] = touching;
+  if (only === void 0) {
+    return { kind: "none" };
+  }
+  return (touching.length === 1 ? valuesShape(only, columnId) : void 0) ?? conditionsShape(touching, columnId) ?? { kind: "custom" };
+}
+function isColumnFiltered(filter, columnId) {
+  return filter.some((entry) => touchesColumn(entry, columnId));
+}
+function isOfferable(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date;
+}
+function matchesSearch(label, search) {
+  return label.toLowerCase().includes(search.toLowerCase());
+}
+function columnValueOptions(rows, dataColumns, filter, columnId, query = {}) {
+  const column = dataColumns.find((entry) => entry.id === columnId)?.column;
+  if (column === void 0) {
+    return { options: [], total: 0, truncated: false, blanks: 0 };
+  }
+  const keep = compileFilter(
+    filter.filter((entry) => !touchesColumn(entry, columnId)),
+    dataColumns
+  );
+  const buckets = /* @__PURE__ */ new Map();
+  let blanks = 0;
+  for (const row of rows) {
+    if (keep !== void 0 && !keep(row)) {
+      continue;
+    }
+    const value = accessDotted(row, column.field);
+    if (isEmptyCell(value)) {
+      blanks++;
+    } else if (isOfferable(value)) {
+      const key = filterValueKey(value, column.type);
+      const bucket = buckets.get(key);
+      if (bucket === void 0) {
+        buckets.set(key, { value, row, count: 1 });
+      } else {
+        bucket.count++;
+      }
+    }
+  }
+  const { search = "", limit, locale } = query;
+  const messages = resolveMessages(query.messages, locale);
+  const options = [...buckets.values()].sort((a, b) => compareValues(a.value, b.value, column.type)).map(({ value, row, count }) => ({
+    value,
+    label: formatCellValue(value, column, locale, row, messages),
+    count
+  })).filter((option) => matchesSearch(option.label, search));
+  const shown = limit === void 0 ? options : options.slice(0, limit);
+  return {
+    options: shown,
+    total: options.length,
+    truncated: shown.length < options.length,
+    blanks,
+    columnType: column.type
+  };
+}
+function keyOf2(draft, value) {
+  return filterValueKey(value, draft.columnType);
+}
+function everyOption(draft) {
+  return new Map(
+    draft.options.map((option) => [keyOf2(draft, option.value), option.value])
+  );
+}
+function initialFilterEditorDraft(shape, values) {
+  const draft = {
+    mode: "values",
+    options: values.options,
+    blanks: values.blanks,
+    search: "",
+    checked: everyOption(values),
+    includeBlanks: values.blanks > 0,
+    conditions: [],
+    combinator: "and",
+    columnType: values.columnType
+  };
+  switch (shape.kind) {
+    case "values":
+      return {
+        ...draft,
+        checked: new Map(
+          shape.values.filter((value) => !isEmptyCell(value)).map((value) => [keyOf2(draft, value), value])
+        ),
+        includeBlanks: shape.includeBlanks
+      };
+    case "conditions":
+      return {
+        ...draft,
+        mode: "conditions",
+        conditions: shape.conditions,
+        combinator: shape.combinator
+      };
+    case "none":
+    case "custom":
+      return draft;
+  }
+}
+function visibleFilterOptions(draft) {
+  return draft.search === "" ? draft.options : draft.options.filter(
+    (option) => matchesSearch(option.label, draft.search)
+  );
+}
+function selectAllCoversBlanks(draft) {
+  return draft.search === "" && draft.blanks > 0;
+}
+function selectAllState(draft) {
+  const states = visibleFilterOptions(draft).map(
+    (option) => draft.checked.has(keyOf2(draft, option.value))
+  );
+  if (selectAllCoversBlanks(draft)) {
+    states.push(draft.includeBlanks);
+  }
+  if (states.length > 0 && states.every(Boolean)) {
+    return "checked";
+  }
+  return states.some(Boolean) ? "mixed" : "unchecked";
+}
+function toggleAll(draft) {
+  const check = selectAllState(draft) !== "checked";
+  const checked = new Map(draft.checked);
+  for (const option of visibleFilterOptions(draft)) {
+    const key = keyOf2(draft, option.value);
+    if (check) {
+      checked.set(key, option.value);
+    } else {
+      checked.delete(key);
+    }
+  }
+  return {
+    ...draft,
+    mode: "values",
+    checked,
+    includeBlanks: selectAllCoversBlanks(draft) ? check : draft.includeBlanks
+  };
+}
+function filterEditorReducer(draft, action) {
+  switch (action.type) {
+    case "search":
+      return { ...draft, search: action.search };
+    case "toggleValue": {
+      const key = keyOf2(draft, action.value);
+      const checked = new Map(draft.checked);
+      if (checked.has(key)) {
+        checked.delete(key);
+      } else {
+        checked.set(key, action.value);
+      }
+      return { ...draft, mode: "values", checked };
+    }
+    case "toggleAll":
+      return toggleAll(draft);
+    case "setIncludeBlanks":
+      return { ...draft, mode: "values", includeBlanks: action.includeBlanks };
+    case "setConditions":
+      return {
+        ...draft,
+        mode: "conditions",
+        conditions: action.conditions,
+        combinator: action.combinator ?? draft.combinator
+      };
+    case "clear":
+      return {
+        ...draft,
+        search: "",
+        checked: everyOption(draft),
+        includeBlanks: draft.blanks > 0,
+        conditions: []
+      };
+  }
+}
+function checksEverything(draft) {
+  return draft.options.every(
+    (option) => draft.checked.has(keyOf2(draft, option.value))
+  ) && (draft.includeBlanks || draft.blanks === 0);
+}
+function draftEntries(draft, columnId) {
+  if (draft.mode === "conditions") {
+    const conditions = draft.conditions.map((condition) => ({
+      ...condition,
+      columnId
+    }));
+    return conditions.length > 1 ? [{ combinator: draft.combinator, entries: conditions }] : conditions;
+  }
+  if (checksEverything(draft)) {
+    return [];
+  }
+  const picked = {
+    columnId,
+    operator: "in",
+    value: [...draft.checked.values()]
+  };
+  return draft.includeBlanks ? [
+    {
+      combinator: "or",
+      entries: [picked, { columnId, operator: "isEmpty" }]
+    }
+  ] : [picked];
+}
+function draftToFilter(draft, columnId, current) {
+  const replacement = draftEntries(draft, columnId);
+  const first = current.findIndex((entry) => touchesColumn(entry, columnId));
+  if (first === -1) {
+    return replacement.length === 0 ? current : [...current, ...replacement];
+  }
+  const kept = current.filter((entry) => !touchesColumn(entry, columnId));
+  return [...kept.slice(0, first), ...replacement, ...kept.slice(first)];
+}
+
 // src/commands/builtInCommands.ts
 function isOn(context, areas) {
   return areas.includes(context.target.area);
@@ -2207,6 +3508,10 @@ 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;
@@ -2261,6 +3566,63 @@ function columnCommand({
     }
   };
 }
+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",
@@ -2382,6 +3744,29 @@ function builtInCommands() {
         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,
@@ -2408,6 +3793,75 @@ function builtInCommands() {
       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);
+      }
     }
   ];
 }
@@ -2554,6 +4008,9 @@ var defaultContextMenu = {
     "sort.descending",
     "sort.clear",
     "separator",
+    "filter.open",
+    "filter.clear",
+    "separator",
     "group.add",
     "group.remove",
     "separator",
@@ -2564,6 +4021,10 @@ var defaultContextMenu = {
     "column.choose"
   ],
   cell: [
+    "copy.cell",
+    "copy.row",
+    "copy.selection",
+    "separator",
     "selection.selectAllRows",
     "selection.clear",
     "separator",
@@ -2680,6 +4141,23 @@ function toolbarEntries(toolbar) {
 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) {
@@ -2695,11 +4173,12 @@ function resolveToolbar(entries, options) {
     if (entry === "separator") {
       return { type: "separator", key: `separator-${String(index)}` };
     }
-    const resolved = resolveMenuEntry(entry, index, {
+    const menuEntry = entry === "export" ? exportMenu() : entry;
+    const resolved = resolveMenuEntry(menuEntry, index, {
       commands,
       context: contextFor({
         area: "toolbar",
-        itemId: typeof entry === "string" ? entry : entry.id
+        itemId: typeof menuEntry === "string" ? menuEntry : menuEntry.id
       })
     });
     if (resolved === null || resolved.type === "separator") {
@@ -2893,558 +4372,218 @@ function nextFocusForKey(key, modifiers, focus, rowCount, columnCount2, pageSize
       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 selectedCount(count, target) {
-  const noun = target === "rows" ? "row" : "column";
-  if (count === 0) {
-    return `No ${noun}s selected`;
-  }
-  return count === 1 ? `1 ${noun} selected` : `${String(count)} ${noun}s selected`;
-}
-var defaultMessages = {
-  pagerLabel: "Pagination",
-  previousPage: "Previous",
-  nextPage: "Next",
-  pageSizeLabel: "Rows per page",
-  pageButtonLabel: (page) => `Page ${String(page)}`,
-  pageStatus: (page, pageCount) => `Page ${String(page)} of ${String(pageCount)}`,
-  loadingMore: "Loading more\u2026",
-  booleanTrue: "true",
-  booleanFalse: "false",
-  blankGroupValue: "(blank)",
-  groupByBarLabel: "Grouped by",
-  groupByBarPlaceholder: "Drag a column here to group by it",
-  groupByChipLabel: (columnName2, level, levelCount) => levelCount > 1 ? `${columnName2}, level ${String(level)} of ${String(levelCount)}` : columnName2,
-  removeGroupBy: (columnName2) => `Stop grouping by ${columnName2}`,
-  columnResized: (columnName2, width) => `${columnName2}, ${String(width)} pixels wide`,
-  columnMoved: (columnName2, position, columnCount2) => `${columnName2}, column ${String(position)} of ${String(columnCount2)}`,
-  columnSorted: (columnName2, direction, key, keyCount) => {
-    const sorted = `${columnName2} sorted ${direction === "asc" ? "ascending" : "descending"}`;
-    return keyCount > 1 ? `${sorted}, key ${String(key)} of ${String(keyCount)}` : sorted;
-  },
-  sortCleared: (columnName2) => `${columnName2}, sort cleared`,
-  groupedBy: (columnName2, level, levelCount) => levelCount > 1 ? `Grouped by ${columnName2}, level ${String(level)} of ${String(levelCount)}` : `Grouped by ${columnName2}`,
-  groupingRemoved: (columnName2) => `${columnName2}, grouping removed`,
-  groupExpanded: "Group expanded",
-  groupCollapsed: "Group collapsed",
-  allGroupsExpanded: "All groups expanded",
-  allGroupsCollapsed: "All groups collapsed",
-  selectedCount,
-  cellSelected: (columnName2, rowNumber) => `${columnName2}, row ${String(rowNumber)}, selected`,
-  columnHidden: (columnName2) => `${columnName2}, column hidden`,
-  columnShown: (columnName2) => `${columnName2}, column shown`,
-  columnsHidden: (count) => columnCount(count, "hidden"),
-  columnsShown: (count) => columnCount(count, "shown"),
-  columnsAutoFitted: (count) => columnCount(count, "autofitted"),
-  headerMenuLabel: (columnName2) => `${columnName2} column menu`,
-  cellMenuLabel: "Row menu",
-  groupMenuLabel: "Group menu",
-  bodyMenuLabel: "Grid menu",
-  sortAscending: "Sort ascending",
-  sortDescending: "Sort descending",
-  clearSort: "Clear sort",
-  clearAllSorting: "Clear all sorting",
-  groupByColumn: (columnName2) => `Group by ${columnName2}`,
-  ungroupAll: "Ungroup all",
-  expandAllGroups: "Expand all groups",
-  collapseAllGroups: "Collapse all groups",
-  hideColumn: "Hide column",
-  autoFitColumn: "Autofit column",
-  autoFitAllColumns: "Autofit all columns",
-  selectAllRows: "Select all rows",
-  clearSelection: "Clear selection",
-  clearFilters: "Clear filters",
-  chooseColumns: "Choose columns",
-  toolbarLabel: "Grid toolbar",
-  searchLabel: "Search",
-  searchPlaceholder: "Search\u2026",
-  moreToolbarItems: "More",
-  searchResults,
-  columnChooserLabel: "Columns",
-  columnChooserSearchLabel: "Search columns",
-  showAllColumns: "Show all",
-  noMatchingColumns: "No matching columns"
-};
-function resolveMessages(messages) {
-  return messages === void 0 ? defaultMessages : { ...defaultMessages, ...messages };
-}
-
-// src/util/format.ts
-var DATE_FIELDS = {
-  year: "numeric",
-  month: "numeric",
-  day: "numeric"
-};
-var TIME_FIELDS = {
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric"
-};
-var DATE_TIME_FIELDS = {
-  ...DATE_FIELDS,
-  ...TIME_FIELDS
-};
-var CURRENCY_DIGITS = {
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2
-};
-var NO_FORMAT = {};
-var formatters = /* @__PURE__ */ new WeakMap();
-function cached(format, key, create) {
-  const owner = format ?? NO_FORMAT;
-  let byKey = formatters.get(owner);
-  if (byKey === void 0) {
-    byKey = /* @__PURE__ */ new Map();
-    formatters.set(owner, byKey);
-  }
-  const existing = byKey.get(key);
-  if (existing !== void 0) {
-    return existing;
-  }
-  const formatter = create();
-  byKey.set(key, formatter);
-  return formatter;
-}
-function localeKey(locale) {
-  return typeof locale === "string" ? locale : locale?.join(",") ?? "";
-}
-function isNumericType(type) {
-  return type === "number" || type === "decimal" || type === "currency" || type === "percent";
-}
-function numberOptions(type, format) {
-  switch (type) {
-    case "currency":
-      return format?.currency === void 0 ? { ...CURRENCY_DIGITS, ...format } : { style: "currency", ...format };
-    case "percent":
-      return { style: "percent", ...format };
-    default:
-      return 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;
-}
-function isOperatorOn(entry, columnId) {
-  return "operator" in entry && entry.columnId === columnId;
-}
-function isConditionOn(entry, columnId) {
-  return isOperatorOn(entry, columnId) && entry.operator !== "in";
-}
-function valuesShape(entry, columnId) {
-  const values = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "in" && isScalarList(candidate.value) ? candidate.value : void 0;
-  const blanks = (candidate) => candidate !== void 0 && isOperatorOn(candidate, columnId) && candidate.operator === "isEmpty";
-  const alone = values(entry);
-  if (alone !== void 0) {
-    return { kind: "values", values: alone, includeBlanks: false };
-  }
-  if (!("combinator" in entry) || entry.combinator !== "or" || entry.entries.length !== 2) {
-    return void 0;
-  }
-  const [first, second] = entry.entries;
-  const listed = blanks(first) ? values(second) : values(first);
-  return listed !== void 0 && (blanks(first) || blanks(second)) ? { kind: "values", values: listed, includeBlanks: true } : void 0;
-}
-function conditionsShape(touching, columnId) {
-  const [only] = touching;
-  const grouped = touching.length === 1 && only !== void 0 && "combinator" in only;
-  const entries = grouped ? only.entries : touching;
-  const combinator = grouped ? only.combinator : "and";
-  if (entries.length === 0 || entries.length > 2) {
-    return void 0;
-  }
-  const conditions = entries.filter((entry) => isConditionOn(entry, columnId));
-  return conditions.length === entries.length ? { kind: "conditions", conditions, combinator } : void 0;
-}
-function describeColumnFilter(filter, columnId) {
-  const touching = filter.filter((entry) => touchesColumn(entry, columnId));
-  const [only] = touching;
-  if (only === void 0) {
-    return { kind: "none" };
+
+// src/util/paginationWindow.ts
+function paginationWindow(currentPage, pageCount, options) {
+  if (pageCount <= 0) {
+    return [];
   }
-  return (touching.length === 1 ? valuesShape(only, columnId) : void 0) ?? conditionsShape(touching, columnId) ?? { kind: "custom" };
+  const boundaryCount = Math.max(0, Math.floor(options?.boundaryCount ?? 1));
+  const siblingCount = Math.max(0, Math.floor(options?.siblingCount ?? 1));
+  const slotCount = 2 * boundaryCount + 2 * siblingCount + 3;
+  if (pageCount <= slotCount) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const current = Math.min(Math.max(currentPage, 1), pageCount);
+  const runStart = Math.min(
+    Math.max(current - siblingCount, boundaryCount + 2),
+    pageCount - boundaryCount - 1 - 2 * siblingCount
+  );
+  const runEnd = runStart + 2 * siblingCount;
+  const entries = [];
+  for (let page = 1; page <= boundaryCount; page++) {
+    entries.push(page);
+  }
+  entries.push(runStart === boundaryCount + 2 ? boundaryCount + 1 : "ellipsis");
+  for (let page = runStart; page <= runEnd; page++) {
+    entries.push(page);
+  }
+  entries.push(
+    runEnd === pageCount - boundaryCount - 1 ? pageCount - boundaryCount : "ellipsis"
+  );
+  for (let page = pageCount - boundaryCount + 1; page <= pageCount; page++) {
+    entries.push(page);
+  }
+  return entries;
 }
-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 +4626,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 +4644,9 @@ export {
   applyColumnVisibility,
   applySelectionIntent,
   beginColumnResize,
+  buildExportTable,
   buildKeyShortcuts,
+  buildPrintDocument,
   builtInCommands,
   clampColumnWidth,
   clampFocus,
@@ -3508,34 +4656,51 @@ export {
   columnValueOptions,
   compareValues,
   computeAggregates,
+  conditionRowsFrom,
+  conditionsFromRows,
   contextMenuEntries,
+  copyContent,
+  createColumnValueOptionsCache,
   createCommandContext,
+  createDefaultMessages,
   createGridController,
   createGridViewResolver,
+  csvWriter,
   defaultContextMenu,
+  defaultFilterOperators,
   defaultMessages,
   defaultToolbar,
   defineColumnsFromRows,
   describeColumnFilter,
   diffSelection,
   draftToFilter,
+  excelFilter,
   expandAllGroups,
+  exportFile,
+  exportPrintDocument,
+  filterChecklist,
   filterEditorReducer,
+  filterOperandArity,
+  filterOperatorFamily,
   filterQueryFor,
   filterRows,
   fitColumnsToWidth,
   fitToolbarItems,
   formatAggregateValue,
   formatCellValue,
+  formatFilterOperand,
+  formatGroupValue,
   getColumnId,
   groupRowId,
   groupRows,
   hasContextMenu,
   initialFilterEditorDraft,
   intentOf,
+  isColumnFiltered,
   isColumnVisible,
   isPinnedToolbarItem,
   isSameCell,
+  jsonWriter,
   matchesQuery,
   moveColumnBefore,
   moveGroupByBefore,
@@ -3545,9 +4710,11 @@ export {
   nextMenuIndex,
   paginateRows,
   paginationWindow,
+  parseFilterOperand,
   resolveCell,
   resolveColumnChooser,
   resolveColumnConstraints,
+  resolveColumnFilterMenu,
   resolveColumnHeaderText,
   resolveColumnLabel,
   resolveColumnWidths,
@@ -3555,6 +4722,7 @@ export {
   resolveCommands,
   resolveDataColumns,
   resolveDropBefore,
+  resolveExportWriters,
   resolveGridView,
   resolveKeyboardDropTarget,
   resolveMenu,
@@ -3580,6 +4748,10 @@ export {
   sortPriorityFor,
   sortRows,
   splitToolbarItems,
+  toCsv,
+  toHtmlTable,
+  toJson,
+  toTsv,
   toggleCellSelection,
   toggleColumnSort,
   toggleGroupExpansion,