@fluixi-ui/bulk-editor 0.3.0-alpha.18 → 0.3.0-alpha.19

package/dist/state.js

@@ -1,627 +1,713 @@
-import { createSignal, createMemo, untrack, createEffect, batch } from "@fluixi/reactive/signal";
+import { batch, createEffect, createMemo, createSignal, untrack } from "@fluixi/reactive/signal";
 import { ERR } from "@fluixi-ui/formula";
-const clampTo = (n, max) => Math.max(0, Math.min(n, max));
-const MIN_COL_WIDTH = 48;
+//#region src/state.ts
+var clampTo = (n, max) => Math.max(0, Math.min(n, max));
+var MIN_COL_WIDTH = 48;
+/** Fold a column's computed values into a single footer value. */
 function aggregateValues(kind, values) {
-  const nums = values.map(Number).filter((n) => !Number.isNaN(n));
-  switch (kind) {
-    case "count":
-      return String(values.filter((v) => v !== "").length);
-    case "sum":
-      return String(nums.reduce((a, b) => a + b, 0));
-    case "avg":
-      return nums.length ? String(Math.round(nums.reduce((a, b) => a + b, 0) / nums.length * 100) / 100) : "";
-    case "min":
-      return nums.length ? String(Math.min(...nums)) : "";
-    case "max":
-      return nums.length ? String(Math.max(...nums)) : "";
-    default:
-      return "";
-  }
+	const nums = values.map(Number).filter((n) => !Number.isNaN(n));
+	switch (kind) {
+		case "count": return String(values.filter((v) => v !== "").length);
+		case "sum": return String(nums.reduce((a, b) => a + b, 0));
+		case "avg": return nums.length ? String(Math.round(nums.reduce((a, b) => a + b, 0) / nums.length * 100) / 100) : "";
+		case "min": return nums.length ? String(Math.min(...nums)) : "";
+		case "max": return nums.length ? String(Math.max(...nums)) : "";
+		default: return "";
+	}
 }
+/**
+* Match a cell value against a filter term. Numeric terms may use comparison
+* operators (`>20`, `<=5`, `!=0`) or modulo (`%3`, `%3=1`); anything else is a
+* case-insensitive substring match.
+*/
 function matchesFilter(value, filter) {
-  const f = filter.trim();
-  if (!f) return true;
-  const mod = /^%\s*(\d+)(?:\s*=\s*(-?\d+))?$/.exec(f);
-  if (mod) {
-    const n = Number(mod[1]);
-    if (!n) return true;
-    const remainder = mod[2] !== void 0 ? Number(mod[2]) : 0;
-    return Number(value) % n === remainder;
-  }
-  const cmp = /^(>=|<=|!=|<>|>|<|=)\s*(-?\d+(?:\.\d+)?)$/.exec(f);
-  if (cmp) {
-    const num = Number(value);
-    if (Number.isNaN(num)) return false;
-    const rhs = Number(cmp[2]);
-    switch (cmp[1]) {
-      case ">":
-        return num > rhs;
-      case ">=":
-        return num >= rhs;
-      case "<":
-        return num < rhs;
-      case "<=":
-        return num <= rhs;
-      case "=":
-        return num === rhs;
-      default:
-        return num !== rhs;
-    }
-  }
-  return value.toLowerCase().includes(f.toLowerCase());
+	const f = filter.trim();
+	if (!f) return true;
+	const mod = /^%\s*(\d+)(?:\s*=\s*(-?\d+))?$/.exec(f);
+	if (mod) {
+		const n = Number(mod[1]);
+		if (!n) return true;
+		const remainder = mod[2] !== void 0 ? Number(mod[2]) : 0;
+		return Number(value) % n === remainder;
+	}
+	const cmp = /^(>=|<=|!=|<>|>|<|=)\s*(-?\d+(?:\.\d+)?)$/.exec(f);
+	if (cmp) {
+		const num = Number(value);
+		if (Number.isNaN(num)) return false;
+		const rhs = Number(cmp[2]);
+		switch (cmp[1]) {
+			case ">": return num > rhs;
+			case ">=": return num >= rhs;
+			case "<": return num < rhs;
+			case "<=": return num <= rhs;
+			case "=": return num === rhs;
+			default: return num !== rhs;
+		}
+	}
+	return value.toLowerCase().includes(f.toLowerCase());
 }
 function colToLabel(col) {
-  let n = col + 1;
-  let s = "";
-  while (n > 0) {
-    const rem = (n - 1) % 26;
-    s = String.fromCharCode(65 + rem) + s;
-    n = Math.floor((n - 1) / 26);
-  }
-  return s;
+	let n = col + 1;
+	let s = "";
+	while (n > 0) {
+		const rem = (n - 1) % 26;
+		s = String.fromCharCode(65 + rem) + s;
+		n = Math.floor((n - 1) / 26);
+	}
+	return s;
 }
 function labelToCol(label) {
-  let n = 0;
-  for (const ch of label.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
-  return n - 1;
+	let n = 0;
+	for (const ch of label.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
+	return n - 1;
 }
+/** `"B3"` → `{ row: 2, col: 1 }`, or `null` if not a valid A1 address. */
 function parseAddress(address) {
-  const m = /^([A-Za-z]+)(\d+)$/.exec(address.trim());
-  if (!m) return null;
-  return { row: Number(m[2]) - 1, col: labelToCol(m[1]) };
+	const m = /^([A-Za-z]+)(\d+)$/.exec(address.trim());
+	if (!m) return null;
+	return {
+		row: Number(m[2]) - 1,
+		col: labelToCol(m[1])
+	};
 }
+/**
+* The headless spreadsheet engine: dimensions, a per-cell raw-value store synced
+* from `rows().data`, a 2D range-selection model, an edit buffer, and the bulk
+* operations (fill, clear, TSV copy/paste). No DOM, no JSX — the component wires
+* events to these actions and reads the accessors to render.
+*/
 function createBulkEditorState(options) {
-  const evaluate = options.evaluate ?? ((ctx) => ctx.raw);
-  const [columnOrder, setColumnOrderState] = createSignal(null);
-  const columns = createMemo(() => {
-    const cols = options.columns();
-    const order = columnOrder();
-    if (!order) return cols;
-    const byKey = new Map(cols.map((c) => [c.key, c]));
-    const ordered = order.map((k) => byKey.get(k)).filter((c) => !!c);
-    for (const c of cols) if (!order.includes(c.key)) ordered.push(c);
-    return ordered;
-  });
-  const baseData = createMemo(() => options.rows().filter((r) => !r.isGroup));
-  const rowById = createMemo(() => {
-    const m = /* @__PURE__ */ new Map();
-    for (const r of options.rows()) if (!r.isGroup) m.set(r.id, r);
-    return m;
-  });
-  const dataRows = createMemo(() => applyView());
-  const rowCount = createMemo(() => dataRows().length);
-  const colCount = createMemo(() => columns().length);
-  const rowAt = (r) => dataRows()[r];
-  const colAt = (c) => columns()[c];
-  const cr = (n) => clampTo(n, rowCount() - 1);
-  const cc = (n) => clampTo(n, colCount() - 1);
-  const cellAddress = (r, c) => `${colToLabel(c)}${r + 1}`;
-  const cellSigs = /* @__PURE__ */ new Map();
-  const key = (rowId, colKey) => `${rowId}::${colKey}`;
-  const ensure = (rowId, colKey, init) => {
-    const k = key(rowId, colKey);
-    let sig = cellSigs.get(k);
-    if (!sig) {
-      sig = createSignal(init);
-      cellSigs.set(k, sig);
-    }
-    return sig;
-  };
-  untrack(() => {
-    const cols = options.columns();
-    for (const row of options.rows()) {
-      if (row.isGroup || !row.data) continue;
-      for (const col of cols) ensure(row.id, col.key, row.data[col.key] ?? "");
-    }
-  });
-  createEffect(() => {
-    const cols = columns();
-    for (const row of options.rows()) {
-      if (row.isGroup || !row.data) continue;
-      for (const col of cols) {
-        const val = row.data[col.key] ?? "";
-        const sig = cellSigs.get(key(row.id, col.key));
-        if (!sig) ensure(row.id, col.key, val);
-        else if (untrack(sig[0]) !== val) sig[1](val);
-      }
-    }
-  });
-  const getRaw = (rowId, colKey) => {
-    const sig = cellSigs.get(key(rowId, colKey));
-    return sig ? sig[0]() : "";
-  };
-  const isColumnReadOnly = (col) => !!col.readOnly || !!col.compute;
-  const [lockedCells, setLockedCells] = createSignal(/* @__PURE__ */ new Set());
-  const isCellLocked = (rowId, colKey) => lockedCells().has(key(rowId, colKey));
-  const isCellLockedAt = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    return row && col ? isCellLocked(row.id, col.key) : false;
-  };
-  const setCellLocked = (rowId, colKey, locked) => setLockedCells((prev) => {
-    const next = new Set(prev);
-    if (locked) next.add(key(rowId, colKey));
-    else next.delete(key(rowId, colKey));
-    return next;
-  });
-  const toggleCellLock = (rowId, colKey) => setCellLocked(rowId, colKey, !isCellLocked(rowId, colKey));
-  const lockableCols = () => columns().filter((c) => !isColumnReadOnly(c));
-  const getRowLockState = (rowId) => {
-    const cols = lockableCols();
-    if (!cols.length) return "none";
-    let locked = 0;
-    for (const col of cols) if (isCellLocked(rowId, col.key)) locked++;
-    return locked === 0 ? "none" : locked === cols.length ? "all" : "some";
-  };
-  const toggleRowLock = (rowId) => {
-    const lockAll = getRowLockState(rowId) !== "all";
-    setLockedCells((prev) => {
-      const next = new Set(prev);
-      for (const col of lockableCols()) {
-        const k = key(rowId, col.key);
-        if (lockAll) next.add(k);
-        else next.delete(k);
-      }
-      return next;
-    });
-  };
-  const getColumnLockState = (colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    const rows = baseData();
-    if (!col || isColumnReadOnly(col) || !rows.length) return "none";
-    let locked = 0;
-    for (const row of rows) if (isCellLocked(row.id, colKey)) locked++;
-    return locked === 0 ? "none" : locked === rows.length ? "all" : "some";
-  };
-  const toggleColumnLock = (colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    if (!col || isColumnReadOnly(col)) return;
-    const lockAll = getColumnLockState(colKey) !== "all";
-    setLockedCells((prev) => {
-      const next = new Set(prev);
-      for (const row of baseData()) {
-        const k = key(row.id, colKey);
-        if (lockAll) next.add(k);
-        else next.delete(k);
-      }
-      return next;
-    });
-  };
-  const lockSelection = (locked) => {
-    const rng = untrack(selectionRange);
-    if (!rng) return;
-    setLockedCells((prev) => {
-      const next = new Set(prev);
-      for (let r = rng.r1; r <= rng.r2; r++)
-        for (let c = rng.c1; c <= rng.c2; c++) {
-          const row = rowAt(r);
-          const col = colAt(c);
-          if (!row || !col || isColumnReadOnly(col)) continue;
-          const k = key(row.id, col.key);
-          if (locked) next.add(k);
-          else next.delete(k);
-        }
-      return next;
-    });
-  };
-  const resolveRef = (address, visited) => {
-    const pos = parseAddress(address);
-    if (!pos) return "";
-    const target = baseData()[pos.row];
-    const targetCol = columns()[pos.col];
-    if (!target || !targetCol) return "";
-    return getComputed(target.id, targetCol.key, visited);
-  };
-  const getComputed = (rowId, colKey, seen) => {
-    const row = rowById().get(rowId);
-    const col = columns().find((c) => c.key === colKey);
-    if (!row || !col) return getRaw(rowId, colKey);
-    const visited = seen ?? /* @__PURE__ */ new Set();
-    const self = key(rowId, colKey);
-    if (visited.has(self)) return ERR.cycle;
-    visited.add(self);
-    try {
-      if (col.compute) return col.compute({ row, col, get: (a) => resolveRef(a, visited) });
-      return evaluate({ raw: getRaw(rowId, colKey), row, col, get: (a) => resolveRef(a, visited) });
-    } finally {
-      visited.delete(self);
-    }
-  };
-  const getDisplay = (rowId, colKey) => {
-    const computed = getComputed(rowId, colKey);
-    const col = columns().find((c) => c.key === colKey);
-    const row = rowById().get(rowId);
-    return col?.format && row ? col.format(computed, { row, col }) : computed;
-  };
-  const [sort, setSortState] = createSignal(null);
-  const [columnFilters, setColumnFilters] = createSignal(/* @__PURE__ */ new Map());
-  const compareRows = (a, b, colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    const va = getComputed(a.id, colKey);
-    const vb = getComputed(b.id, colKey);
-    if (col?.type === "number") return (Number(va) || 0) - (Number(vb) || 0);
-    return va.localeCompare(vb, void 0, { numeric: true });
-  };
-  function applyView() {
-    let rows = baseData();
-    const activeFilters = [...columnFilters().entries()].filter(([, t]) => t);
-    if (activeFilters.length) {
-      rows = rows.filter((row) => activeFilters.every(([colKey, text]) => matchesFilter(getComputed(row.id, colKey), text)));
-    }
-    const s = sort();
-    if (s) rows = [...rows].sort((a, b) => compareRows(a, b, s.colKey) * (s.dir === "asc" ? 1 : -1));
-    return rows;
-  }
-  const isViewActive = createMemo(() => sort() !== null || [...columnFilters().values()].some((t) => t));
-  const viewRows = createMemo(() => isViewActive() ? applyView() : options.rows());
-  const sortBy = (colKey) => setSortState(
-    (cur) => !cur || cur.colKey !== colKey ? { colKey, dir: "asc" } : cur.dir === "asc" ? { colKey, dir: "desc" } : null
-  );
-  const setSort = (next) => setSortState(next);
-  const getColumnFilter = (colKey) => columnFilters().get(colKey) ?? "";
-  const setColumnFilter = (colKey, text) => setColumnFilters((prev) => {
-    const next = new Map(prev);
-    if (text) next.set(colKey, text);
-    else next.delete(colKey);
-    return next;
-  });
-  const clearFilters = () => setColumnFilters(/* @__PURE__ */ new Map());
-  const [columnWidths, setColumnWidths] = createSignal(/* @__PURE__ */ new Map());
-  const setColumnWidth = (colKey, width) => setColumnWidths((prev) => {
-    const next = new Map(prev);
-    next.set(colKey, Math.max(MIN_COL_WIDTH, Math.round(width)));
-    return next;
-  });
-  const resetColumnWidth = (colKey) => setColumnWidths((prev) => {
-    if (!prev.has(colKey)) return prev;
-    const next = new Map(prev);
-    next.delete(colKey);
-    return next;
-  });
-  const setColumnOrder = (keys) => setColumnOrderState(keys);
-  const moveColumn = (fromKey, toKey) => {
-    const order = columns().map((c) => c.key);
-    const from = order.indexOf(fromKey);
-    const to = order.indexOf(toKey);
-    if (from < 0 || to < 0 || from === to) return;
-    order.splice(to, 0, order.splice(from, 1)[0]);
-    setColumnOrderState(order);
-  };
-  const getColumnAggregate = (colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    if (!col?.aggregate) return "";
-    const rows = dataRows();
-    const values = rows.map((r) => getComputed(r.id, colKey));
-    return typeof col.aggregate === "function" ? col.aggregate(values, { col, rows }) : aggregateValues(col.aggregate, values);
-  };
-  const getRawAt = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    return row && col ? getRaw(row.id, col.key) : "";
-  };
-  const getComputedAt = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    return row && col ? getComputed(row.id, col.key) : "";
-  };
-  const getDisplayAt = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    return row && col ? getDisplay(row.id, col.key) : "";
-  };
-  const [errors, setErrors] = createSignal(/* @__PURE__ */ new Map());
-  const getError = (rowId, colKey) => errors().get(key(rowId, colKey));
-  const getErrorAt = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    return row && col ? getError(row.id, col.key) : void 0;
-  };
-  const hasErrors = createMemo(() => errors().size > 0);
-  const [undoStack, setUndoStack] = createSignal([]);
-  const [redoStack, setRedoStack] = createSignal([]);
-  let recording = null;
-  const withHistory = (fn) => {
-    if (recording) return void fn();
-    recording = [];
-    batch(fn);
-    const changes = recording.filter((ch) => ch.before !== ch.after);
-    recording = null;
-    if (changes.length) {
-      setUndoStack((s) => [...s, changes]);
-      setRedoStack([]);
-    }
-  };
-  const writeCell = (rowId, colKey, value) => {
-    const before = getRaw(rowId, colKey);
-    if (recording) recording.push({ rowId, colKey, before, after: value });
-    ensure(rowId, colKey, value)[1](value);
-    const col = columns().find((c) => c.key === colKey);
-    const row = rowById().get(rowId);
-    if (col?.validate && row) {
-      const message = col.validate(value, { row, col }) || void 0;
-      setErrors((prev) => {
-        const next = new Map(prev);
-        if (message) next.set(key(rowId, colKey), message);
-        else next.delete(key(rowId, colKey));
-        return next;
-      });
-    }
-    options.onCellChange?.(rowId, colKey, value);
-  };
-  const applyWrite = (r, c, value) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    if (!row || !col || isColumnReadOnly(col) || isCellLocked(row.id, col.key)) return;
-    writeCell(row.id, col.key, value);
-  };
-  const setCellAt = (r, c, value) => withHistory(() => applyWrite(r, c, value));
-  const undo = () => {
-    const stack = undoStack();
-    if (!stack.length) return;
-    const changes = stack[stack.length - 1];
-    batch(() => {
-      for (const ch of changes) writeCell(ch.rowId, ch.colKey, ch.before);
-    });
-    setUndoStack((s) => s.slice(0, -1));
-    setRedoStack((s) => [...s, changes]);
-  };
-  const redo = () => {
-    const stack = redoStack();
-    if (!stack.length) return;
-    const changes = stack[stack.length - 1];
-    batch(() => {
-      for (const ch of changes) writeCell(ch.rowId, ch.colKey, ch.after);
-    });
-    setRedoStack((s) => s.slice(0, -1));
-    setUndoStack((s) => [...s, changes]);
-  };
-  const canUndo = createMemo(() => undoStack().length > 0);
-  const canRedo = createMemo(() => redoStack().length > 0);
-  const [selection, setSelection] = createSignal(null);
-  const selectionRange = createMemo(() => {
-    const s = selection();
-    if (!s) return null;
-    return {
-      r1: Math.min(s.anchor.row, s.focus.row),
-      r2: Math.max(s.anchor.row, s.focus.row),
-      c1: Math.min(s.anchor.col, s.focus.col),
-      c2: Math.max(s.anchor.col, s.focus.col)
-    };
-  });
-  const hasSelection = createMemo(() => selection() !== null);
-  const isSelected = (r, c) => {
-    const rng = selectionRange();
-    return !!rng && r >= rng.r1 && r <= rng.r2 && c >= rng.c1 && c <= rng.c2;
-  };
-  const isAnchor = (r, c) => {
-    const s = selection();
-    return !!s && s.anchor.row === r && s.anchor.col === c;
-  };
-  const selectCell = (r, c, extend = false) => {
-    r = cr(r);
-    c = cc(c);
-    setSelection(
-      (p) => extend && p ? { anchor: p.anchor, focus: { row: r, col: c } } : { anchor: { row: r, col: c }, focus: { row: r, col: c } }
-    );
-  };
-  const move = (dr, dc, extend = false) => {
-    if (rowCount() === 0 || colCount() === 0) return;
-    const cur = selection();
-    const from = extend && cur ? cur.focus : cur ? cur.anchor : { row: 0, col: 0 };
-    const nr = cr(from.row + dr);
-    const nc = cc(from.col + dc);
-    if (extend && cur) setSelection({ anchor: cur.anchor, focus: { row: nr, col: nc } });
-    else setSelection({ anchor: { row: nr, col: nc }, focus: { row: nr, col: nc } });
-  };
-  const selectRow = (r) => {
-    if (colCount() === 0) return;
-    r = cr(r);
-    setSelection({ anchor: { row: r, col: 0 }, focus: { row: r, col: colCount() - 1 } });
-  };
-  const selectColumn = (c) => {
-    if (rowCount() === 0) return;
-    c = cc(c);
-    setSelection({ anchor: { row: 0, col: c }, focus: { row: rowCount() - 1, col: c } });
-  };
-  const selectAll = () => {
-    if (rowCount() === 0 || colCount() === 0) return;
-    setSelection({ anchor: { row: 0, col: 0 }, focus: { row: rowCount() - 1, col: colCount() - 1 } });
-  };
-  const clearSelection = () => setSelection(null);
-  const [editing, setEditing] = createSignal(null);
-  const [editBuffer, setEditBuffer] = createSignal("");
-  const isEditing = (r, c) => {
-    const e = editing();
-    return !!e && e.row === r && e.col === c;
-  };
-  const startEdit = (r, c, initChar) => {
-    const col = colAt(c);
-    const row = rowAt(r);
-    if (!col || !row || isColumnReadOnly(col) || col.type === "checkbox" || isCellLocked(row.id, col.key)) return false;
-    batch(() => {
-      setEditing({ row: r, col: c });
-      setEditBuffer(initChar !== void 0 ? initChar : getRaw(row.id, col.key));
-    });
-    return true;
-  };
-  const commitEdit = () => {
-    const ed = untrack(editing);
-    if (!ed) return;
-    const val = untrack(editBuffer);
-    const rng = untrack(selectionRange);
-    setEditing(null);
-    withHistory(() => {
-      if (rng && (rng.r2 > rng.r1 || rng.c2 > rng.c1)) {
-        for (let r = rng.r1; r <= rng.r2; r++) for (let c = rng.c1; c <= rng.c2; c++) applyWrite(r, c, val);
-      } else {
-        applyWrite(ed.row, ed.col, val);
-      }
-    });
-  };
-  const cancelEdit = () => setEditing(null);
-  const clearRange = () => {
-    const rng = untrack(selectionRange);
-    if (!rng) return;
-    withHistory(() => {
-      for (let r = rng.r1; r <= rng.r2; r++) for (let c = rng.c1; c <= rng.c2; c++) applyWrite(r, c, "");
-    });
-  };
-  const fillDown = () => {
-    const rng = untrack(selectionRange);
-    const s = untrack(selection);
-    if (!rng || !s) return;
-    withHistory(() => {
-      for (let c = rng.c1; c <= rng.c2; c++) {
-        const val = getRawAt(s.anchor.row, c);
-        for (let r = rng.r1; r <= rng.r2; r++) {
-          if (r === s.anchor.row) continue;
-          applyWrite(r, c, val);
-        }
-      }
-    });
-  };
-  const toggleCheckbox = (r, c) => {
-    const row = rowAt(r);
-    const col = colAt(c);
-    if (!row || !col || col.type !== "checkbox" || col.readOnly) return;
-    if (col.disable?.({ row, col }) || isCellLocked(row.id, col.key)) return;
-    const next = getRaw(row.id, col.key) === "1" ? "0" : "1";
-    withHistory(() => writeCell(row.id, col.key, next));
-  };
-  const getColumnCheckedState = (colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    const rows = baseData();
-    if (!col || col.type !== "checkbox" || !rows.length) return "none";
-    let checked = 0;
-    for (const row of rows) if (getRaw(row.id, colKey) === "1") checked++;
-    return checked === 0 ? "none" : checked === rows.length ? "all" : "some";
-  };
-  const toggleColumnChecked = (colKey) => {
-    const col = columns().find((c) => c.key === colKey);
-    if (!col || col.type !== "checkbox") return;
-    const value = getColumnCheckedState(colKey) === "all" ? "0" : "1";
-    withHistory(() => {
-      for (const row of baseData()) {
-        if (isCellLocked(row.id, colKey) || col.disable?.({ row, col })) continue;
-        writeCell(row.id, colKey, value);
-      }
-    });
-  };
-  const getSelectionTSV = () => {
-    const rng = untrack(selectionRange);
-    if (!rng) return "";
-    const lines = [];
-    for (let r = rng.r1; r <= rng.r2; r++) {
-      const cells = [];
-      for (let c = rng.c1; c <= rng.c2; c++) cells.push(getComputedAt(r, c));
-      lines.push(cells.join("	"));
-    }
-    return lines.join("\n");
-  };
-  const pasteTSV = (text) => {
-    const s = untrack(selection);
-    if (!s || !text) return;
-    const grid = text.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n").map((line) => line.split("	"));
-    withHistory(() => {
-      for (let ri = 0; ri < grid.length; ri++) {
-        for (let ci = 0; ci < grid[ri].length; ci++) {
-          applyWrite(s.anchor.row + ri, s.anchor.col + ci, grid[ri][ci]);
-        }
-      }
-    });
-  };
-  untrack(() => {
-    const cols = columns();
-    const initial = /* @__PURE__ */ new Map();
-    for (const row of dataRows())
-      for (const col of cols) {
-        if (!col.validate) continue;
-        const msg = col.validate(getRaw(row.id, col.key), { row, col }) || void 0;
-        if (msg) initial.set(key(row.id, col.key), msg);
-      }
-    if (initial.size) setErrors(initial);
-  });
-  return {
-    columns,
-    dataRows,
-    viewRows,
-    rowCount,
-    colCount,
-    sort,
-    sortBy,
-    setSort,
-    columnWidths,
-    setColumnWidth,
-    resetColumnWidth,
-    columnOrder,
-    setColumnOrder,
-    moveColumn,
-    getColumnAggregate,
-    columnFilters,
-    getColumnFilter,
-    setColumnFilter,
-    clearFilters,
-    rowAt,
-    colAt,
-    cellAddress,
-    getRaw,
-    getComputed: (rowId, colKey) => getComputed(rowId, colKey),
-    getDisplay,
-    getRawAt,
-    getComputedAt,
-    getDisplayAt,
-    setCellAt,
-    isColumnReadOnly,
-    lockedCells,
-    isCellLocked,
-    isCellLockedAt,
-    setCellLocked,
-    toggleCellLock,
-    getRowLockState,
-    toggleRowLock,
-    getColumnLockState,
-    toggleColumnLock,
-    lockSelection,
-    errors,
-    getError,
-    getErrorAt,
-    hasErrors,
-    selection,
-    selectionRange,
-    hasSelection,
-    isSelected,
-    isAnchor,
-    selectCell,
-    move,
-    selectRow,
-    selectColumn,
-    selectAll,
-    clearSelection,
-    editing,
-    editBuffer,
-    setEditBuffer,
-    isEditing,
-    startEdit,
-    commitEdit,
-    cancelEdit,
-    clearRange,
-    fillDown,
-    toggleCheckbox,
-    getColumnCheckedState,
-    toggleColumnChecked,
-    getSelectionTSV,
-    pasteTSV,
-    undo,
-    redo,
-    canUndo,
-    canRedo
-  };
+	const evaluate = options.evaluate ?? ((ctx) => ctx.raw);
+	const [columnOrder, setColumnOrderState] = createSignal(null);
+	const columns = createMemo(() => {
+		const cols = options.columns();
+		const order = columnOrder();
+		if (!order) return cols;
+		const byKey = new Map(cols.map((c) => [c.key, c]));
+		const ordered = order.map((k) => byKey.get(k)).filter((c) => !!c);
+		for (const c of cols) if (!order.includes(c.key)) ordered.push(c);
+		return ordered;
+	});
+	const baseData = createMemo(() => options.rows().filter((r) => !r.isGroup));
+	const rowById = createMemo(() => {
+		const m = /* @__PURE__ */ new Map();
+		for (const r of options.rows()) if (!r.isGroup) m.set(r.id, r);
+		return m;
+	});
+	const dataRows = createMemo(() => applyView());
+	const rowCount = createMemo(() => dataRows().length);
+	const colCount = createMemo(() => columns().length);
+	const rowAt = (r) => dataRows()[r];
+	const colAt = (c) => columns()[c];
+	const cr = (n) => clampTo(n, rowCount() - 1);
+	const cc = (n) => clampTo(n, colCount() - 1);
+	const cellAddress = (r, c) => `${colToLabel(c)}${r + 1}`;
+	const cellSigs = /* @__PURE__ */ new Map();
+	const key = (rowId, colKey) => `${rowId}::${colKey}`;
+	const ensure = (rowId, colKey, init) => {
+		const k = key(rowId, colKey);
+		let sig = cellSigs.get(k);
+		if (!sig) {
+			sig = createSignal(init);
+			cellSigs.set(k, sig);
+		}
+		return sig;
+	};
+	untrack(() => {
+		const cols = options.columns();
+		for (const row of options.rows()) {
+			if (row.isGroup || !row.data) continue;
+			for (const col of cols) ensure(row.id, col.key, row.data[col.key] ?? "");
+		}
+	});
+	createEffect(() => {
+		const cols = columns();
+		for (const row of options.rows()) {
+			if (row.isGroup || !row.data) continue;
+			for (const col of cols) {
+				const val = row.data[col.key] ?? "";
+				const sig = cellSigs.get(key(row.id, col.key));
+				if (!sig) ensure(row.id, col.key, val);
+				else if (untrack(sig[0]) !== val) sig[1](val);
+			}
+		}
+	});
+	const getRaw = (rowId, colKey) => {
+		const sig = cellSigs.get(key(rowId, colKey));
+		return sig ? sig[0]() : "";
+	};
+	const isColumnReadOnly = (col) => !!col.readOnly || !!col.compute;
+	const [lockedCells, setLockedCells] = createSignal(/* @__PURE__ */ new Set());
+	const isCellLocked = (rowId, colKey) => lockedCells().has(key(rowId, colKey));
+	const isCellLockedAt = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		return row && col ? isCellLocked(row.id, col.key) : false;
+	};
+	const setCellLocked = (rowId, colKey, locked) => setLockedCells((prev) => {
+		const next = new Set(prev);
+		if (locked) next.add(key(rowId, colKey));
+		else next.delete(key(rowId, colKey));
+		return next;
+	});
+	const toggleCellLock = (rowId, colKey) => setCellLocked(rowId, colKey, !isCellLocked(rowId, colKey));
+	const lockableCols = () => columns().filter((c) => !isColumnReadOnly(c));
+	const getRowLockState = (rowId) => {
+		const cols = lockableCols();
+		if (!cols.length) return "none";
+		let locked = 0;
+		for (const col of cols) if (isCellLocked(rowId, col.key)) locked++;
+		return locked === 0 ? "none" : locked === cols.length ? "all" : "some";
+	};
+	const toggleRowLock = (rowId) => {
+		const lockAll = getRowLockState(rowId) !== "all";
+		setLockedCells((prev) => {
+			const next = new Set(prev);
+			for (const col of lockableCols()) {
+				const k = key(rowId, col.key);
+				if (lockAll) next.add(k);
+				else next.delete(k);
+			}
+			return next;
+		});
+	};
+	const getColumnLockState = (colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		const rows = baseData();
+		if (!col || isColumnReadOnly(col) || !rows.length) return "none";
+		let locked = 0;
+		for (const row of rows) if (isCellLocked(row.id, colKey)) locked++;
+		return locked === 0 ? "none" : locked === rows.length ? "all" : "some";
+	};
+	const toggleColumnLock = (colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		if (!col || isColumnReadOnly(col)) return;
+		const lockAll = getColumnLockState(colKey) !== "all";
+		setLockedCells((prev) => {
+			const next = new Set(prev);
+			for (const row of baseData()) {
+				const k = key(row.id, colKey);
+				if (lockAll) next.add(k);
+				else next.delete(k);
+			}
+			return next;
+		});
+	};
+	const lockSelection = (locked) => {
+		const rng = untrack(selectionRange);
+		if (!rng) return;
+		setLockedCells((prev) => {
+			const next = new Set(prev);
+			for (let r = rng.r1; r <= rng.r2; r++) for (let c = rng.c1; c <= rng.c2; c++) {
+				const row = rowAt(r);
+				const col = colAt(c);
+				if (!row || !col || isColumnReadOnly(col)) continue;
+				const k = key(row.id, col.key);
+				if (locked) next.add(k);
+				else next.delete(k);
+			}
+			return next;
+		});
+	};
+	const resolveRef = (address, visited) => {
+		const pos = parseAddress(address);
+		if (!pos) return "";
+		const target = baseData()[pos.row];
+		const targetCol = columns()[pos.col];
+		if (!target || !targetCol) return "";
+		return getComputed(target.id, targetCol.key, visited);
+	};
+	const getComputed = (rowId, colKey, seen) => {
+		const row = rowById().get(rowId);
+		const col = columns().find((c) => c.key === colKey);
+		if (!row || !col) return getRaw(rowId, colKey);
+		const visited = seen ?? /* @__PURE__ */ new Set();
+		const self = key(rowId, colKey);
+		if (visited.has(self)) return ERR.cycle;
+		visited.add(self);
+		try {
+			if (col.compute) return col.compute({
+				row,
+				col,
+				get: (a) => resolveRef(a, visited)
+			});
+			return evaluate({
+				raw: getRaw(rowId, colKey),
+				row,
+				col,
+				get: (a) => resolveRef(a, visited)
+			});
+		} finally {
+			visited.delete(self);
+		}
+	};
+	const getDisplay = (rowId, colKey) => {
+		const computed = getComputed(rowId, colKey);
+		const col = columns().find((c) => c.key === colKey);
+		const row = rowById().get(rowId);
+		return col?.format && row ? col.format(computed, {
+			row,
+			col
+		}) : computed;
+	};
+	const [sort, setSortState] = createSignal(null);
+	const [columnFilters, setColumnFilters] = createSignal(/* @__PURE__ */ new Map());
+	const compareRows = (a, b, colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		const va = getComputed(a.id, colKey);
+		const vb = getComputed(b.id, colKey);
+		if (col?.type === "number") return (Number(va) || 0) - (Number(vb) || 0);
+		return va.localeCompare(vb, void 0, { numeric: true });
+	};
+	function applyView() {
+		let rows = baseData();
+		const activeFilters = [...columnFilters().entries()].filter(([, t]) => t);
+		if (activeFilters.length) rows = rows.filter((row) => activeFilters.every(([colKey, text]) => matchesFilter(getComputed(row.id, colKey), text)));
+		const s = sort();
+		if (s) rows = [...rows].sort((a, b) => compareRows(a, b, s.colKey) * (s.dir === "asc" ? 1 : -1));
+		return rows;
+	}
+	const isViewActive = createMemo(() => sort() !== null || [...columnFilters().values()].some((t) => t));
+	const viewRows = createMemo(() => isViewActive() ? applyView() : options.rows());
+	const sortBy = (colKey) => setSortState((cur) => !cur || cur.colKey !== colKey ? {
+		colKey,
+		dir: "asc"
+	} : cur.dir === "asc" ? {
+		colKey,
+		dir: "desc"
+	} : null);
+	const setSort = (next) => setSortState(next);
+	const getColumnFilter = (colKey) => columnFilters().get(colKey) ?? "";
+	const setColumnFilter = (colKey, text) => setColumnFilters((prev) => {
+		const next = new Map(prev);
+		if (text) next.set(colKey, text);
+		else next.delete(colKey);
+		return next;
+	});
+	const clearFilters = () => setColumnFilters(/* @__PURE__ */ new Map());
+	const [columnWidths, setColumnWidths] = createSignal(/* @__PURE__ */ new Map());
+	const setColumnWidth = (colKey, width) => setColumnWidths((prev) => {
+		const next = new Map(prev);
+		next.set(colKey, Math.max(MIN_COL_WIDTH, Math.round(width)));
+		return next;
+	});
+	const resetColumnWidth = (colKey) => setColumnWidths((prev) => {
+		if (!prev.has(colKey)) return prev;
+		const next = new Map(prev);
+		next.delete(colKey);
+		return next;
+	});
+	const setColumnOrder = (keys) => setColumnOrderState(keys);
+	const moveColumn = (fromKey, toKey) => {
+		const order = columns().map((c) => c.key);
+		const from = order.indexOf(fromKey);
+		const to = order.indexOf(toKey);
+		if (from < 0 || to < 0 || from === to) return;
+		order.splice(to, 0, order.splice(from, 1)[0]);
+		setColumnOrderState(order);
+	};
+	const getColumnAggregate = (colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		if (!col?.aggregate) return "";
+		const rows = dataRows();
+		const values = rows.map((r) => getComputed(r.id, colKey));
+		return typeof col.aggregate === "function" ? col.aggregate(values, {
+			col,
+			rows
+		}) : aggregateValues(col.aggregate, values);
+	};
+	const getRawAt = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		return row && col ? getRaw(row.id, col.key) : "";
+	};
+	const getComputedAt = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		return row && col ? getComputed(row.id, col.key) : "";
+	};
+	const getDisplayAt = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		return row && col ? getDisplay(row.id, col.key) : "";
+	};
+	const [errors, setErrors] = createSignal(/* @__PURE__ */ new Map());
+	const getError = (rowId, colKey) => errors().get(key(rowId, colKey));
+	const getErrorAt = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		return row && col ? getError(row.id, col.key) : void 0;
+	};
+	const hasErrors = createMemo(() => errors().size > 0);
+	const [undoStack, setUndoStack] = createSignal([]);
+	const [redoStack, setRedoStack] = createSignal([]);
+	let recording = null;
+	const withHistory = (fn) => {
+		if (recording) return void fn();
+		recording = [];
+		batch(fn);
+		const changes = recording.filter((ch) => ch.before !== ch.after);
+		recording = null;
+		if (changes.length) {
+			setUndoStack((s) => [...s, changes]);
+			setRedoStack([]);
+		}
+	};
+	const writeCell = (rowId, colKey, value) => {
+		const before = getRaw(rowId, colKey);
+		if (recording) recording.push({
+			rowId,
+			colKey,
+			before,
+			after: value
+		});
+		ensure(rowId, colKey, value)[1](value);
+		const col = columns().find((c) => c.key === colKey);
+		const row = rowById().get(rowId);
+		if (col?.validate && row) {
+			const message = col.validate(value, {
+				row,
+				col
+			}) || void 0;
+			setErrors((prev) => {
+				const next = new Map(prev);
+				if (message) next.set(key(rowId, colKey), message);
+				else next.delete(key(rowId, colKey));
+				return next;
+			});
+		}
+		options.onCellChange?.(rowId, colKey, value);
+	};
+	const applyWrite = (r, c, value) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		if (!row || !col || isColumnReadOnly(col) || isCellLocked(row.id, col.key)) return;
+		writeCell(row.id, col.key, value);
+	};
+	const setCellAt = (r, c, value) => withHistory(() => applyWrite(r, c, value));
+	const undo = () => {
+		const stack = undoStack();
+		if (!stack.length) return;
+		const changes = stack[stack.length - 1];
+		batch(() => {
+			for (const ch of changes) writeCell(ch.rowId, ch.colKey, ch.before);
+		});
+		setUndoStack((s) => s.slice(0, -1));
+		setRedoStack((s) => [...s, changes]);
+	};
+	const redo = () => {
+		const stack = redoStack();
+		if (!stack.length) return;
+		const changes = stack[stack.length - 1];
+		batch(() => {
+			for (const ch of changes) writeCell(ch.rowId, ch.colKey, ch.after);
+		});
+		setRedoStack((s) => s.slice(0, -1));
+		setUndoStack((s) => [...s, changes]);
+	};
+	const canUndo = createMemo(() => undoStack().length > 0);
+	const canRedo = createMemo(() => redoStack().length > 0);
+	const [selection, setSelection] = createSignal(null);
+	const selectionRange = createMemo(() => {
+		const s = selection();
+		if (!s) return null;
+		return {
+			r1: Math.min(s.anchor.row, s.focus.row),
+			r2: Math.max(s.anchor.row, s.focus.row),
+			c1: Math.min(s.anchor.col, s.focus.col),
+			c2: Math.max(s.anchor.col, s.focus.col)
+		};
+	});
+	const hasSelection = createMemo(() => selection() !== null);
+	const isSelected = (r, c) => {
+		const rng = selectionRange();
+		return !!rng && r >= rng.r1 && r <= rng.r2 && c >= rng.c1 && c <= rng.c2;
+	};
+	const isAnchor = (r, c) => {
+		const s = selection();
+		return !!s && s.anchor.row === r && s.anchor.col === c;
+	};
+	const selectCell = (r, c, extend = false) => {
+		r = cr(r);
+		c = cc(c);
+		setSelection((p) => extend && p ? {
+			anchor: p.anchor,
+			focus: {
+				row: r,
+				col: c
+			}
+		} : {
+			anchor: {
+				row: r,
+				col: c
+			},
+			focus: {
+				row: r,
+				col: c
+			}
+		});
+	};
+	const move = (dr, dc, extend = false) => {
+		if (rowCount() === 0 || colCount() === 0) return;
+		const cur = selection();
+		const from = extend && cur ? cur.focus : cur ? cur.anchor : {
+			row: 0,
+			col: 0
+		};
+		const nr = cr(from.row + dr);
+		const nc = cc(from.col + dc);
+		if (extend && cur) setSelection({
+			anchor: cur.anchor,
+			focus: {
+				row: nr,
+				col: nc
+			}
+		});
+		else setSelection({
+			anchor: {
+				row: nr,
+				col: nc
+			},
+			focus: {
+				row: nr,
+				col: nc
+			}
+		});
+	};
+	const selectRow = (r) => {
+		if (colCount() === 0) return;
+		r = cr(r);
+		setSelection({
+			anchor: {
+				row: r,
+				col: 0
+			},
+			focus: {
+				row: r,
+				col: colCount() - 1
+			}
+		});
+	};
+	const selectColumn = (c) => {
+		if (rowCount() === 0) return;
+		c = cc(c);
+		setSelection({
+			anchor: {
+				row: 0,
+				col: c
+			},
+			focus: {
+				row: rowCount() - 1,
+				col: c
+			}
+		});
+	};
+	const selectAll = () => {
+		if (rowCount() === 0 || colCount() === 0) return;
+		setSelection({
+			anchor: {
+				row: 0,
+				col: 0
+			},
+			focus: {
+				row: rowCount() - 1,
+				col: colCount() - 1
+			}
+		});
+	};
+	const clearSelection = () => setSelection(null);
+	const [editing, setEditing] = createSignal(null);
+	const [editBuffer, setEditBuffer] = createSignal("");
+	const isEditing = (r, c) => {
+		const e = editing();
+		return !!e && e.row === r && e.col === c;
+	};
+	const startEdit = (r, c, initChar) => {
+		const col = colAt(c);
+		const row = rowAt(r);
+		if (!col || !row || isColumnReadOnly(col) || col.type === "checkbox" || isCellLocked(row.id, col.key)) return false;
+		batch(() => {
+			setEditing({
+				row: r,
+				col: c
+			});
+			setEditBuffer(initChar !== void 0 ? initChar : getRaw(row.id, col.key));
+		});
+		return true;
+	};
+	const commitEdit = () => {
+		const ed = untrack(editing);
+		if (!ed) return;
+		const val = untrack(editBuffer);
+		const rng = untrack(selectionRange);
+		setEditing(null);
+		withHistory(() => {
+			if (rng && (rng.r2 > rng.r1 || rng.c2 > rng.c1)) for (let r = rng.r1; r <= rng.r2; r++) for (let c = rng.c1; c <= rng.c2; c++) applyWrite(r, c, val);
+			else applyWrite(ed.row, ed.col, val);
+		});
+	};
+	const cancelEdit = () => setEditing(null);
+	const clearRange = () => {
+		const rng = untrack(selectionRange);
+		if (!rng) return;
+		withHistory(() => {
+			for (let r = rng.r1; r <= rng.r2; r++) for (let c = rng.c1; c <= rng.c2; c++) applyWrite(r, c, "");
+		});
+	};
+	const fillDown = () => {
+		const rng = untrack(selectionRange);
+		const s = untrack(selection);
+		if (!rng || !s) return;
+		withHistory(() => {
+			for (let c = rng.c1; c <= rng.c2; c++) {
+				const val = getRawAt(s.anchor.row, c);
+				for (let r = rng.r1; r <= rng.r2; r++) {
+					if (r === s.anchor.row) continue;
+					applyWrite(r, c, val);
+				}
+			}
+		});
+	};
+	const toggleCheckbox = (r, c) => {
+		const row = rowAt(r);
+		const col = colAt(c);
+		if (!row || !col || col.type !== "checkbox" || col.readOnly) return;
+		if (col.disable?.({
+			row,
+			col
+		}) || isCellLocked(row.id, col.key)) return;
+		const next = getRaw(row.id, col.key) === "1" ? "0" : "1";
+		withHistory(() => writeCell(row.id, col.key, next));
+	};
+	const getColumnCheckedState = (colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		const rows = baseData();
+		if (!col || col.type !== "checkbox" || !rows.length) return "none";
+		let checked = 0;
+		for (const row of rows) if (getRaw(row.id, colKey) === "1") checked++;
+		return checked === 0 ? "none" : checked === rows.length ? "all" : "some";
+	};
+	const toggleColumnChecked = (colKey) => {
+		const col = columns().find((c) => c.key === colKey);
+		if (!col || col.type !== "checkbox") return;
+		const value = getColumnCheckedState(colKey) === "all" ? "0" : "1";
+		withHistory(() => {
+			for (const row of baseData()) {
+				if (isCellLocked(row.id, colKey) || col.disable?.({
+					row,
+					col
+				})) continue;
+				writeCell(row.id, colKey, value);
+			}
+		});
+	};
+	const getSelectionTSV = () => {
+		const rng = untrack(selectionRange);
+		if (!rng) return "";
+		const lines = [];
+		for (let r = rng.r1; r <= rng.r2; r++) {
+			const cells = [];
+			for (let c = rng.c1; c <= rng.c2; c++) cells.push(getComputedAt(r, c));
+			lines.push(cells.join("	"));
+		}
+		return lines.join("\n");
+	};
+	const pasteTSV = (text) => {
+		const s = untrack(selection);
+		if (!s || !text) return;
+		const grid = text.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n").map((line) => line.split("	"));
+		withHistory(() => {
+			for (let ri = 0; ri < grid.length; ri++) for (let ci = 0; ci < grid[ri].length; ci++) applyWrite(s.anchor.row + ri, s.anchor.col + ci, grid[ri][ci]);
+		});
+	};
+	untrack(() => {
+		const cols = columns();
+		const initial = /* @__PURE__ */ new Map();
+		for (const row of dataRows()) for (const col of cols) {
+			if (!col.validate) continue;
+			const msg = col.validate(getRaw(row.id, col.key), {
+				row,
+				col
+			}) || void 0;
+			if (msg) initial.set(key(row.id, col.key), msg);
+		}
+		if (initial.size) setErrors(initial);
+	});
+	return {
+		columns,
+		dataRows,
+		viewRows,
+		rowCount,
+		colCount,
+		sort,
+		sortBy,
+		setSort,
+		columnWidths,
+		setColumnWidth,
+		resetColumnWidth,
+		columnOrder,
+		setColumnOrder,
+		moveColumn,
+		getColumnAggregate,
+		columnFilters,
+		getColumnFilter,
+		setColumnFilter,
+		clearFilters,
+		rowAt,
+		colAt,
+		cellAddress,
+		getRaw,
+		getComputed: (rowId, colKey) => getComputed(rowId, colKey),
+		getDisplay,
+		getRawAt,
+		getComputedAt,
+		getDisplayAt,
+		setCellAt,
+		isColumnReadOnly,
+		lockedCells,
+		isCellLocked,
+		isCellLockedAt,
+		setCellLocked,
+		toggleCellLock,
+		getRowLockState,
+		toggleRowLock,
+		getColumnLockState,
+		toggleColumnLock,
+		lockSelection,
+		errors,
+		getError,
+		getErrorAt,
+		hasErrors,
+		selection,
+		selectionRange,
+		hasSelection,
+		isSelected,
+		isAnchor,
+		selectCell,
+		move,
+		selectRow,
+		selectColumn,
+		selectAll,
+		clearSelection,
+		editing,
+		editBuffer,
+		setEditBuffer,
+		isEditing,
+		startEdit,
+		commitEdit,
+		cancelEdit,
+		clearRange,
+		fillDown,
+		toggleCheckbox,
+		getColumnCheckedState,
+		toggleColumnChecked,
+		getSelectionTSV,
+		pasteTSV,
+		undo,
+		redo,
+		canUndo,
+		canRedo
+	};
 }
-export {
-  colToLabel,
-  createBulkEditorState,
-  labelToCol,
-  matchesFilter,
-  parseAddress
-};
+//#endregion
+export { colToLabel, createBulkEditorState, labelToCol, matchesFilter, parseAddress };