@bendyline/squisq 2.9.0 → 2.11.0

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-8BQMY2HV.d.ts → themeLibrary-BG3jr6mT.d.ts}

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

package/dist/transform/index.d.ts

@@ -1,7 +1,7 @@
-import { r as ColorScheme, O as Doc, k as Block } from '../Doc-DBadkoP4.js';
-import { i as PageTransformHints } from '../materializePageSection-Rss5thAj.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-CcrDFdWH.js';
+import '../types-Be6sBUBx.js';
 
 /** Identifier for a built-in or caller-registered transform style. */
 type TransformStyleId = string;

package/dist/{types-CcrDFdWH.d.ts → types-Be6sBUBx.d.ts}

@@ -463,6 +463,32 @@ interface MarkdownStrikethrough extends MarkdownNodeBase {
     type: 'delete';
     children: MarkdownInlineNode[];
 }
+/**
+ * Superscript text (`<sup>text</sup>`).
+ *
+ * Markdown has no native syntax for vertical alignment, so the source form is
+ * inline HTML — which is exactly what every importer that carries the
+ * information (DOCX `w:vertAlign`, SpreadsheetML `vertAlign`, HTML `<sup>`)
+ * can round-trip. The parser folds the `<sup>` … `</sup>` tag pair into this
+ * node so consumers treat it like {@link MarkdownStrong} rather than having to
+ * pair up two unrelated `htmlInline` nodes themselves; the serializer expands
+ * it back to the same three tokens, byte for byte.
+ *
+ * Only a BARE tag pair folds. `<sup class="fn">` keeps its attributes and stays
+ * `htmlInline`, because this node has nowhere to put them.
+ */
+interface MarkdownSuperscript extends MarkdownNodeBase {
+    type: 'superscript';
+    children: MarkdownInlineNode[];
+}
+/**
+ * Subscript text (`<sub>text</sub>`). The vertical-alignment sibling of
+ * {@link MarkdownSuperscript}; see there for how the source form round-trips.
+ */
+interface MarkdownSubscript extends MarkdownNodeBase {
+    type: 'subscript';
+    children: MarkdownInlineNode[];
+}
 /**
  * Inline code (`code`).
  */
@@ -609,7 +635,7 @@ interface MarkdownMention extends MarkdownNodeBase {
 /** Block-level content that can appear as direct children of the document root, blockquotes, list items, etc. */
 type MarkdownBlockNode = MarkdownHeading | MarkdownParagraph | MarkdownBlockquote | MarkdownList | MarkdownCodeBlock | MarkdownThematicBreak | MarkdownTable | MarkdownHtmlBlock | MarkdownMathBlock | MarkdownLinkDefinition | MarkdownFootnoteDefinition | MarkdownContainerDirective | MarkdownLeafDirective | MarkdownDefinitionList;
 /** Inline/phrasing content that appears inside paragraphs, headings, links, etc. */
-type MarkdownInlineNode = MarkdownText | MarkdownEmphasis | MarkdownStrong | MarkdownStrikethrough | MarkdownInlineCode | MarkdownLink | MarkdownImage | MarkdownBreak | MarkdownInlineHtml | MarkdownInlineMath | MarkdownFootnoteReference | MarkdownLinkReference | MarkdownImageReference | MarkdownTextDirective | MarkdownMention | MarkdownInlineIcon;
+type MarkdownInlineNode = MarkdownText | MarkdownEmphasis | MarkdownStrong | MarkdownStrikethrough | MarkdownSuperscript | MarkdownSubscript | MarkdownInlineCode | MarkdownLink | MarkdownImage | MarkdownBreak | MarkdownInlineHtml | MarkdownInlineMath | MarkdownFootnoteReference | MarkdownLinkReference | MarkdownImageReference | MarkdownTextDirective | MarkdownMention | MarkdownInlineIcon;
 /**
  * Any node in the markdown tree. Includes structural nodes (listItem,
  * tableRow, tableCell, etc.) that only appear as children of specific parents.
@@ -665,4 +691,4 @@ interface StringifyOptions {
     setext?: boolean;
 }
 
-export { TRANSITION_DIRECTIONS as $, type MarkdownLeafDirective as A, MarkdownLimitError as B, type MarkdownLink as C, DEFAULT_MARKDOWN_SAFETY_LIMITS as D, type MarkdownLinkDefinition as E, type MarkdownLinkReference as F, type MarkdownList as G, type HeadingAttributes as H, type MarkdownListItem as I, type MarkdownMathBlock as J, type MarkdownMention as K, type MarkdownNode as L, type MarkdownBlockNode as M, type MarkdownParagraph as N, type MarkdownPoint as O, type MarkdownSafetyLimits as P, type MarkdownSourcePosition as Q, type MarkdownStrikethrough as R, type MarkdownStrong as S, type MarkdownTable as T, type MarkdownTableCell as U, type MarkdownTableRow as V, type MarkdownText as W, type MarkdownTextDirective as X, type MarkdownThematicBreak as Y, type ParseOptions as Z, type StringifyOptions as _, DEFAULT_TRANSITION_DURATION_SECONDS as a, TRANSITION_TYPES as a0, type Transition as a1, type TransitionDirection as a2, type TransitionType as a3, assertMarkdownDocumentWithinLimits as a4, assertMarkdownSourceWithinLimits as a5, isTransitionType as a6, normalizeTransitionDirection as a7, normalizeTransitionType as a8, resolveBlockTransition as a9, resolveMarkdownSafetyLimits as aa, resolveTransitionDuration as ab, type BlockConnection as ac, type HeadingTemplateAnnotation as b, type HtmlComment as c, type HtmlElement as d, type HtmlNode as e, type HtmlText as f, type MarkdownBlockquote as g, type MarkdownBreak as h, type MarkdownCodeBlock as i, type MarkdownContainerDirective as j, type MarkdownDefinitionDescription as k, type MarkdownDefinitionList as l, type MarkdownDefinitionTerm as m, type MarkdownDocument as n, type MarkdownEmphasis as o, type MarkdownFootnoteDefinition as p, type MarkdownFootnoteReference as q, type MarkdownHeading as r, type MarkdownHtmlBlock as s, type MarkdownImage as t, type MarkdownImageReference as u, type MarkdownInlineCode as v, type MarkdownInlineHtml as w, type MarkdownInlineIcon as x, type MarkdownInlineMath as y, type MarkdownInlineNode as z };
+export { type ParseOptions as $, type MarkdownLeafDirective as A, MarkdownLimitError as B, type MarkdownLink as C, DEFAULT_MARKDOWN_SAFETY_LIMITS as D, type MarkdownLinkDefinition as E, type MarkdownLinkReference as F, type MarkdownList as G, type HeadingAttributes as H, type MarkdownListItem as I, type MarkdownMathBlock as J, type MarkdownMention as K, type MarkdownNode as L, type MarkdownBlockNode as M, type MarkdownParagraph as N, type MarkdownPoint as O, type MarkdownSafetyLimits as P, type MarkdownSourcePosition as Q, type MarkdownStrikethrough as R, type MarkdownStrong as S, type MarkdownSubscript as T, type MarkdownSuperscript as U, type MarkdownTable as V, type MarkdownTableCell as W, type MarkdownTableRow as X, type MarkdownText as Y, type MarkdownTextDirective as Z, type MarkdownThematicBreak as _, DEFAULT_TRANSITION_DURATION_SECONDS as a, type StringifyOptions as a0, TRANSITION_DIRECTIONS as a1, TRANSITION_TYPES as a2, type Transition as a3, type TransitionDirection as a4, type TransitionType as a5, assertMarkdownDocumentWithinLimits as a6, assertMarkdownSourceWithinLimits as a7, isTransitionType as a8, normalizeTransitionDirection as a9, normalizeTransitionType as aa, resolveBlockTransition as ab, resolveMarkdownSafetyLimits as ac, resolveTransitionDuration as ad, type BlockConnection as ae, type HeadingTemplateAnnotation as b, type HtmlComment as c, type HtmlElement as d, type HtmlNode as e, type HtmlText as f, type MarkdownBlockquote as g, type MarkdownBreak as h, type MarkdownCodeBlock as i, type MarkdownContainerDirective as j, type MarkdownDefinitionDescription as k, type MarkdownDefinitionList as l, type MarkdownDefinitionTerm as m, type MarkdownDocument as n, type MarkdownEmphasis as o, type MarkdownFootnoteDefinition as p, type MarkdownFootnoteReference as q, type MarkdownHeading as r, type MarkdownHtmlBlock as s, type MarkdownImage as t, type MarkdownImageReference as u, type MarkdownInlineCode as v, type MarkdownInlineHtml as w, type MarkdownInlineIcon as x, type MarkdownInlineMath as y, type MarkdownInlineNode as z };

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.9.0",
+  "version": "2.11.0",
   "description": "Headless utilities for doc/block rendering, spatial math, Markdown, and storage",
   "license": "MIT",
   "author": "Bendyline",
@@ -126,6 +126,16 @@
       "types": "./dist/fence/index.d.ts",
       "import": "./dist/fence/index.js",
       "default": "./dist/fence/index.js"
+    },
+    "./proof": {
+      "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": {