@latentic/live-markdown 0.3.0 → 0.4.0

package/dist/codemirror/table/tableInline.js

@@ -0,0 +1,105 @@
+import "../../chunk-V6TY7KAL.js";
+import { docTree, inCode } from "../core/codeContext.js";
+import { escapeAttr, escapeText } from "../core/htmlEscape.js";
+import { inlineScanRulesFacet, scanInline } from "../core/inlineScan.js";
+import { NODE_RULES } from "../core/registry.js";
+function codeText(state, node) {
+  let innerFrom = node.from;
+  let innerTo = node.to;
+  let seenMark = false;
+  for (let child = node.firstChild; child; child = child.nextSibling) {
+    if (child.name !== "CodeMark") continue;
+    if (!seenMark) {
+      innerFrom = child.to;
+      seenMark = true;
+    }
+    innerTo = child.from;
+  }
+  return state.sliceDoc(innerFrom, innerTo);
+}
+function renderLink(state, node, className) {
+  let url = "";
+  let labelFrom = -1;
+  let labelTo = -1;
+  for (let child = node.firstChild; child; child = child.nextSibling) {
+    if (child.name === "URL") url = state.sliceDoc(child.from, child.to);
+    else if (child.name === "LinkMark") {
+      const mark = state.sliceDoc(child.from, child.to);
+      if (mark === "[") labelFrom = child.to;
+      else if (mark === "]" && labelTo < 0) labelTo = child.from;
+    }
+  }
+  if (labelFrom < 0 || labelTo < 0) return state.sliceDoc(node.from, node.to);
+  const label = renderRange(state, node, labelFrom, labelTo);
+  return url ? `<a href="${escapeAttr(url)}" class="${className}">${label}</a>` : `<span class="${className}">${label}</span>`;
+}
+function renderMark(state, node, className) {
+  if (node.name === "InlineCode") {
+    return `<span class="${className}">${escapeText(codeText(state, node))}</span>`;
+  }
+  if (node.name === "Link") {
+    return renderLink(state, node, className);
+  }
+  return `<span class="${className}">${renderRange(state, node, node.from, node.to)}</span>`;
+}
+function renderNode(state, parent, node) {
+  const rule = NODE_RULES[node.name];
+  if (!rule) return state.sliceDoc(node.from, node.to);
+  const paint = rule({
+    name: node.name,
+    from: node.from,
+    to: node.to,
+    parentName: parent.name,
+    node,
+    state
+  });
+  switch (paint.paint) {
+    case "mark":
+      return renderMark(state, node, paint.className);
+    case "hide": {
+      const hidden = paint.range ?? node;
+      return state.sliceDoc(node.from, hidden.from) + state.sliceDoc(hidden.to, node.to);
+    }
+    case "widget":
+      return state.sliceDoc(node.from, node.to);
+    default:
+      return renderRange(state, node, node.from, node.to);
+  }
+}
+function renderRange(state, parent, from, to) {
+  let html = "";
+  let pos = from;
+  for (let child = parent.firstChild; child; child = child.nextSibling) {
+    if (child.to <= from || child.from >= to) continue;
+    if (child.from > pos) html += state.sliceDoc(pos, child.from);
+    html += renderNode(state, parent, child);
+    pos = child.to;
+  }
+  if (pos < to) html += state.sliceDoc(pos, to);
+  return html;
+}
+function straddlesChild(cell, from, to) {
+  for (let child = cell.firstChild; child; child = child.nextSibling) {
+    if (child.from < from && child.to > from) return true;
+    if (child.from < to && child.to > to) return true;
+  }
+  return false;
+}
+function renderInlineCell(state, cell) {
+  const rules = state.facet(inlineScanRulesFacet);
+  const tree = docTree(state);
+  let html = "";
+  let pos = cell.from;
+  for (const span of scanInline(rules, state.sliceDoc(cell.from, cell.to), cell.from)) {
+    if (span.from < pos) continue;
+    if (inCode(tree, span.from) || inCode(tree, span.to - 1)) continue;
+    if (straddlesChild(cell, span.from, span.to)) continue;
+    html += renderRange(state, cell, pos, span.from) + span.html;
+    pos = span.to;
+  }
+  return (html + renderRange(state, cell, pos, cell.to)).trim();
+}
+export {
+  renderInlineCell
+};
+//# sourceMappingURL=tableInline.js.map

package/dist/codemirror/table/tableInline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/tableInline.ts"],"sourcesContent":["/**\n * Renders a table cell's inline markdown to an HTML string by walking the Lezer\n * inline nodes already parsed inside the `TableCell`, styled through the SAME\n * {@link NODE_RULES} the live editor uses: a `mark` paint becomes a `<span>`\n * carrying that rule's class (`cm-strong`, `cm-inline-code`, `cm-link`, …), so\n * a cell's bold/code/link is painted by the exact `.cm-*` theme rules as body\n * text — not a second, drifting set of styles. Hidden chrome drops out;\n * not-yet-styled constructs pass through as raw markdown, matching how the\n * body leaves them today. Cells render STRINGS, not DOM, so a `widget` paint\n * passes the node's raw source through (the cell's DOMPurify pass keeps\n * allow-listed inline HTML like `<br>` and drops the rest).\n *\n * Reading the parsed tree (rather than re-parsing the cell string) preserves\n * escaped pipes and leaves literal inline HTML (`<br>`) in the gaps between\n * nodes intact — the cell's DOMPurify pass (tableCell.ts) sanitises the result.\n */\n\nimport { type EditorState } from \"@codemirror/state\";\n\nimport { docTree, inCode } from \"../core/codeContext\";\nimport { escapeAttr, escapeText } from \"../core/htmlEscape\";\nimport { inlineScanRulesFacet, scanInline } from \"../core/inlineScan\";\nimport { type NodeLike } from \"../core/paint\";\nimport { NODE_RULES } from \"../core/registry\";\n\ntype SyntaxNodeLike = {\n  readonly name: string;\n  readonly from: number;\n  readonly to: number;\n  readonly firstChild: SyntaxNodeLike | null;\n  readonly nextSibling: SyntaxNodeLike | null;\n};\n\n/**\n * `InlineCode` content sits between its two `CodeMark` backtick children and is\n * literal — no nested markdown — so it's entity-escaped rather than recursed.\n */\nfunction codeText(state: EditorState, node: SyntaxNodeLike): string {\n  let innerFrom = node.from;\n  let innerTo = node.to;\n  let seenMark = false;\n  for (let child = node.firstChild; child; child = child.nextSibling) {\n    if (child.name !== \"CodeMark\") continue;\n    if (!seenMark) {\n      innerFrom = child.to;\n      seenMark = true;\n    }\n    innerTo = child.from;\n  }\n  return state.sliceDoc(innerFrom, innerTo);\n}\n\nfunction renderLink(state: EditorState, node: SyntaxNodeLike, className: string): string {\n  let url = \"\";\n  let labelFrom = -1;\n  let labelTo = -1;\n  for (let child = node.firstChild; child; child = child.nextSibling) {\n    if (child.name === \"URL\") url = state.sliceDoc(child.from, child.to);\n    else if (child.name === \"LinkMark\") {\n      const mark = state.sliceDoc(child.from, child.to);\n      if (mark === \"[\") labelFrom = child.to;\n      else if (mark === \"]\" && labelTo < 0) labelTo = child.from;\n    }\n  }\n  if (labelFrom < 0 || labelTo < 0) return state.sliceDoc(node.from, node.to);\n  const label = renderRange(state, node, labelFrom, labelTo);\n  // Keep the anchor — the widget's click handler routes a Cmd-click through to\n  // the host opener — but carry `.cm-link` so it matches body links.\n  return url\n    ? `<a href=\"${escapeAttr(url)}\" class=\"${className}\">${label}</a>`\n    : `<span class=\"${className}\">${label}</span>`;\n}\n\n/** A registry `mark` node → `<span class=\"…\">`, reusing the editor's own class. */\nfunction renderMark(state: EditorState, node: SyntaxNodeLike, className: string): string {\n  if (node.name === \"InlineCode\") {\n    // Literal content between the backtick `CodeMark`s — entity-escaped, no recursion.\n    return `<span class=\"${className}\">${escapeText(codeText(state, node))}</span>`;\n  }\n  if (node.name === \"Link\") {\n    return renderLink(state, node, className);\n  }\n  return `<span class=\"${className}\">${renderRange(state, node, node.from, node.to)}</span>`;\n}\n\nfunction renderNode(state: EditorState, parent: SyntaxNodeLike, node: SyntaxNodeLike): string {\n  const rule = NODE_RULES[node.name];\n  // An unknown node (no rule) is emitted verbatim.\n  if (!rule) return state.sliceDoc(node.from, node.to);\n  const paint = rule({\n    name: node.name,\n    from: node.from,\n    to: node.to,\n    parentName: parent.name,\n    node: node as unknown as NodeLike,\n    state,\n  });\n  switch (paint.paint) {\n    case \"mark\":\n      return renderMark(state, node, paint.className);\n    case \"hide\": {\n      // Emit whatever the rule did NOT hide — \"\" for whole-node chrome\n      // (`**`, `` ` ``, a Link's URL), the escaped character for `\\x`.\n      const hidden = paint.range ?? node;\n      return state.sliceDoc(node.from, hidden.from) + state.sliceDoc(hidden.to, node.to);\n    }\n    case \"widget\":\n      // Cells render strings, not DOM — the raw source passes through and\n      // the cell's DOMPurify pass keeps allow-listed tags (`<br>`).\n      return state.sliceDoc(node.from, node.to);\n    default:\n      // none / lineClass: recurse so nested styled marks still render, while\n      // this node's own (unstyled) markup passes through as raw text.\n      return renderRange(state, node, node.from, node.to);\n  }\n}\n\n/**\n * Render `parent`'s inline content clipped to `[from, to)`: each child node\n * becomes its tag, and the un-tokenised text in the gaps between children\n * (plain text, inline HTML) is emitted verbatim.\n */\nfunction renderRange(\n  state: EditorState,\n  parent: SyntaxNodeLike,\n  from: number,\n  to: number,\n): string {\n  let html = \"\";\n  let pos = from;\n  for (let child = parent.firstChild; child; child = child.nextSibling) {\n    if (child.to <= from || child.from >= to) continue;\n    if (child.from > pos) html += state.sliceDoc(pos, child.from);\n    html += renderNode(state, parent, child);\n    pos = child.to;\n  }\n  if (pos < to) html += state.sliceDoc(pos, to);\n  return html;\n}\n\n/**\n * A scanned span may stand in for whole child nodes, but must not cut one in\n * half: {@link renderRange} emits a straddling child in full at both ends of the\n * span, which would render it twice.\n */\nfunction straddlesChild(cell: SyntaxNodeLike, from: number, to: number): boolean {\n  for (let child = cell.firstChild; child; child = child.nextSibling) {\n    if (child.from < from && child.to > from) return true;\n    if (child.from < to && child.to > to) return true;\n  }\n  return false;\n}\n\n/**\n * Inline-render one `TableCell` node to a (still-to-be-sanitised) HTML string.\n *\n * The constructs Lezer parses come from the tree; the four it does not\n * (wikilink, highlight, footnote, math) are carved out of the cell's text first\n * and take precedence over the tree walk — the same order the body renders in,\n * where a scanning plugin's replace decoration covers the marks beneath it.\n */\nexport function renderInlineCell(state: EditorState, cell: SyntaxNodeLike): string {\n  const rules = state.facet(inlineScanRulesFacet);\n  const tree = docTree(state);\n  let html = \"\";\n  let pos = cell.from;\n  for (const span of scanInline(rules, state.sliceDoc(cell.from, cell.to), cell.from)) {\n    // Code is literal, exactly as in the body: `$x$` inside a code span is text.\n    if (span.from < pos) continue;\n    if (inCode(tree, span.from) || inCode(tree, span.to - 1)) continue;\n    if (straddlesChild(cell, span.from, span.to)) continue;\n    html += renderRange(state, cell, pos, span.from) + span.html;\n    pos = span.to;\n  }\n  return (html + renderRange(state, cell, pos, cell.to)).trim();\n}\n"],"mappings":";AAmBA,SAAS,SAAS,cAAc;AAChC,SAAS,YAAY,kBAAkB;AACvC,SAAS,sBAAsB,kBAAkB;AAEjD,SAAS,kBAAkB;AAc3B,SAAS,SAAS,OAAoB,MAA8B;AAClE,MAAI,YAAY,KAAK;AACrB,MAAI,UAAU,KAAK;AACnB,MAAI,WAAW;AACf,WAAS,QAAQ,KAAK,YAAY,OAAO,QAAQ,MAAM,aAAa;AAClE,QAAI,MAAM,SAAS,WAAY;AAC/B,QAAI,CAAC,UAAU;AACb,kBAAY,MAAM;AAClB,iBAAW;AAAA,IACb;AACA,cAAU,MAAM;AAAA,EAClB;AACA,SAAO,MAAM,SAAS,WAAW,OAAO;AAC1C;AAEA,SAAS,WAAW,OAAoB,MAAsB,WAA2B;AACvF,MAAI,MAAM;AACV,MAAI,YAAY;AAChB,MAAI,UAAU;AACd,WAAS,QAAQ,KAAK,YAAY,OAAO,QAAQ,MAAM,aAAa;AAClE,QAAI,MAAM,SAAS,MAAO,OAAM,MAAM,SAAS,MAAM,MAAM,MAAM,EAAE;AAAA,aAC1D,MAAM,SAAS,YAAY;AAClC,YAAM,OAAO,MAAM,SAAS,MAAM,MAAM,MAAM,EAAE;AAChD,UAAI,SAAS,IAAK,aAAY,MAAM;AAAA,eAC3B,SAAS,OAAO,UAAU,EAAG,WAAU,MAAM;AAAA,IACxD;AAAA,EACF;AACA,MAAI,YAAY,KAAK,UAAU,EAAG,QAAO,MAAM,SAAS,KAAK,MAAM,KAAK,EAAE;AAC1E,QAAM,QAAQ,YAAY,OAAO,MAAM,WAAW,OAAO;AAGzD,SAAO,MACH,YAAY,WAAW,GAAG,CAAC,YAAY,SAAS,KAAK,KAAK,SAC1D,gBAAgB,SAAS,KAAK,KAAK;AACzC;AAGA,SAAS,WAAW,OAAoB,MAAsB,WAA2B;AACvF,MAAI,KAAK,SAAS,cAAc;AAE9B,WAAO,gBAAgB,SAAS,KAAK,WAAW,SAAS,OAAO,IAAI,CAAC,CAAC;AAAA,EACxE;AACA,MAAI,KAAK,SAAS,QAAQ;AACxB,WAAO,WAAW,OAAO,MAAM,SAAS;AAAA,EAC1C;AACA,SAAO,gBAAgB,SAAS,KAAK,YAAY,OAAO,MAAM,KAAK,MAAM,KAAK,EAAE,CAAC;AACnF;AAEA,SAAS,WAAW,OAAoB,QAAwB,MAA8B;AAC5F,QAAM,OAAO,WAAW,KAAK,IAAI;AAEjC,MAAI,CAAC,KAAM,QAAO,MAAM,SAAS,KAAK,MAAM,KAAK,EAAE;AACnD,QAAM,QAAQ,KAAK;AAAA,IACjB,MAAM,KAAK;AAAA,IACX,MAAM,KAAK;AAAA,IACX,IAAI,KAAK;AAAA,IACT,YAAY,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,EACF,CAAC;AACD,UAAQ,MAAM,OAAO;AAAA,IACnB,KAAK;AACH,aAAO,WAAW,OAAO,MAAM,MAAM,SAAS;AAAA,IAChD,KAAK,QAAQ;AAGX,YAAM,SAAS,MAAM,SAAS;AAC9B,aAAO,MAAM,SAAS,KAAK,MAAM,OAAO,IAAI,IAAI,MAAM,SAAS,OAAO,IAAI,KAAK,EAAE;AAAA,IACnF;AAAA,IACA,KAAK;AAGH,aAAO,MAAM,SAAS,KAAK,MAAM,KAAK,EAAE;AAAA,IAC1C;AAGE,aAAO,YAAY,OAAO,MAAM,KAAK,MAAM,KAAK,EAAE;AAAA,EACtD;AACF;AAOA,SAAS,YACP,OACA,QACA,MACA,IACQ;AACR,MAAI,OAAO;AACX,MAAI,MAAM;AACV,WAAS,QAAQ,OAAO,YAAY,OAAO,QAAQ,MAAM,aAAa;AACpE,QAAI,MAAM,MAAM,QAAQ,MAAM,QAAQ,GAAI;AAC1C,QAAI,MAAM,OAAO,IAAK,SAAQ,MAAM,SAAS,KAAK,MAAM,IAAI;AAC5D,YAAQ,WAAW,OAAO,QAAQ,KAAK;AACvC,UAAM,MAAM;AAAA,EACd;AACA,MAAI,MAAM,GAAI,SAAQ,MAAM,SAAS,KAAK,EAAE;AAC5C,SAAO;AACT;AAOA,SAAS,eAAe,MAAsB,MAAc,IAAqB;AAC/E,WAAS,QAAQ,KAAK,YAAY,OAAO,QAAQ,MAAM,aAAa;AAClE,QAAI,MAAM,OAAO,QAAQ,MAAM,KAAK,KAAM,QAAO;AACjD,QAAI,MAAM,OAAO,MAAM,MAAM,KAAK,GAAI,QAAO;AAAA,EAC/C;AACA,SAAO;AACT;AAUO,SAAS,iBAAiB,OAAoB,MAA8B;AACjF,QAAM,QAAQ,MAAM,MAAM,oBAAoB;AAC9C,QAAM,OAAO,QAAQ,KAAK;AAC1B,MAAI,OAAO;AACX,MAAI,MAAM,KAAK;AACf,aAAW,QAAQ,WAAW,OAAO,MAAM,SAAS,KAAK,MAAM,KAAK,EAAE,GAAG,KAAK,IAAI,GAAG;AAEnF,QAAI,KAAK,OAAO,IAAK;AACrB,QAAI,OAAO,MAAM,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK,KAAK,CAAC,EAAG;AAC1D,QAAI,eAAe,MAAM,KAAK,MAAM,KAAK,EAAE,EAAG;AAC9C,YAAQ,YAAY,OAAO,MAAM,KAAK,KAAK,IAAI,IAAI,KAAK;AACxD,UAAM,KAAK;AAAA,EACb;AACA,UAAQ,OAAO,YAAY,OAAO,MAAM,KAAK,KAAK,EAAE,GAAG,KAAK;AAC9D;","names":[]}

package/dist/codemirror/table/tableModel.d.ts

@@ -0,0 +1,45 @@
+import { EditorState } from '@codemirror/state';
+
+/**
+ * Turns a Lezer `Table` node into the per-table row/column models the widget
+ * renders. Reading the parsed tree (not re-splitting the source on `|`) keeps
+ * the model aligned with Lezer's boundaries:
+ *
+ *   - Escaped pipes (`x \| y`) stay inside one `TableCell`.
+ *   - Cell inline markdown (`**b**`, `` `c` ``, links) renders via the cell's
+ *     inline child nodes (see {@link renderInlineCell}).
+ *   - Trailing prose Lezer folds into the table (no blank-line gap) carries no
+ *     `TableDelimiter`, so it's dropped rather than rendered as a junk row.
+ *   - Tables written with no blank line between them are merged by Lezer into a
+ *     single node; each interior delimiter row begins a new table, so one node
+ *     can yield several models.
+ */
+
+type SyntaxNodeLike = {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    readonly firstChild: SyntaxNodeLike | null;
+    readonly nextSibling: SyntaxNodeLike | null;
+};
+interface TableCellData {
+    /** Inline-rendered HTML (sanitised at render time). */
+    html: string;
+    /** The cell's content range in the document — the span a cell editor edits. */
+    from: number;
+    to: number;
+}
+interface TableData {
+    header: TableCellData[];
+    rows: TableCellData[][];
+    alignments: Array<"left" | "right" | "center" | null>;
+}
+/** One rendered table plus the document range its source occupies. */
+interface TableModel {
+    data: TableData;
+    from: number;
+    to: number;
+}
+declare function parseTableNode(state: EditorState, table: SyntaxNodeLike): TableModel[];
+
+export { type TableCellData, type TableData, type TableModel, parseTableNode };

package/dist/codemirror/table/tableModel.js

@@ -0,0 +1,98 @@
+import "../../chunk-V6TY7KAL.js";
+import { renderInlineCell } from "./tableInline.js";
+function alignmentFor(spec) {
+  const t = spec.trim();
+  if (!t) return null;
+  const left = t.startsWith(":");
+  const right = t.endsWith(":");
+  if (left && right) return "center";
+  if (right) return "right";
+  if (left) return "left";
+  return null;
+}
+function cells(state, row) {
+  const out = [];
+  let lastPipeTo = null;
+  let sawCell = false;
+  for (let child = row.firstChild; child; child = child.nextSibling) {
+    if (child.name === "TableCell") {
+      out.push({ html: renderInlineCell(state, child), from: child.from, to: child.to });
+      sawCell = true;
+    } else if (child.name === "TableDelimiter") {
+      if (lastPipeTo !== null && !sawCell) {
+        out.push({ html: "", from: lastPipeTo, to: child.from });
+      }
+      lastPipeTo = child.to;
+      sawCell = false;
+    }
+  }
+  return out;
+}
+function isContentRow(row) {
+  for (let child = row.firstChild; child; child = child.nextSibling) {
+    if (child.name === "TableDelimiter") return true;
+  }
+  return false;
+}
+function alignmentsFrom(state, delimiterLine) {
+  return state.sliceDoc(delimiterLine.from, delimiterLine.to).replace(/^\s*\|/, "").replace(/\|\s*$/, "").split("|").map((s) => s.trim());
+}
+function rowCellTexts(state, row) {
+  const cells2 = [];
+  for (let child = row.firstChild; child; child = child.nextSibling) {
+    if (child.name === "TableCell") cells2.push(state.sliceDoc(child.from, child.to).trim());
+  }
+  return cells2;
+}
+function isDelimiterCells(cells2) {
+  return cells2.length > 0 && cells2.every((c) => /^:?-+:?$/.test(c));
+}
+function isDelimiterRow(state, node) {
+  if (node.name === "TableDelimiter") return true;
+  return isDelimiterCells(rowCellTexts(state, node));
+}
+function tableItems(state, table) {
+  const items = [];
+  for (let child = table.firstChild; child; child = child.nextSibling) {
+    if (child.name === "TableHeader" || child.name === "TableRow" || child.name === "TableDelimiter") {
+      items.push({ node: child, isDelimiter: isDelimiterRow(state, child) });
+    }
+  }
+  return items;
+}
+function bodyRows(state, items, delimiterIndex) {
+  const rows = [];
+  let to = items[delimiterIndex].node.to;
+  for (let j = delimiterIndex + 1; j < items.length; j++) {
+    if (items[j].isDelimiter) break;
+    if (items[j + 1]?.isDelimiter) break;
+    if (!isContentRow(items[j].node)) continue;
+    rows.push(cells(state, items[j].node));
+    to = items[j].node.to;
+  }
+  return { rows, to };
+}
+function parseTableNode(state, table) {
+  const items = tableItems(state, table);
+  const models = [];
+  for (let k = 0; k < items.length; k++) {
+    if (!items[k].isDelimiter) continue;
+    const headerItem = items[k - 1];
+    if (!headerItem || headerItem.isDelimiter) continue;
+    const { rows, to } = bodyRows(state, items, k);
+    models.push({
+      data: {
+        header: cells(state, headerItem.node),
+        rows,
+        alignments: alignmentsFrom(state, items[k].node).map(alignmentFor)
+      },
+      from: headerItem.node.from,
+      to
+    });
+  }
+  return models;
+}
+export {
+  parseTableNode
+};
+//# sourceMappingURL=tableModel.js.map

package/dist/codemirror/table/tableModel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/tableModel.ts"],"sourcesContent":["/**\n * Turns a Lezer `Table` node into the per-table row/column models the widget\n * renders. Reading the parsed tree (not re-splitting the source on `|`) keeps\n * the model aligned with Lezer's boundaries:\n *\n *   - Escaped pipes (`x \\| y`) stay inside one `TableCell`.\n *   - Cell inline markdown (`**b**`, `` `c` ``, links) renders via the cell's\n *     inline child nodes (see {@link renderInlineCell}).\n *   - Trailing prose Lezer folds into the table (no blank-line gap) carries no\n *     `TableDelimiter`, so it's dropped rather than rendered as a junk row.\n *   - Tables written with no blank line between them are merged by Lezer into a\n *     single node; each interior delimiter row begins a new table, so one node\n *     can yield several models.\n */\n\nimport { type EditorState } from \"@codemirror/state\";\n\nimport { renderInlineCell } from \"./tableInline\";\n\ntype SyntaxNodeLike = {\n  readonly name: string;\n  readonly from: number;\n  readonly to: number;\n  readonly firstChild: SyntaxNodeLike | null;\n  readonly nextSibling: SyntaxNodeLike | null;\n};\n\nexport interface TableCellData {\n  /** Inline-rendered HTML (sanitised at render time). */\n  html: string;\n  /** The cell's content range in the document — the span a cell editor edits. */\n  from: number;\n  to: number;\n}\n\nexport interface TableData {\n  header: TableCellData[];\n  rows: TableCellData[][];\n  alignments: Array<\"left\" | \"right\" | \"center\" | null>;\n}\n\n/** One rendered table plus the document range its source occupies. */\nexport interface TableModel {\n  data: TableData;\n  from: number;\n  to: number;\n}\n\nfunction alignmentFor(spec: string): \"left\" | \"right\" | \"center\" | null {\n  const t = spec.trim();\n  if (!t) return null;\n  const left = t.startsWith(\":\");\n  const right = t.endsWith(\":\");\n  if (left && right) return \"center\";\n  if (right) return \"right\";\n  if (left) return \"left\";\n  return null;\n}\n\n/**\n * A row's cells in document order, including empty ones. Lezer emits a\n * `TableCell` only for non-empty cells, so an empty cell shows up as two\n * adjacent `TableDelimiter` pipes with nothing between — reconstruct those as\n * empty cells (range = the gap) so blank or freshly inserted rows and columns\n * still render and stay editable. Walking the pipe/cell nodes (rather than\n * splitting on `|`) keeps an escaped pipe (`x \\| y`) inside its one cell.\n */\nfunction cells(state: EditorState, row: SyntaxNodeLike): TableCellData[] {\n  const out: TableCellData[] = [];\n  let lastPipeTo: number | null = null;\n  let sawCell = false;\n  for (let child = row.firstChild; child; child = child.nextSibling) {\n    if (child.name === \"TableCell\") {\n      out.push({ html: renderInlineCell(state, child), from: child.from, to: child.to });\n      sawCell = true;\n    } else if (child.name === \"TableDelimiter\") {\n      if (lastPipeTo !== null && !sawCell) {\n        out.push({ html: \"\", from: lastPipeTo, to: child.from });\n      }\n      lastPipeTo = child.to;\n      sawCell = false;\n    }\n  }\n  return out;\n}\n\n/**\n * A genuine GFM row carries at least one `TableDelimiter` (the `|` pipes).\n * Lezer folds a blank-line-less trailing paragraph into the table as a\n * `TableRow` with a single cell and no delimiter — prose, not a row.\n */\nfunction isContentRow(row: SyntaxNodeLike): boolean {\n  for (let child = row.firstChild; child; child = child.nextSibling) {\n    if (child.name === \"TableDelimiter\") return true;\n  }\n  return false;\n}\n\nfunction alignmentsFrom(state: EditorState, delimiterLine: SyntaxNodeLike): string[] {\n  return state\n    .sliceDoc(delimiterLine.from, delimiterLine.to)\n    .replace(/^\\s*\\|/, \"\")\n    .replace(/\\|\\s*$/, \"\")\n    .split(\"|\")\n    .map((s) => s.trim());\n}\n\nfunction rowCellTexts(state: EditorState, row: SyntaxNodeLike): string[] {\n  const cells: string[] = [];\n  for (let child = row.firstChild; child; child = child.nextSibling) {\n    if (child.name === \"TableCell\") cells.push(state.sliceDoc(child.from, child.to).trim());\n  }\n  return cells;\n}\n\n/** `| --- | :-: |`: every cell is a dash run with optional alignment colons. */\nfunction isDelimiterCells(cells: string[]): boolean {\n  return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));\n}\n\n/**\n * Whether a line is a delimiter (alignment) row. Lezer tags only the FIRST\n * one as a `TableDelimiter` node; the separator of a back-to-back table is a\n * plain `TableRow` whose cells happen to be dash runs, so those are detected by\n * content.\n */\nfunction isDelimiterRow(state: EditorState, node: SyntaxNodeLike): boolean {\n  if (node.name === \"TableDelimiter\") return true;\n  return isDelimiterCells(rowCellTexts(state, node));\n}\n\ninterface Item {\n  node: SyntaxNodeLike;\n  isDelimiter: boolean;\n}\n\n/** The Table node's header/row lines and delimiter lines, in document order. */\nfunction tableItems(state: EditorState, table: SyntaxNodeLike): Item[] {\n  const items: Item[] = [];\n  for (let child = table.firstChild; child; child = child.nextSibling) {\n    if (\n      child.name === \"TableHeader\" ||\n      child.name === \"TableRow\" ||\n      child.name === \"TableDelimiter\"\n    ) {\n      items.push({ node: child, isDelimiter: isDelimiterRow(state, child) });\n    }\n  }\n  return items;\n}\n\n/**\n * Body rows for the table whose delimiter is at `delimiterIndex`: content rows\n * up to the header of the next back-to-back table (the row immediately before\n * the next delimiter), skipping folded-in prose.\n */\nfunction bodyRows(\n  state: EditorState,\n  items: Item[],\n  delimiterIndex: number,\n): { rows: TableCellData[][]; to: number } {\n  const rows: TableCellData[][] = [];\n  let to = items[delimiterIndex].node.to;\n  for (let j = delimiterIndex + 1; j < items.length; j++) {\n    if (items[j].isDelimiter) break;\n    if (items[j + 1]?.isDelimiter) break;\n    if (!isContentRow(items[j].node)) continue;\n    rows.push(cells(state, items[j].node));\n    to = items[j].node.to;\n  }\n  return { rows, to };\n}\n\nexport function parseTableNode(state: EditorState, table: SyntaxNodeLike): TableModel[] {\n  const items = tableItems(state, table);\n  const models: TableModel[] = [];\n  for (let k = 0; k < items.length; k++) {\n    if (!items[k].isDelimiter) continue;\n    const headerItem = items[k - 1];\n    if (!headerItem || headerItem.isDelimiter) continue;\n    const { rows, to } = bodyRows(state, items, k);\n    models.push({\n      data: {\n        header: cells(state, headerItem.node),\n        rows,\n        alignments: alignmentsFrom(state, items[k].node).map(alignmentFor),\n      },\n      from: headerItem.node.from,\n      to,\n    });\n  }\n  return models;\n}\n"],"mappings":"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","names":["cells"]}

package/dist/codemirror/tablev2/bridgeRules.d.ts

@@ -0,0 +1,48 @@
+import { TableModel } from '../table/tableModel.js';
+import '@codemirror/state';
+
+/**
+ * The bridge's key decisions (ADR 0001): given where the caret sits inside a
+ * cell, either the browser handles the key natively (mid-text editing) or the
+ * bridge takes over at a boundary — stepping to a neighbour cell or exiting
+ * the table. Pure — the grid math delegates to {@link stepCell}; geometry
+ * (wrapped-line detection) arrives as booleans computed by the surface.
+ *
+ * Structural invariant: no key ever merges cells or rows. Backspace/Delete at
+ * a cell edge NAVIGATES; structure changes only happen through explicit
+ * commands (tableEditCommands).
+ */
+
+type BridgeKey = "Tab" | "Shift-Tab" | "ArrowRight" | "ArrowLeft" | "ArrowUp" | "ArrowDown" | "Backspace" | "Delete" | "Enter";
+interface BridgeInput {
+    /** Grid dimensions: rows includes the header. */
+    rows: number;
+    cols: number;
+    /** Caret cell (row 0 = header) and text position. */
+    row: number;
+    col: number;
+    offset: number;
+    length: number;
+    /** Real-geometry flags from the surface (wrapped cells). */
+    onFirstVisualLine: boolean;
+    onLastVisualLine: boolean;
+}
+type BridgeAction = {
+    kind: "native";
+} | {
+    kind: "focusCell";
+    row: number;
+    col: number;
+    caret: "start" | "end";
+} | {
+    kind: "exit";
+    edge: "before" | "after";
+};
+/** Dimensions of `model` as BridgeInput expects them. */
+declare function gridSize(model: TableModel): {
+    rows: number;
+    cols: number;
+};
+declare function bridgeKey(input: BridgeInput, key: BridgeKey): BridgeAction;
+
+export { type BridgeAction, type BridgeInput, type BridgeKey, bridgeKey, gridSize };

package/dist/codemirror/tablev2/bridgeRules.js

@@ -0,0 +1,42 @@
+import "../../chunk-V6TY7KAL.js";
+import { rowCount, stepGrid } from "../table/tableCellNav.js";
+const NATIVE = { kind: "native" };
+function gridSize(model) {
+  return { rows: rowCount(model), cols: model.data.header.length };
+}
+function resolve(input, dir, caret) {
+  const target = stepGrid(input.rows, input.cols, input.row, input.col, dir);
+  if (target.kind === "cell") return { kind: "focusCell", row: target.row, col: target.col, caret };
+  return { kind: "exit", edge: target.edge === "above" || target.edge === "before" ? "before" : "after" };
+}
+function bridgeKey(input, key) {
+  const atStart = input.offset === 0;
+  const atEnd = input.offset >= input.length;
+  switch (key) {
+    case "Tab":
+      return resolve(input, "next", "start");
+    case "Shift-Tab":
+      return resolve(input, "prev", "end");
+    case "ArrowRight":
+      return atEnd ? resolve(input, "next", "start") : NATIVE;
+    case "ArrowLeft":
+      return atStart ? resolve(input, "prev", "end") : NATIVE;
+    case "ArrowDown":
+      return input.onLastVisualLine ? resolve(input, "down", "start") : NATIVE;
+    case "ArrowUp":
+      return input.onFirstVisualLine ? resolve(input, "up", "start") : NATIVE;
+    case "Backspace":
+      return atStart ? resolve(input, "prev", "end") : NATIVE;
+    case "Delete":
+      return atEnd ? resolve(input, "next", "start") : NATIVE;
+    case "Enter":
+      return resolve(input, "down", "start");
+    default:
+      return NATIVE;
+  }
+}
+export {
+  bridgeKey,
+  gridSize
+};
+//# sourceMappingURL=bridgeRules.js.map

package/dist/codemirror/tablev2/bridgeRules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/tablev2/bridgeRules.ts"],"sourcesContent":["/**\n * The bridge's key decisions (ADR 0001): given where the caret sits inside a\n * cell, either the browser handles the key natively (mid-text editing) or the\n * bridge takes over at a boundary — stepping to a neighbour cell or exiting\n * the table. Pure — the grid math delegates to {@link stepCell}; geometry\n * (wrapped-line detection) arrives as booleans computed by the surface.\n *\n * Structural invariant: no key ever merges cells or rows. Backspace/Delete at\n * a cell edge NAVIGATES; structure changes only happen through explicit\n * commands (tableEditCommands).\n */\n\nimport { type NavDir, type NavTarget, rowCount, stepGrid } from \"../table/tableCellNav\";\nimport { type TableModel } from \"../table/tableModel\";\n\nexport type BridgeKey =\n  | \"Tab\"\n  | \"Shift-Tab\"\n  | \"ArrowRight\"\n  | \"ArrowLeft\"\n  | \"ArrowUp\"\n  | \"ArrowDown\"\n  | \"Backspace\"\n  | \"Delete\"\n  | \"Enter\";\n\nexport interface BridgeInput {\n  /** Grid dimensions: rows includes the header. */\n  rows: number;\n  cols: number;\n  /** Caret cell (row 0 = header) and text position. */\n  row: number;\n  col: number;\n  offset: number;\n  length: number;\n  /** Real-geometry flags from the surface (wrapped cells). */\n  onFirstVisualLine: boolean;\n  onLastVisualLine: boolean;\n}\n\nexport type BridgeAction =\n  | { kind: \"native\" }\n  | { kind: \"focusCell\"; row: number; col: number; caret: \"start\" | \"end\" }\n  | { kind: \"exit\"; edge: \"before\" | \"after\" };\n\nconst NATIVE: BridgeAction = { kind: \"native\" };\n\n/** Dimensions of `model` as BridgeInput expects them. */\nexport function gridSize(model: TableModel): { rows: number; cols: number } {\n  return { rows: rowCount(model), cols: model.data.header.length };\n}\n\nfunction resolve(input: BridgeInput, dir: NavDir, caret: \"start\" | \"end\"): BridgeAction {\n  const target: NavTarget = stepGrid(input.rows, input.cols, input.row, input.col, dir);\n  if (target.kind === \"cell\") return { kind: \"focusCell\", row: target.row, col: target.col, caret };\n  return { kind: \"exit\", edge: target.edge === \"above\" || target.edge === \"before\" ? \"before\" : \"after\" };\n}\n\nexport function bridgeKey(input: BridgeInput, key: BridgeKey): BridgeAction {\n  const atStart = input.offset === 0;\n  const atEnd = input.offset >= input.length;\n  switch (key) {\n    case \"Tab\":\n      return resolve(input, \"next\", \"start\");\n    case \"Shift-Tab\":\n      return resolve(input, \"prev\", \"end\");\n    case \"ArrowRight\":\n      return atEnd ? resolve(input, \"next\", \"start\") : NATIVE;\n    case \"ArrowLeft\":\n      return atStart ? resolve(input, \"prev\", \"end\") : NATIVE;\n    case \"ArrowDown\":\n      return input.onLastVisualLine ? resolve(input, \"down\", \"start\") : NATIVE;\n    case \"ArrowUp\":\n      return input.onFirstVisualLine ? resolve(input, \"up\", \"start\") : NATIVE;\n    case \"Backspace\":\n      return atStart ? resolve(input, \"prev\", \"end\") : NATIVE;\n    case \"Delete\":\n      return atEnd ? resolve(input, \"next\", \"start\") : NATIVE;\n    case \"Enter\":\n      return resolve(input, \"down\", \"start\");\n    default:\n      return NATIVE;\n  }\n}\n"],"mappings":";AAYA,SAAsC,UAAU,gBAAgB;AAiChE,MAAM,SAAuB,EAAE,MAAM,SAAS;AAGvC,SAAS,SAAS,OAAmD;AAC1E,SAAO,EAAE,MAAM,SAAS,KAAK,GAAG,MAAM,MAAM,KAAK,OAAO,OAAO;AACjE;AAEA,SAAS,QAAQ,OAAoB,KAAa,OAAsC;AACtF,QAAM,SAAoB,SAAS,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK,MAAM,KAAK,GAAG;AACpF,MAAI,OAAO,SAAS,OAAQ,QAAO,EAAE,MAAM,aAAa,KAAK,OAAO,KAAK,KAAK,OAAO,KAAK,MAAM;AAChG,SAAO,EAAE,MAAM,QAAQ,MAAM,OAAO,SAAS,WAAW,OAAO,SAAS,WAAW,WAAW,QAAQ;AACxG;AAEO,SAAS,UAAU,OAAoB,KAA8B;AAC1E,QAAM,UAAU,MAAM,WAAW;AACjC,QAAM,QAAQ,MAAM,UAAU,MAAM;AACpC,UAAQ,KAAK;AAAA,IACX,KAAK;AACH,aAAO,QAAQ,OAAO,QAAQ,OAAO;AAAA,IACvC,KAAK;AACH,aAAO,QAAQ,OAAO,QAAQ,KAAK;AAAA,IACrC,KAAK;AACH,aAAO,QAAQ,QAAQ,OAAO,QAAQ,OAAO,IAAI;AAAA,IACnD,KAAK;AACH,aAAO,UAAU,QAAQ,OAAO,QAAQ,KAAK,IAAI;AAAA,IACnD,KAAK;AACH,aAAO,MAAM,mBAAmB,QAAQ,OAAO,QAAQ,OAAO,IAAI;AAAA,IACpE,KAAK;AACH,aAAO,MAAM,oBAAoB,QAAQ,OAAO,MAAM,OAAO,IAAI;AAAA,IACnE,KAAK;AACH,aAAO,UAAU,QAAQ,OAAO,QAAQ,KAAK,IAAI;AAAA,IACnD,KAAK;AACH,aAAO,QAAQ,QAAQ,OAAO,QAAQ,OAAO,IAAI;AAAA,IACnD,KAAK;AACH,aAAO,QAAQ,OAAO,QAAQ,OAAO;AAAA,IACvC;AACE,aAAO;AAAA,EACX;AACF;","names":[]}

package/dist/codemirror/tablev2/cellEditingSurface.d.ts

@@ -0,0 +1,79 @@
+import { ChangeDesc, EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+
+/**
+ * The swappable cell-editing seam (ADR 0001 §Editing surface).
+ *
+ * The table model, bridge rules, commands, and menu are identical for both
+ * candidate surfaces; only *where typing physically happens* differs:
+ *
+ *   - inline  (B): the cell `<td>` itself becomes contenteditable.
+ *   - overlay (C): one shared editor is positioned over the cell rect,
+ *                  portaled outside CodeMirror's DOM.
+ *
+ * A surface manages at most ONE active edit. It is told about document
+ * changes (`mapThrough`) and widget DOM updates (`reanchor`) by the tableV2
+ * extension, and resolves the cell's CURRENT source range only at commit
+ * time — so edits merge cleanly with concurrent external changes.
+ */
+
+interface CellRef {
+    /** 0 = header row; 1.. = body rows. */
+    row: number;
+    col: number;
+}
+interface ActiveEdit {
+    ref: CellRef;
+    /** Live unescaped cell text. */
+    text: string;
+    /** Caret offset within `text`. */
+    caret: number;
+}
+interface CellEditingSurface {
+    readonly kind: "inline" | "overlay";
+    /** Begin editing `ref` in the table anchored at `tableFrom` (source start).
+     *  Returns false when the cell can't be resolved. */
+    begin(view: EditorView, tableFrom: number, ref: CellRef, caret?: number): boolean;
+    active(): ActiveEdit | null;
+    /** The DOM element that hosts typing while an edit is active. */
+    editingElement(): HTMLElement | null;
+    /** Move the active edit's caret — DOM selection AND the live mirror, so a
+     *  bridge key arriving before the async selectionchange reads the truth. */
+    placeCaret(offset: number): void;
+    /** The current source position of the active edit's table, or null. */
+    anchor(): number | null;
+    /** Keep the table anchor position current across document changes. */
+    mapThrough(changes: ChangeDesc): void;
+    /** Called after the widget DOM was patched or recreated: re-attach the
+     *  editing UI, preserving live text, caret, and focus. */
+    reanchor(view: EditorView): void;
+    /** Resolve the cell's current range and write the live text (if changed);
+     *  ends the edit. */
+    commit(view: EditorView): void;
+    /** End the edit without writing. */
+    cancel(): void;
+}
+/** The rendered element for a cell, resolved through the widget's CURRENT
+ *  source-anchor stamp (re-stamped on every toDOM/updateDOM). */
+declare function cellElement(view: EditorView, tableFrom: number, ref: CellRef): HTMLElement | null;
+/** The cell's current source range, from the freshly-parsed model. */
+declare function cellRange(state: EditorState, tableFrom: number, ref: CellRef): {
+    from: number;
+    to: number;
+} | null;
+/** Collapse the selection at `offset` within `el` (flat text content). */
+declare function setCaret(el: HTMLElement, offset: number): void;
+/** The selection's caret offset within `el`, or null when it's elsewhere. */
+declare function caretOffset(el: HTMLElement): number | null;
+/** Caret offset at a viewport point inside `el`, or null when the point
+ *  resolves elsewhere (borders, padding gutters). WebKit API. */
+declare function offsetAtPoint(el: HTMLElement, x: number, y: number): number | null;
+/** Whether the caret sits on the first/last VISUAL line of `el` — a wrapped
+ *  cell spans several. Vertical bridge motion only leaves the cell from its
+ *  edge lines. Empty or unmeasurable selections count as single-line. */
+declare function visualEdges(el: HTMLElement): {
+    onFirstVisualLine: boolean;
+    onLastVisualLine: boolean;
+};
+
+export { type ActiveEdit, type CellEditingSurface, type CellRef, caretOffset, cellElement, cellRange, offsetAtPoint, setCaret, visualEdges };

package/dist/codemirror/tablev2/cellEditingSurface.js

@@ -0,0 +1,70 @@
+import "../../chunk-V6TY7KAL.js";
+import { cellAt } from "../table/tableCellNav.js";
+import { modelAt } from "../table/tableGeometry.js";
+function cellElement(view, tableFrom, ref) {
+  for (const wrap of view.dom.querySelectorAll("[data-tablev2-from]")) {
+    if (Number(wrap.dataset.tablev2From) !== tableFrom) continue;
+    return wrap.querySelector(`[data-row="${ref.row}"][data-col="${ref.col}"]`);
+  }
+  return null;
+}
+function cellRange(state, tableFrom, ref) {
+  const model = modelAt(state, tableFrom);
+  if (!model) return null;
+  const cell = cellAt(model, ref.row, ref.col);
+  return cell ? { from: cell.from, to: cell.to } : null;
+}
+function setCaret(el, offset) {
+  let textNode = el.firstChild;
+  if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+    textNode = el.ownerDocument.createTextNode(el.textContent ?? "");
+    el.textContent = "";
+    el.appendChild(textNode);
+  }
+  const max = textNode.textContent?.length ?? 0;
+  el.ownerDocument.getSelection()?.collapse(textNode, Math.max(0, Math.min(offset, max)));
+}
+function caretOffset(el) {
+  const sel = el.ownerDocument.getSelection();
+  if (!sel || sel.rangeCount === 0) return null;
+  const range = sel.getRangeAt(0);
+  if (!el.contains(range.startContainer)) return null;
+  const pre = range.cloneRange();
+  pre.selectNodeContents(el);
+  pre.setEnd(range.startContainer, range.startOffset);
+  return pre.toString().length;
+}
+function offsetAtPoint(el, x, y) {
+  const doc = el.ownerDocument;
+  const range = doc.caretRangeFromPoint?.(x, y);
+  if (!range || !el.contains(range.startContainer)) return null;
+  const pre = range.cloneRange();
+  pre.selectNodeContents(el);
+  pre.setEnd(range.startContainer, range.startOffset);
+  return pre.toString().length;
+}
+function visualEdges(el) {
+  const single = { onFirstVisualLine: true, onLastVisualLine: true };
+  const sel = el.ownerDocument.getSelection();
+  if (!sel || sel.rangeCount === 0) return single;
+  const range = sel.getRangeAt(0);
+  if (!el.contains(range.startContainer)) return single;
+  const rects = range.getClientRects();
+  if (rects.length === 0) return single;
+  const caret = rects[0];
+  const elRect = el.getBoundingClientRect();
+  const line = caret.height || parseFloat(getComputedStyle(el).lineHeight) || 16;
+  return {
+    onFirstVisualLine: caret.top - elRect.top < line * 0.75,
+    onLastVisualLine: elRect.bottom - caret.bottom < line * 0.75
+  };
+}
+export {
+  caretOffset,
+  cellElement,
+  cellRange,
+  offsetAtPoint,
+  setCaret,
+  visualEdges
+};
+//# sourceMappingURL=cellEditingSurface.js.map

package/dist/codemirror/tablev2/cellEditingSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/tablev2/cellEditingSurface.ts"],"sourcesContent":["/**\n * The swappable cell-editing seam (ADR 0001 §Editing surface).\n *\n * The table model, bridge rules, commands, and menu are identical for both\n * candidate surfaces; only *where typing physically happens* differs:\n *\n *   - inline  (B): the cell `<td>` itself becomes contenteditable.\n *   - overlay (C): one shared editor is positioned over the cell rect,\n *                  portaled outside CodeMirror's DOM.\n *\n * A surface manages at most ONE active edit. It is told about document\n * changes (`mapThrough`) and widget DOM updates (`reanchor`) by the tableV2\n * extension, and resolves the cell's CURRENT source range only at commit\n * time — so edits merge cleanly with concurrent external changes.\n */\n\nimport { type ChangeDesc, type EditorState } from \"@codemirror/state\";\nimport { type EditorView } from \"@codemirror/view\";\n\nimport { cellAt } from \"../table/tableCellNav\";\nimport { modelAt } from \"../table/tableGeometry\";\n\nexport interface CellRef {\n  /** 0 = header row; 1.. = body rows. */\n  row: number;\n  col: number;\n}\n\nexport interface ActiveEdit {\n  ref: CellRef;\n  /** Live unescaped cell text. */\n  text: string;\n  /** Caret offset within `text`. */\n  caret: number;\n}\n\nexport interface CellEditingSurface {\n  readonly kind: \"inline\" | \"overlay\";\n  /** Begin editing `ref` in the table anchored at `tableFrom` (source start).\n   *  Returns false when the cell can't be resolved. */\n  begin(view: EditorView, tableFrom: number, ref: CellRef, caret?: number): boolean;\n  active(): ActiveEdit | null;\n  /** The DOM element that hosts typing while an edit is active. */\n  editingElement(): HTMLElement | null;\n  /** Move the active edit's caret — DOM selection AND the live mirror, so a\n   *  bridge key arriving before the async selectionchange reads the truth. */\n  placeCaret(offset: number): void;\n  /** The current source position of the active edit's table, or null. */\n  anchor(): number | null;\n  /** Keep the table anchor position current across document changes. */\n  mapThrough(changes: ChangeDesc): void;\n  /** Called after the widget DOM was patched or recreated: re-attach the\n   *  editing UI, preserving live text, caret, and focus. */\n  reanchor(view: EditorView): void;\n  /** Resolve the cell's current range and write the live text (if changed);\n   *  ends the edit. */\n  commit(view: EditorView): void;\n  /** End the edit without writing. */\n  cancel(): void;\n}\n\n/** The rendered element for a cell, resolved through the widget's CURRENT\n *  source-anchor stamp (re-stamped on every toDOM/updateDOM). */\nexport function cellElement(\n  view: EditorView,\n  tableFrom: number,\n  ref: CellRef,\n): HTMLElement | null {\n  for (const wrap of view.dom.querySelectorAll<HTMLElement>(\"[data-tablev2-from]\")) {\n    if (Number(wrap.dataset.tablev2From) !== tableFrom) continue;\n    return wrap.querySelector<HTMLElement>(`[data-row=\"${ref.row}\"][data-col=\"${ref.col}\"]`);\n  }\n  return null;\n}\n\n/** The cell's current source range, from the freshly-parsed model. */\nexport function cellRange(\n  state: EditorState,\n  tableFrom: number,\n  ref: CellRef,\n): { from: number; to: number } | null {\n  const model = modelAt(state, tableFrom);\n  if (!model) return null;\n  const cell = cellAt(model, ref.row, ref.col);\n  return cell ? { from: cell.from, to: cell.to } : null;\n}\n\n/** Collapse the selection at `offset` within `el` (flat text content). */\nexport function setCaret(el: HTMLElement, offset: number): void {\n  let textNode = el.firstChild;\n  if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {\n    textNode = el.ownerDocument.createTextNode(el.textContent ?? \"\");\n    el.textContent = \"\";\n    el.appendChild(textNode);\n  }\n  const max = textNode.textContent?.length ?? 0;\n  el.ownerDocument.getSelection()?.collapse(textNode, Math.max(0, Math.min(offset, max)));\n}\n\n/** The selection's caret offset within `el`, or null when it's elsewhere. */\nexport function caretOffset(el: HTMLElement): number | null {\n  const sel = el.ownerDocument.getSelection();\n  if (!sel || sel.rangeCount === 0) return null;\n  const range = sel.getRangeAt(0);\n  if (!el.contains(range.startContainer)) return null;\n  const pre = range.cloneRange();\n  pre.selectNodeContents(el);\n  pre.setEnd(range.startContainer, range.startOffset);\n  return pre.toString().length;\n}\n\n/** Caret offset at a viewport point inside `el`, or null when the point\n *  resolves elsewhere (borders, padding gutters). WebKit API. */\nexport function offsetAtPoint(el: HTMLElement, x: number, y: number): number | null {\n  const doc = el.ownerDocument as Document & {\n    caretRangeFromPoint?: (x: number, y: number) => Range | null;\n  };\n  const range = doc.caretRangeFromPoint?.(x, y);\n  if (!range || !el.contains(range.startContainer)) return null;\n  const pre = range.cloneRange();\n  pre.selectNodeContents(el);\n  pre.setEnd(range.startContainer, range.startOffset);\n  return pre.toString().length;\n}\n\n/** Whether the caret sits on the first/last VISUAL line of `el` — a wrapped\n *  cell spans several. Vertical bridge motion only leaves the cell from its\n *  edge lines. Empty or unmeasurable selections count as single-line. */\nexport function visualEdges(el: HTMLElement): {\n  onFirstVisualLine: boolean;\n  onLastVisualLine: boolean;\n} {\n  const single = { onFirstVisualLine: true, onLastVisualLine: true };\n  const sel = el.ownerDocument.getSelection();\n  if (!sel || sel.rangeCount === 0) return single;\n  const range = sel.getRangeAt(0);\n  if (!el.contains(range.startContainer)) return single;\n  const rects = range.getClientRects();\n  if (rects.length === 0) return single;\n  const caret = rects[0];\n  const elRect = el.getBoundingClientRect();\n  const line = caret.height || parseFloat(getComputedStyle(el).lineHeight) || 16;\n  return {\n    onFirstVisualLine: caret.top - elRect.top < line * 0.75,\n    onLastVisualLine: elRect.bottom - caret.bottom < line * 0.75,\n  };\n}\n"],"mappings":";AAmBA,SAAS,cAAc;AACvB,SAAS,eAAe;AA2CjB,SAAS,YACd,MACA,WACA,KACoB;AACpB,aAAW,QAAQ,KAAK,IAAI,iBAA8B,qBAAqB,GAAG;AAChF,QAAI,OAAO,KAAK,QAAQ,WAAW,MAAM,UAAW;AACpD,WAAO,KAAK,cAA2B,cAAc,IAAI,GAAG,gBAAgB,IAAI,GAAG,IAAI;AAAA,EACzF;AACA,SAAO;AACT;AAGO,SAAS,UACd,OACA,WACA,KACqC;AACrC,QAAM,QAAQ,QAAQ,OAAO,SAAS;AACtC,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,OAAO,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG;AAC3C,SAAO,OAAO,EAAE,MAAM,KAAK,MAAM,IAAI,KAAK,GAAG,IAAI;AACnD;AAGO,SAAS,SAAS,IAAiB,QAAsB;AAC9D,MAAI,WAAW,GAAG;AAClB,MAAI,CAAC,YAAY,SAAS,aAAa,KAAK,WAAW;AACrD,eAAW,GAAG,cAAc,eAAe,GAAG,eAAe,EAAE;AAC/D,OAAG,cAAc;AACjB,OAAG,YAAY,QAAQ;AAAA,EACzB;AACA,QAAM,MAAM,SAAS,aAAa,UAAU;AAC5C,KAAG,cAAc,aAAa,GAAG,SAAS,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,QAAQ,GAAG,CAAC,CAAC;AACxF;AAGO,SAAS,YAAY,IAAgC;AAC1D,QAAM,MAAM,GAAG,cAAc,aAAa;AAC1C,MAAI,CAAC,OAAO,IAAI,eAAe,EAAG,QAAO;AACzC,QAAM,QAAQ,IAAI,WAAW,CAAC;AAC9B,MAAI,CAAC,GAAG,SAAS,MAAM,cAAc,EAAG,QAAO;AAC/C,QAAM,MAAM,MAAM,WAAW;AAC7B,MAAI,mBAAmB,EAAE;AACzB,MAAI,OAAO,MAAM,gBAAgB,MAAM,WAAW;AAClD,SAAO,IAAI,SAAS,EAAE;AACxB;AAIO,SAAS,cAAc,IAAiB,GAAW,GAA0B;AAClF,QAAM,MAAM,GAAG;AAGf,QAAM,QAAQ,IAAI,sBAAsB,GAAG,CAAC;AAC5C,MAAI,CAAC,SAAS,CAAC,GAAG,SAAS,MAAM,cAAc,EAAG,QAAO;AACzD,QAAM,MAAM,MAAM,WAAW;AAC7B,MAAI,mBAAmB,EAAE;AACzB,MAAI,OAAO,MAAM,gBAAgB,MAAM,WAAW;AAClD,SAAO,IAAI,SAAS,EAAE;AACxB;AAKO,SAAS,YAAY,IAG1B;AACA,QAAM,SAAS,EAAE,mBAAmB,MAAM,kBAAkB,KAAK;AACjE,QAAM,MAAM,GAAG,cAAc,aAAa;AAC1C,MAAI,CAAC,OAAO,IAAI,eAAe,EAAG,QAAO;AACzC,QAAM,QAAQ,IAAI,WAAW,CAAC;AAC9B,MAAI,CAAC,GAAG,SAAS,MAAM,cAAc,EAAG,QAAO;AAC/C,QAAM,QAAQ,MAAM,eAAe;AACnC,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,QAAM,QAAQ,MAAM,CAAC;AACrB,QAAM,SAAS,GAAG,sBAAsB;AACxC,QAAM,OAAO,MAAM,UAAU,WAAW,iBAAiB,EAAE,EAAE,UAAU,KAAK;AAC5E,SAAO;AAAA,IACL,mBAAmB,MAAM,MAAM,OAAO,MAAM,OAAO;AAAA,IACnD,kBAAkB,OAAO,SAAS,MAAM,SAAS,OAAO;AAAA,EAC1D;AACF;","names":[]}

package/dist/codemirror/tablev2/cellText.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cell text ↔ source transforms (GFM). A raw `|` inside a cell starts a new
+ * column; the only literal pipe is `\|`. Surfaces edit the UNESCAPED text and
+ * re-escape on commit, so typing `|` in a cell can never shift the row.
+ * Canonical home for the redesign (ADR 0001); the nested-editor copies retire
+ * with `tableCellSubview.ts`.
+ */
+declare function unescapePipes(source: string): string;
+declare function escapePipes(text: string): string;
+
+export { escapePipes, unescapePipes };

package/dist/codemirror/tablev2/cellText.js

@@ -0,0 +1,12 @@
+import "../../chunk-V6TY7KAL.js";
+function unescapePipes(source) {
+  return source.replace(/\\\|/g, "|");
+}
+function escapePipes(text) {
+  return text.replace(/\|/g, "\\|");
+}
+export {
+  escapePipes,
+  unescapePipes
+};
+//# sourceMappingURL=cellText.js.map

package/dist/codemirror/tablev2/cellText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/tablev2/cellText.ts"],"sourcesContent":["/**\n * Cell text ↔ source transforms (GFM). A raw `|` inside a cell starts a new\n * column; the only literal pipe is `\\|`. Surfaces edit the UNESCAPED text and\n * re-escape on commit, so typing `|` in a cell can never shift the row.\n * Canonical home for the redesign (ADR 0001); the nested-editor copies retire\n * with `tableCellSubview.ts`.\n */\n\nexport function unescapePipes(source: string): string {\n  return source.replace(/\\\\\\|/g, \"|\");\n}\n\nexport function escapePipes(text: string): string {\n  return text.replace(/\\|/g, \"\\\\|\");\n}\n"],"mappings":";AAQO,SAAS,cAAc,QAAwB;AACpD,SAAO,OAAO,QAAQ,SAAS,GAAG;AACpC;AAEO,SAAS,YAAY,MAAsB;AAChD,SAAO,KAAK,QAAQ,OAAO,KAAK;AAClC;","names":[]}

package/dist/codemirror/tablev2/inlineCellSurface.d.ts

@@ -0,0 +1,38 @@
+import { ChangeDesc } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { CellEditingSurface, CellRef, ActiveEdit } from './cellEditingSurface.js';
+
+/**
+ * Surface B — the cell `<td>` itself edits (ADR 0001 §Editing surface).
+ *
+ * `begin` swaps the rendered cell content for the raw text and flips the cell
+ * to `contenteditable="plaintext-only"`; the browser owns caret, typing, and
+ * intra-cell selection from there. Live text and caret are mirrored into
+ * surface state on every input/selection change, because the DOM copy is NOT
+ * durable: any widget patch rewrites cell innerHTML from (stale) data, and a
+ * full widget recreate replaces the element wholesale. `reanchor` restores
+ * text, caret, and focus onto whatever element currently renders the cell.
+ */
+
+declare class InlineCellSurface implements CellEditingSurface {
+    readonly kind: "inline";
+    private edit;
+    private readonly onInput;
+    private readonly onSelectionChange;
+    private readonly onFocusOut;
+    private readonly onBeforeInput;
+    begin(view: EditorView, tableFrom: number, ref: CellRef, caret?: number): boolean;
+    active(): ActiveEdit | null;
+    editingElement(): HTMLElement | null;
+    placeCaret(offset: number): void;
+    anchor(): number | null;
+    mapThrough(changes: ChangeDesc): void;
+    reanchor(view: EditorView): void;
+    commit(view: EditorView): void;
+    cancel(): void;
+    private attach;
+    private applyEditableState;
+    private teardown;
+}
+
+export { InlineCellSurface };