@bendyline/squisq 2.10.0 → 2.11.1

package/dist/table/index.d.ts

@@ -0,0 +1,123 @@
+import { T as TableViewState, V as ViewIssue } from '../viewState-lTZS-hP_.js';
+export { E as EMPTY_TABLE_VIEW_STATE, F as FilterClause, a as FilterOp, P as ParsedTableViewState, S as SortTerm, i as inferNumericColumn, b as isEmptyViewState, c as isNumericCellText, m as makeTableCollator, p as parseTableViewState, q as quoteViewToken, s as serializeTableViewState } from '../viewState-lTZS-hP_.js';
+
+/**
+ * Reference implementation of table view state over a plain string matrix —
+ * the semantics contract the grid's worker kernel is parity-tested against,
+ * and what the sidecar data readers apply before windowing so previews and
+ * exports show the author's curated view.
+ *
+ * Semantics:
+ *  - filter first (AND conjunction), then a STABLE multi-term sort;
+ *  - a column is numeric per `inferNumericColumn` (all non-blank cells
+ *    numeric, no leading-zero strings) — numeric columns compare by value,
+ *    everything else via the shared collator (`numeric: true`, so "v2" <
+ *    "v10" in text columns too);
+ *  - blank cells sort LAST regardless of direction (Excel behavior) and
+ *    match only `= ''` / `!=` filters;
+ *  - text-matching ops (`= != ~ !~ ^~ $~`) are case-INSENSITIVE by default
+ *    (Excel AutoFilter semantics); `clause.caseSensitive` (`*` in the
+ *    grammar) makes them exact-case. Numeric equality is unaffected.
+ */
+
+interface AppliedTableView {
+    /** Filtered + sorted rows (the same row arrays, re-ordered — not copies). */
+    rows: string[][];
+    /** Source-row index (0-based, header excluded) per output row. */
+    rowIds: number[];
+    /** Row count before filtering (equals `rows.length` with no filter). */
+    unfilteredRowCount: number;
+}
+/**
+ * Apply `view` to `rows`. Row identity is positional: `rowIds[i]` is the
+ * index of output row `i` in the input `rows`.
+ */
+declare function applyTableViewState(headers: readonly string[], rows: readonly (readonly string[])[], view: TableViewState): AppliedTableView;
+
+/**
+ * TableQueryProvider — the async, worker-ready contract a data grid renders
+ * against and a query backend implements. The default implementation is the
+ * in-house columnar worker store in `@bendyline/squisq-grid-react`; heavier
+ * backends (SQL engines, remote services) implement the same surface later.
+ *
+ * Design constraints baked in:
+ *  - Everything is async: the reference backend lives in a Web Worker, and
+ *    retrofitting async under a sync grid API is painful — so the contract
+ *    is async from day one and renderers use windowed prefetch.
+ *  - View state (sort/filter) is provider-side: the renderer never holds
+ *    more than a window of rows, so ordering/filtering must happen where
+ *    the full dataset lives.
+ *  - Row identity is the immutable SOURCE row index (`rowId`), assigned at
+ *    ingest — stable under any permutation and unaffected by edits changing
+ *    sort keys.
+ */
+
+type TableColumnKind = 'number' | 'string' | 'date' | 'boolean';
+interface TableColumnSchema {
+    name: string;
+    kind: TableColumnKind;
+}
+interface TableSchema {
+    columns: TableColumnSchema[];
+    /** Total data rows in the source (before any filter). */
+    rowCount: number;
+}
+/** A cell value as providers exchange it. `null` = blank. */
+type TableCellValue = string | number | boolean | null;
+interface TableRowsPage {
+    /** View-coordinate index of the first returned row. */
+    start: number;
+    /** Source row id per returned row (edit/selection identity). */
+    rowIds: number[];
+    /** Raw values; formatting is the renderer's job. */
+    cells: TableCellValue[][];
+}
+interface TableViewResult {
+    /** Row count AFTER the active filter (the virtualizer's row count). */
+    viewRowCount: number;
+    issues: ViewIssue[];
+}
+interface TableCellEdit {
+    rowId: number;
+    col: number;
+    value: TableCellValue;
+}
+interface TableEditResult {
+    /**
+     * True when an edited cell touched an active sort/filter column — the
+     * current permutation may be outdated. Providers NEVER auto re-sort on
+     * edit (a row teleporting out from under the caret is hostile); the
+     * renderer offers an explicit refresh.
+     */
+    staleView: boolean;
+}
+/** Result of a {@link TableQueryProvider.distinct} sweep over one column. */
+interface TableDistinctResult {
+    /**
+     * Distinct non-blank values as display text, sorted (numerically for
+     * numeric columns, collated otherwise), capped at the requested limit.
+     */
+    values: string[];
+    /** Total distinct non-blank values in the column (may exceed `values`). */
+    totalDistinct: number;
+    /** Whether any cell in the column is blank. */
+    hasBlank: boolean;
+}
+interface TableQueryProvider {
+    describe(): Promise<TableSchema>;
+    /** Apply a view; subsequent `rows()` windows are in view coordinates. */
+    setView(view: TableViewState): Promise<TableViewResult>;
+    rows(start: number, count: number): Promise<TableRowsPage>;
+    /** Optional: providers without write support omit it (read-only grid). */
+    applyEdits?(edits: TableCellEdit[]): Promise<TableEditResult>;
+    /**
+     * Optional: distinct values of one column over the FULL source (not the
+     * filtered view), for value-picker UIs. Cheap for the columnar store —
+     * string columns are dictionary-encoded — so renderers feature-detect
+     * this rather than aggregating rows themselves.
+     */
+    distinct?(col: number, limit: number): Promise<TableDistinctResult>;
+    dispose(): void;
+}
+
+export { type AppliedTableView, type TableCellEdit, type TableCellValue, type TableColumnKind, type TableColumnSchema, type TableDistinctResult, type TableEditResult, type TableQueryProvider, type TableRowsPage, type TableSchema, type TableViewResult, TableViewState, ViewIssue, applyTableViewState };

package/dist/table/index.js

@@ -0,0 +1,298 @@
+// src/table/viewState.ts
+var TEXT_FILTER_OPS = ["=", "!=", "~", "!~", "^~", "$~"];
+var EMPTY_TABLE_VIEW_STATE = Object.freeze({
+  sort: [],
+  filter: []
+});
+function isEmptyViewState(view) {
+  return view.sort.length === 0 && view.filter.length === 0;
+}
+function isNumericCellText(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (/^0\d/.test(trimmed)) return false;
+  return Number.isFinite(Number(trimmed));
+}
+function inferNumericColumn(rows, col) {
+  let sawValue = false;
+  for (const row of rows) {
+    const cell = row[col] ?? "";
+    if (cell.trim() === "") continue;
+    if (!isNumericCellText(cell)) return false;
+    sawValue = true;
+  }
+  return sawValue;
+}
+function makeTableCollator() {
+  return new Intl.Collator(void 0, { numeric: true });
+}
+var NEEDS_INNER_QUOTING_RE = /[,:;=!<>~"^$*]|^\s|\s$/;
+function quoteViewToken(text) {
+  if (text === "" || NEEDS_INNER_QUOTING_RE.test(text)) {
+    return `"${text.replace(/"/g, '""')}"`;
+  }
+  return text;
+}
+function readQuoted(scanner) {
+  let out = "";
+  let i = scanner.pos + 1;
+  const { text } = scanner;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      if (text[i + 1] === '"') {
+        out += '"';
+        i += 2;
+        continue;
+      }
+      scanner.pos = i + 1;
+      return out;
+    }
+    out += ch;
+    i++;
+  }
+  return null;
+}
+function readBare(scanner, stops) {
+  const { text } = scanner;
+  let i = scanner.pos;
+  while (i < text.length && !stops.includes(text[i])) i++;
+  const out = text.slice(scanner.pos, i);
+  scanner.pos = i;
+  return out.trim();
+}
+function skipSpaces(scanner) {
+  while (scanner.text[scanner.pos] === " ") scanner.pos++;
+}
+var FILTER_OP_TOKENS = [
+  { token: ">=", op: ">=", caseSensitive: false },
+  { token: "<=", op: "<=", caseSensitive: false },
+  { token: "!~*", op: "!~", caseSensitive: true },
+  { token: "!~", op: "!~", caseSensitive: false },
+  { token: "!=*", op: "!=", caseSensitive: true },
+  { token: "!=", op: "!=", caseSensitive: false },
+  { token: "^~*", op: "^~", caseSensitive: true },
+  { token: "^~", op: "^~", caseSensitive: false },
+  { token: "$~*", op: "$~", caseSensitive: true },
+  { token: "$~", op: "$~", caseSensitive: false },
+  { token: "~*", op: "~", caseSensitive: true },
+  { token: "~", op: "~", caseSensitive: false },
+  { token: "=*", op: "=", caseSensitive: true },
+  { token: "=", op: "=", caseSensitive: false },
+  { token: ">", op: ">", caseSensitive: false },
+  { token: "<", op: "<", caseSensitive: false }
+];
+function parseSortParam(raw) {
+  const scanner = { text: raw, pos: 0 };
+  const terms = [];
+  for (; ; ) {
+    skipSpaces(scanner);
+    const column = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, ":,");
+    if (column === null || column === "") return null;
+    let dir = "asc";
+    skipSpaces(scanner);
+    if (scanner.text[scanner.pos] === ":") {
+      scanner.pos++;
+      skipSpaces(scanner);
+      const dirToken = readBare(scanner, ",").toLowerCase();
+      if (dirToken !== "asc" && dirToken !== "desc") return null;
+      dir = dirToken;
+    }
+    terms.push({ column, dir });
+    skipSpaces(scanner);
+    if (scanner.pos >= scanner.text.length) return terms;
+    if (scanner.text[scanner.pos] !== ",") return null;
+    scanner.pos++;
+  }
+}
+function parseFilterParam(raw) {
+  const scanner = { text: raw, pos: 0 };
+  const clauses = [];
+  for (; ; ) {
+    skipSpaces(scanner);
+    const column = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, "=!<>~^$;");
+    if (column === null || column === "") return null;
+    skipSpaces(scanner);
+    const rest = scanner.text.slice(scanner.pos);
+    const match = FILTER_OP_TOKENS.find((candidate) => rest.startsWith(candidate.token));
+    if (!match) return null;
+    scanner.pos += match.token.length;
+    skipSpaces(scanner);
+    const value = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, ";");
+    if (value === null) return null;
+    const clause = { column, op: match.op, value };
+    if (match.caseSensitive) clause.caseSensitive = true;
+    clauses.push(clause);
+    skipSpaces(scanner);
+    if (scanner.pos >= scanner.text.length) return clauses;
+    if (scanner.text[scanner.pos] !== ";") return null;
+    scanner.pos++;
+  }
+}
+function parseTableViewState(sortRaw, filterRaw, headers) {
+  const issues = [];
+  const known = new Set(headers);
+  let sort = [];
+  if (sortRaw !== void 0 && sortRaw.trim() !== "") {
+    const parsed = parseSortParam(sortRaw);
+    if (parsed === null) {
+      issues.push({ code: "data-view-invalid", message: `sort "${sortRaw}" could not be parsed` });
+    } else {
+      sort = parsed.filter((term) => {
+        if (known.has(term.column)) return true;
+        issues.push({
+          code: "data-view-unknown-column",
+          message: `sort column "${term.column}" is not a header`
+        });
+        return false;
+      });
+    }
+  }
+  let filter = [];
+  if (filterRaw !== void 0 && filterRaw.trim() !== "") {
+    const parsed = parseFilterParam(filterRaw);
+    if (parsed === null) {
+      issues.push({
+        code: "data-view-invalid",
+        message: `filter "${filterRaw}" could not be parsed`
+      });
+    } else {
+      filter = parsed.filter((clause) => {
+        if (known.has(clause.column)) return true;
+        issues.push({
+          code: "data-view-unknown-column",
+          message: `filter column "${clause.column}" is not a header`
+        });
+        return false;
+      });
+    }
+  }
+  return { view: { sort, filter }, issues };
+}
+function serializeTableViewState(view) {
+  const out = {};
+  if (view.sort.length > 0) {
+    out.sort = view.sort.map((term) => `${quoteViewToken(term.column)}${term.dir === "desc" ? ":desc" : ""}`).join(",");
+  }
+  if (view.filter.length > 0) {
+    out.filter = view.filter.map((clause) => {
+      const star = clause.caseSensitive === true && TEXT_FILTER_OPS.includes(clause.op) ? "*" : "";
+      return `${quoteViewToken(clause.column)}${clause.op}${star}${quoteViewToken(clause.value)}`;
+    }).join(";");
+  }
+  return out;
+}
+
+// src/table/applyTableViewState.ts
+function matchesClause(cell, clause, numericColumn, collator) {
+  const cellTrim = cell.trim();
+  const valueTrim = clause.value.trim();
+  const blank = cellTrim === "";
+  const fold = (text) => clause.caseSensitive ? text : text.toLowerCase();
+  switch (clause.op) {
+    case "=":
+      if (valueTrim === "") return blank;
+      if (blank) return false;
+      if (numericColumn && isNumericCellText(valueTrim)) {
+        return Number(cellTrim) === Number(valueTrim);
+      }
+      return fold(cellTrim) === fold(valueTrim);
+    case "!=":
+      return !matchesClause(cell, { ...clause, op: "=" }, numericColumn, collator);
+    case "~":
+      return !blank && fold(cellTrim).includes(fold(valueTrim));
+    case "!~":
+      return !matchesClause(cell, { ...clause, op: "~" }, numericColumn, collator);
+    case "^~":
+      return !blank && fold(cellTrim).startsWith(fold(valueTrim));
+    case "$~":
+      return !blank && fold(cellTrim).endsWith(fold(valueTrim));
+    case ">":
+    case "<":
+    case ">=":
+    case "<=": {
+      if (blank) return false;
+      let comparison;
+      if (numericColumn && isNumericCellText(valueTrim)) {
+        comparison = Number(cellTrim) - Number(valueTrim);
+      } else {
+        comparison = collator.compare(cellTrim, valueTrim);
+      }
+      if (clause.op === ">") return comparison > 0;
+      if (clause.op === "<") return comparison < 0;
+      if (clause.op === ">=") return comparison >= 0;
+      return comparison <= 0;
+    }
+  }
+}
+function applyTableViewState(headers, rows, view) {
+  const asMutable = rows;
+  if (isEmptyViewState(view)) {
+    return {
+      rows: [...asMutable],
+      rowIds: rows.map((_, index) => index),
+      unfilteredRowCount: rows.length
+    };
+  }
+  const collator = makeTableCollator();
+  const columnIndex = new Map(headers.map((header, index) => [header, index]));
+  const numericByCol = /* @__PURE__ */ new Map();
+  const numericFor = (col) => {
+    let cached = numericByCol.get(col);
+    if (cached === void 0) {
+      cached = inferNumericColumn(rows, col);
+      numericByCol.set(col, cached);
+    }
+    return cached;
+  };
+  const clauses = view.filter.map((clause) => ({ clause, col: columnIndex.get(clause.column) })).filter((entry) => entry.col !== void 0);
+  let rowIds = [];
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    let pass = true;
+    for (const { clause, col } of clauses) {
+      if (!matchesClause(row[col] ?? "", clause, numericFor(col), collator)) {
+        pass = false;
+        break;
+      }
+    }
+    if (pass) rowIds.push(index);
+  }
+  const terms = view.sort.map((term) => ({ term, col: columnIndex.get(term.column) })).filter(
+    (entry) => entry.col !== void 0
+  );
+  if (terms.length > 0) {
+    for (const { col } of terms) numericFor(col);
+    rowIds = [...rowIds].sort((a, b) => {
+      for (const { term, col } of terms) {
+        const left = (rows[a][col] ?? "").trim();
+        const right = (rows[b][col] ?? "").trim();
+        const leftBlank = left === "";
+        const rightBlank = right === "";
+        if (leftBlank || rightBlank) {
+          if (leftBlank && rightBlank) continue;
+          return leftBlank ? 1 : -1;
+        }
+        const comparison = numericByCol.get(col) ? Number(left) - Number(right) : collator.compare(left, right);
+        if (comparison !== 0) return term.dir === "desc" ? -comparison : comparison;
+      }
+      return a - b;
+    });
+  }
+  return {
+    rows: rowIds.map((id) => asMutable[id]),
+    rowIds,
+    unfilteredRowCount: rows.length
+  };
+}
+export {
+  EMPTY_TABLE_VIEW_STATE,
+  applyTableViewState,
+  inferNumericColumn,
+  isEmptyViewState,
+  isNumericCellText,
+  makeTableCollator,
+  parseTableViewState,
+  quoteViewToken,
+  serializeTableViewState
+};

package/dist/{themeLibrary-xaxN5UYu.d.ts → themeLibrary-BG3jr6mT.d.ts}

@@ -1,4 +1,4 @@
-import { bh as Theme, bl as ThemeRegistry } from './Doc-DTyeaFuW.js';
+import { bh as Theme, bl as ThemeRegistry } from './Doc-CRPQCkHn.js';
 
 /**
  * Built-in Theme Library

package/dist/transform/index.d.ts

@@ -1,5 +1,5 @@
-import { r as ColorScheme, O as Doc, k as Block } from '../Doc-DTyeaFuW.js';
-import { i as PageTransformHints } from '../materializePageSection-BRNIINlU.js';
+import { r as ColorScheme, O as Doc, k as Block } from '../Doc-CRPQCkHn.js';
+import { i as PageTransformHints } from '../materializePageSection-BeUPHeCl.js';
 import { d as ExtractionType, E as ExtractedElement, b as ExtractionOptions } from '../contentExtractor-BNfVJV2U.js';
 import '../types-Be6sBUBx.js';
 

package/dist/versions/index.d.ts

@@ -128,5 +128,19 @@ declare function parseVersionPath(path: string): {
     timestamp: Date;
     collision: number;
 } | null;
+/** Subfolder holding pre-save backups of DATA sidecar files. */
+declare const DATA_BACKUP_PREFIX = ".versions/data/";
+/**
+ * Build a pre-save backup path for a data sidecar file:
+ * `.versions/data/<path with '/' → '__'>.<stamp>[-n].<ext>`.
+ *
+ * The grid's save flow writes the ORIGINAL bytes here before overwriting a
+ * sidecar in place — the only cross-save undo the grid offers. Unlike
+ * `buildVersionPath` (markdown-only, single-basename), the flattened full
+ * path keeps same-named files in different folders distinct, and the
+ * extension follows the sidecar. The flattened name goes through the same
+ * safety rules as document snapshots (via a per-call strategy).
+ */
+declare function buildDataBackupPath(sidecarPath: string, date: Date, collision?: number): string;
 
-export { CoalesceOptions, DocumentVersionManager, type DocumentVersionManagerOptions, PrunePolicy, RevertOptions, RevertResult, SaveVersionOptions, SaveVersionResult, VERSIONS_PREFIX, VERSION_TIMESTAMP_PATTERN, Version, buildVersionPath, coalesceVersions, formatVersionTimestamp, getDocBasename, listVersions, parseVersionPath, parseVersionTimestamp, pruneVersions, readVersion, revertToVersion, saveVersion };
+export { CoalesceOptions, DATA_BACKUP_PREFIX, DocumentVersionManager, type DocumentVersionManagerOptions, PrunePolicy, RevertOptions, RevertResult, SaveVersionOptions, SaveVersionResult, VERSIONS_PREFIX, VERSION_TIMESTAMP_PATTERN, Version, buildDataBackupPath, buildVersionPath, coalesceVersions, formatVersionTimestamp, getDocBasename, listVersions, parseVersionPath, parseVersionTimestamp, pruneVersions, readVersion, revertToVersion, saveVersion };

package/dist/versions/index.js

@@ -1,6 +1,8 @@
 import {
+  DATA_BACKUP_PREFIX,
   DocumentVersionManager,
   VERSIONS_PREFIX,
+  buildDataBackupPath,
   buildVersionPath,
   coalesceVersions,
   getDocBasename,
@@ -10,16 +12,18 @@ import {
   readVersion,
   revertToVersion,
   saveVersion
-} from "../chunk-7YEZFHLS.js";
+} from "../chunk-O7HLQ22N.js";
 import {
   VERSION_TIMESTAMP_PATTERN,
   formatVersionTimestamp,
   parseVersionTimestamp
 } from "../chunk-OPO5K4DZ.js";
 export {
+  DATA_BACKUP_PREFIX,
   DocumentVersionManager,
   VERSIONS_PREFIX,
   VERSION_TIMESTAMP_PATTERN,
+  buildDataBackupPath,
   buildVersionPath,
   coalesceVersions,
   formatVersionTimestamp,

package/dist/viewState-lTZS-hP_.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Table view state — the non-destructive sort/filter vocabulary that rides a
+ * `{[dataTable src=… sort=… filter=…]}` annotation. The data bytes are never
+ * touched; view state is part of the DOCUMENT (an author's sort shapes the
+ * bounded previews and exports), exactly like `sheet`/`anchor` are part of
+ * the reference.
+ *
+ * Grammar (inside the param value; the whole value then rides the ordinary
+ * `{[…]}` attr quoting):
+ *
+ *   sort   := term (',' term)*
+ *   term   := colName (':' ('asc'|'desc'))?          // default asc
+ *   filter := clause (';' clause)*                    // conjunction (AND) only
+ *   clause := colName op value
+ *   op     := textOp '*'? | cmpOp
+ *   textOp := '=' | '!=' | '~' | '!~' | '^~' | '$~'
+ *   cmpOp  := '>' | '<' | '>=' | '<='
+ *
+ * Text-matching ops (`= != ~ !~ ^~ $~`) are CASE-INSENSITIVE by default
+ * (Excel AutoFilter semantics); a `*` suffix makes the match case-sensitive
+ * (`Region=*West`). `~` is contains, `^~` starts-with, `$~` ends-with (the
+ * `~` marks the text family; `^`/`$` are the regex-anchor mnemonics).
+ * Comparison ops compare numerically on numeric columns and via the shared
+ * collator otherwise, and take no `*`. Column names address headers by exact
+ * text. Names/values containing structural characters are quoted CSV-style —
+ * double quotes with `""` doubling, NO backslashes (the outer `{[…]}` layer
+ * already owns backslash escaping inside quoted attr values; stacking a
+ * second backslash grammar inside would be unreadable and fragile):
+ *
+ *   sort=Revenue:desc,Region
+ *   sort="Ratio A:B":desc
+ *   filter=Region=West;Revenue>=1000
+ *   filter=Note~"a;b"
+ *
+ * Parsing NEVER throws: an unknown column drops that term/clause with a
+ * `data-view-unknown-column` issue; malformed syntax drops the whole param
+ * with `data-view-invalid`. Renderers fall back to natural order.
+ */
+interface SortTerm {
+    column: string;
+    dir: 'asc' | 'desc';
+}
+type FilterOp = '=' | '!=' | '>' | '<' | '>=' | '<=' | '~' | '!~' | '^~' | '$~';
+interface FilterClause {
+    column: string;
+    op: FilterOp;
+    value: string;
+    /**
+     * Case-sensitive matching for text ops (serialized as a `*` op suffix).
+     * Absent/false = the default case-insensitive match. Meaningless on the
+     * comparison ops and never serialized for them.
+     */
+    caseSensitive?: boolean;
+}
+interface TableViewState {
+    sort: SortTerm[];
+    filter: FilterClause[];
+}
+interface ViewIssue {
+    code: 'data-view-unknown-column' | 'data-view-invalid';
+    message: string;
+}
+interface ParsedTableViewState {
+    view: TableViewState;
+    issues: ViewIssue[];
+}
+declare const EMPTY_TABLE_VIEW_STATE: TableViewState;
+/** True when the view state changes nothing. */
+declare function isEmptyViewState(view: TableViewState): boolean;
+/**
+ * A column is numeric iff every non-blank trimmed cell parses to a finite
+ * number AND is not a leading-zero string (`"007"` stays text — zip codes,
+ * ids). Blank cells don't vote.
+ */
+declare function isNumericCellText(value: string): boolean;
+declare function inferNumericColumn(rows: readonly (readonly string[])[], col: number): boolean;
+/** The one collator both sides of the parity contract use. */
+declare function makeTableCollator(): Intl.Collator;
+declare function quoteViewToken(text: string): string;
+/**
+ * Parse the raw `sort`/`filter` param values against real headers.
+ * Never throws; degradation is per the module contract.
+ */
+declare function parseTableViewState(sortRaw: string | undefined, filterRaw: string | undefined, headers: readonly string[]): ParsedTableViewState;
+/** Serialize to `{ sort?, filter? }` raw param values (undefined = omit). */
+declare function serializeTableViewState(view: TableViewState): {
+    sort?: string;
+    filter?: string;
+};
+
+export { EMPTY_TABLE_VIEW_STATE as E, type FilterClause as F, type ParsedTableViewState as P, type SortTerm as S, type TableViewState as T, type ViewIssue as V, type FilterOp as a, isEmptyViewState as b, isNumericCellText as c, inferNumericColumn as i, makeTableCollator as m, parseTableViewState as p, quoteViewToken as q, serializeTableViewState as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq",
-  "version": "2.10.0",
+  "version": "2.11.1",
   "description": "Headless utilities for doc/block rendering, spatial math, Markdown, and storage",
   "license": "MIT",
   "author": "Bendyline",
@@ -131,6 +131,11 @@
       "types": "./dist/proof/index.d.ts",
       "import": "./dist/proof/index.js",
       "default": "./dist/proof/index.js"
+    },
+    "./table": {
+      "types": "./dist/table/index.d.ts",
+      "import": "./dist/table/index.js",
+      "default": "./dist/table/index.js"
     }
   },
   "scripts": {