@helping-ai-workflow/md2doc 3.17.7 → 3.17.8

package/lib/editor/client.js

@@ -17387,7 +17387,16 @@
         // after a space (`**a **`) is not a closing delimiter in markdown.
         const r = document.createRange();
         r.selectNodeContents(cell);
-        if (trimRangeToText(r)) wrapRangeIn(r, tag, cell);
+        if (trimRangeToText(r)) {
+          // v3.17.8 D2 (final review I2): a cell whose text is one code span
+          // (a signal-name column) trims to the code's own text node, and the
+          // wrap landed inside the <code>, which the save drops. The mark goes
+          // around the code instead (`**`b`**`), as it goes around every other
+          // cell's text.
+          const code = tag !== 'CODE' ? wholeSelectionMark(r, 'CODE', cell) : null;
+          if (code) r.selectNode(code);
+          wrapRangeIn(r, tag, cell);
+        }
       }
     });
     snapBurstIfActive(burst.editEl, 'range-mark');
@@ -21616,6 +21625,15 @@
 
   // Applies the toggle policy for a plain mark type (STRONG/EM/CODE/DEL/U —
   // link has its own entry point below because it also needs a URL).
+  // v3.17.8 D2: Markdown cannot hold a mark inside a code span (serializeCode()
+  // writes the code's textContent), so a WRAP of anything but the code itself is
+  // refused when the selection lies wholly inside one <code>. One helper, read
+  // by selectionMarkStates() (the buttons' 'inert') and by the actions (the
+  // keyboard reaches them without a button), so the two cannot drift. Unwrapping
+  // a mark that wraps the code from outside stays allowed: that is spellable.
+  function wrapRefusedInCode(range, tag, root) {
+    return tag !== 'CODE' && !!wholeSelectionMark(range, 'CODE', root);
+  }
   function applyMarkToggle(tag) {
     if (cellRangeBurst()) { applyMarkToCellRange(tag); return; }
     const root = selToolbarEditEl;
@@ -21646,6 +21664,11 @@
       return;
     }
     if (!trimRangeToText(range)) return;   // 全空白／collapsed 選取：no-op
+    // v3.17.8 D2: judged on the TRIMMED range, as the wrap sees it. A double
+    // click on a code span's last word also selects the space after it; the
+    // untrimmed range then ends outside the <code>, the trim pulls it back in,
+    // and the wrap landed inside the code (final review I1).
+    if (wrapRefusedInCode(range, tag, root)) return;
     snapBurstIfActive(root, 'mark-pre');
     reselectAndReposition(wrapRangeIn(range, tag, root));
     snapBurstIfActive(root, 'mark');
@@ -21990,6 +22013,7 @@
     // An all-whitespace range trims to nothing: bail before the field opens,
     // or accepting it would wrap a bare space in an <a>.
     if (!trimRangeToText(range)) return;
+    if (wrapRefusedInCode(range, 'A', root)) return;   // v3.17.8 D2
     openLinkField({ root, range, existing: null, prefill: '' });
   }
 
@@ -23382,7 +23406,9 @@
   //    <strong> was gone, the paragraph's text was unchanged, and the file
   //    saved back with no `**` in it. So drawing every button inert there
   //    would grey out a button that acts.
-  //  * 'A' never reaches it. The link button does not go through
+  //  * (v3.17.8 D2) A selection wholly inside one <code> makes every other
+  //    tag's would-wrap state 'inert' too, 'A' included: wrapRefusedInCode().
+  //  * Otherwise 'A' never reaches it. The link button does not go through
   //    applyMarkToggle() at all — applyLinkToggle() has the same first two
   //    branches, and since v3.4.0 its third refuses an all-whitespace
   //    selection through trimRangeToText() before the URL field opens. The
@@ -23405,11 +23431,13 @@
     if (!hasFormattableSelection(sel)) return null;
     const root = selToolbarEditEl;
     const range = sel.getRangeAt(0);
-    const wrappable = trimRangeToText(range.cloneRange());
+    const trimmed = range.cloneRange();
+    const wrappable = trimRangeToText(trimmed);
     const out = {};
     for (const tag of MARK_TAGS) {
       if (wholeSelectionMark(range, tag, root)) out[tag] = 'whole';
       else if (overlappingMarks(range, tag, root).length > 0) out[tag] = 'partial';
+      else if (wrapRefusedInCode(wrappable ? trimmed : range, tag, root)) out[tag] = 'inert';   // v3.17.8 D2, trimmed as the wrap sees it
       else if (wrappable || tag === 'A') out[tag] = 'none';
       else out[tag] = 'inert';
     }
@@ -26109,6 +26137,15 @@
   // file kept the plain word. This listener is registered ahead of the
   // `native-format-pre` one below (both capture phase on document, so they
   // run in that order), so the burst exists when that one snaps it.
+  // v3.17.8 D2: the browser's own Ctrl+B / I / U must not wrap inside a code
+  // span either (it would draw <b> in a <code> that the save then drops).
+  document.addEventListener('beforeinput', (e) => {
+    if (!NATIVE_FORMAT_INPUT_TYPES.has(e.inputType) || e.inputType === 'formatRemove') return;
+    const surface = e.target && e.target.closest ? e.target.closest('.ed-wys-armed, .ed-wys-cell') : null;
+    const sel = window.getSelection();
+    if (!surface || !sel || !sel.rangeCount || sel.isCollapsed) return;
+    if (wholeSelectionMark(sel.getRangeAt(0), 'CODE', surface)) e.preventDefault();
+  }, true);
   document.addEventListener('beforeinput', (e) => {
     if (e.defaultPrevented) return;
     const t = e.inputType;

package/lib/editor/inline-md.js

@@ -25,6 +25,7 @@
     return ch !== undefined && /\w/.test(ch);
   }
 
+  const REFERENCE_SHAPE = /^&#?\w+;/;
   function escapeText(s) {
     let out = '';
     for (let i = 0; i < s.length; i++) {
@@ -36,6 +37,13 @@
       if (c === ']') { out += '\\]'; continue; }
       if (c === '<') { out += '&lt;'; continue; }
       if (c === '~') { out += '\\~'; continue; }
+      // v3.17.8 D3: an `&` that starts something shaped like a character
+      // reference (`&amp;`, `&#38;`, `&x_1;`) is written `\&`, or the reader
+      // decodes what the person typed (`a &amp; b` showed `a & b`). The shape
+      // is marked's own, `&#?\w+;` (its escape() leaves exactly that alone),
+      // so it covers every reference a browser could decode. Any other `&`
+      // (`AT&T`, `&copy` with no `;`) is shown as typed and stays bare.
+      if (c === '&' && REFERENCE_SHAPE.test(s.slice(i, i + 40))) { out += '\\&'; continue; }
       if (c === '_') {
         const prev = s[i - 1];
         const next = s[i + 1];

package/lib/editor/paste-md.js

@@ -381,6 +381,20 @@ function htmlToMarkdown(html) {
     codeBlockStyle: 'fenced',
     emDelimiter: '*'
   });
+  // v3.17.8 D3: turndown's escape() covers Markdown punctuation only, so
+  // pasted TEXT that spells HTML came back as markup: `<b>x</b>` turned bold,
+  // `<!-- c -->` vanished, `&amp;` showed as `&`. A `<` that could open a tag,
+  // a comment or an autolink is written `&lt;`, and an `&` shaped like a
+  // character reference is written `\&` -- the spellings inline-md.js's
+  // escapeText() gives typed text. A bare `<` (`1 < 2`) or `&` (`AT&T`) is
+  // already shown as typed and stays bare. Code is not escaped by turndown
+  // at all, and needs none: a code span is literal.
+  var baseEscape = service.escape;
+  service.escape = function (s) {
+    return baseEscape.call(this, s)
+      .replace(/&(?=#?\w+;)/g, '\\&')
+      .replace(/<(?=[A-Za-z\/!?])/g, '&lt;');
+  };
   addStrikethroughRule(service);
   addFlankingEmphasisRules(service);
   addTableRules(service);

package/lib/editor/table-md.js

@@ -29,14 +29,14 @@
   // nothing to do with text alignment. Reading them as alignment would be a
   // bug; they are deliberately never consulted below.
   //
-  // ── Emission form (spec §4 / task-5 brief, amended by v3.0.1) ──────────
-  // There are TWO emission forms, and exactly one gate selects between them:
-  // whether serializeTable() was handed an `originalMd` it could turn into a
-  // usable width source (columnWidthsOf() parsed it, AND the greedy
-  // header-TEXT walk in serializeTable() matched EVERY original column, in
-  // order — the all-or-nothing gate). No second argument, an unparseable or
-  // ragged original, a renamed header, a dropped column: all of them land on
-  // form A.
+  // ── Emission form (spec §4 / task-5 brief, amended by v3.0.1, v3.17.8) ─
+  // There are TWO emission forms for the padding. Form B applies when
+  // serializeTable() was handed an `originalMd` it could turn into a width
+  // source: columnWidthsOf() parsed it (not ragged) and the forward header
+  // scan in serializeTable() found no MOVED column. Since v3.0.2 a renamed
+  // or dropped column no longer voids it; only that column loses its width.
+  // No second argument, an unparseable or ragged original, a moved column:
+  // all of them land on form A.
   //
   //   A. MINIMAL form (pre-v3.0.1, unchanged, and still what
   //      `serializeTable(tableEl)` with no second argument emits — byte for
@@ -60,18 +60,30 @@
   //      separators Prettier and VS Code emit ('| ----- | --- |') survive a
   //      no-op instead of being rebuilt flush ('|-------|-----|').
   //
-  // Independent of the form: a literal '|' inside
-  // a cell -> '&#124;'; a cell newline is the literal '<br>' inline-md.js's
+  // Cell bytes (v3.17.8 F1, both forms): a cell whose original field reads
+  // the same as its current content (see readsSame()) is written with the
+  // original field's bytes, trimmed; every other cell gets the canonical
+  // spelling below. A header row or body row whose cells were ALL reused, in
+  // the original columns, with no column widened past that line's own
+  // fields, is the original line itself (trimmed), odd padding like '|a|b|'
+  // included. Body rows are paired with original rows by pairBodyRows(), so a
+  // row inserted, deleted or moved leaves the others as they were. With no
+  // parser nothing is reused, and the output is what it was before v3.17.8.
+  //
+  // Canonical spelling: a literal '|' inside a cell's text -> '&#124;'; a
+  // cell newline is the literal '<br>' inline-md.js's
   // serializeInline() already emits for both a real <br> node and a
   // contenteditable <div> line-split boundary — AND (final-review Finding 1
   // defense-in-depth) any raw '\n'/'\r' that still reaches a text node is
   // collapsed to '<br>' here too, via escapeNewlines() below, so a cell can
   // never split serializeTable()'s output into more physical lines than
-  // it has rows. No trailing whitespace on any emitted line (every row/
-  // separator line is built as '|'-delimited fields, so it always ends in
-  // '|', never in whitespace, by construction). A '|' inside a <code> span
-  // is written as '\|' instead (v3.17.6) — see codePipesOf() below; the one
-  // code text that has no table spelling reports 'CODE' unsupported.
+  // it has rows. A '|' inside a <code> span is written as '\|' instead
+  // (v3.17.6) — see codePipesOf() below; the one code text that has no
+  // table spelling reports 'CODE' unsupported. A reused field never holds a
+  // newline or an unescaped '|' (it is one field of one source line). No
+  // trailing whitespace on any emitted line: a built row or separator is
+  // '|'-delimited fields, and an original line is trimmed and, to be read
+  // at all, ends in an unescaped '|' (splitFields()).
   //
   // Constrained (same as inline-md.js, and for the same reason: the node
   // test drives this with the hand-rolled element stub from
@@ -190,22 +202,35 @@
   // width of 3 is indistinguishable from this serializer's own minimal
   // form, which is exactly 3 on every row by construction).
   //
-  // Source THIS serializer produced holds '\|' only inside code spans (plain
-  // text gets '&#124;'), and a hand-written table may use '\|' anywhere, so
-  // the split must not break on an escaped delimiter.
+  // A hand-written table may use '\|' anywhere, and since v3.17.8 so may
+  // this serializer's output (a reused field keeps the author's '\|'), so
+  // the split must not break on an escaped delimiter. Escaped means what
+  // marked's splitCells() means (v3.17.8 F3): an ODD run of backslashes
+  // before the '|'. A backslash and the character after it are taken as one
+  // pair, so '\\|' is an escaped backslash and then a delimiter; before this
+  // the split read that '|' as escaped, the row came out one field short and
+  // the whole table lost its width memory. A line whose last '|' is escaped
+  // has no closing delimiter and is not a row this can read (see the end).
   function splitFields(line) {
     const t = line.trim();
-    if (t.charAt(0) !== '|' || t.charAt(t.length - 1) !== '|' || t.length < 2) return null;
-    const inner = t.slice(1, -1);
+    if (t.charAt(0) !== '|' || t.length < 2) return null;
     const out = [];
     let cur = '';
-    for (let i = 0; i < inner.length; i++) {
-      const c = inner.charAt(i);
-      if (c === '\\' && inner.charAt(i + 1) === '|') { cur += '\\|'; i += 1; continue; }
+    for (let i = 1; i < t.length; i++) {
+      const c = t.charAt(i);
+      if (c === '\\' && i + 1 < t.length) { cur += c + t.charAt(i + 1); i += 1; continue; }
       if (c === '|') { out.push(cur); cur = ''; continue; }
       cur += c;
     }
-    out.push(cur);
+    // A line whose last '|' is escaped (`| p | q \|`) has no closing
+    // delimiter: not a row this can read, so it is never reused and the table
+    // has no width memory. v3.17.8's final-review round 1 split it the old way
+    // instead (last '|' closes the row) to keep the width memory, and the
+    // re-review found that this loses an edit: the field ` q \` read alone is
+    // `q \`, but in its line it reads `q |`, so an edit from `q |` to `q \`
+    // read "the same" and the original line came back (N1). Width memory
+    // for such a rare table is not worth that.
+    if (cur !== '') return null;
     return out;
   }
 
@@ -268,6 +293,231 @@
     return { widths, headerFields: first.map((f) => f.trim()), sepFields };
   }
 
+  // ── v3.17.8 F1: an untouched cell keeps its bytes ─────────────────────
+  // Every cell is serialized from the DOM, so a cell nobody edited comes
+  // back in this file's canonical spelling: a plain '[' as '\[', a
+  // plain-text '\|' as '&#124;'. The meaning is the same; the git diff is
+  // not. So a current cell reuses its ORIGINAL field (trimmed) when the two
+  // spellings READ the same, and that is decided by parsing, not by rules:
+  // a private `new Marked({ gfm: true, breaks: false })` (the same family as
+  // inline-md.js's getInlineParser(); server.js injects marked before the
+  // editor modules) renders each spelling as the one cell of a one-column
+  // table, and the two cell HTMLs are compared after character references
+  // in their text are decoded (marked passes '&#124;' through, the browser
+  // shows '|'). A cell is parsed once per string (readCache).
+  //
+  // The plain parser has none of md2doc's sub / sup / KaTeX extensions, so
+  // an original holding an unescaped '~', '^' or '$' is reused only when it
+  // is byte-equal to the canonical spelling (R5). No parser (a page without
+  // marked, or setCellParser(null)): nothing is reused and every byte is
+  // what the serializer wrote before v3.17.8.
+  let cellParser; // undefined: not looked up yet; null: none available
+  const readCache = new Map();
+  function getCellParser() {
+    if (cellParser !== undefined) return cellParser;
+    cellParser = null;
+    try {
+      let lib = null;
+      if (typeof module === 'object' && module.exports && typeof require === 'function') lib = require('marked');
+      else if (typeof self !== 'undefined' && self.marked) lib = self.marked;
+      if (lib && typeof lib.Marked === 'function') {
+        const m = new lib.Marked({ gfm: true, breaks: false });
+        cellParser = (s) => m.parse(s);
+      }
+    } catch (e) {
+      cellParser = null;
+    }
+    return cellParser;
+  }
+  // Tests swap the parser: a function (markdown -> HTML), null to switch
+  // reuse off, or nothing to go back to the lookup above.
+  function setCellParser(fn) {
+    cellParser = typeof fn === 'function' ? fn : (fn === null ? null : undefined);
+    readCache.clear();
+  }
+
+  const CELL_HEAD = '<table>\n<thead>\n<tr>\n<th>h</th>\n</tr>\n</thead>\n<tbody><tr>\n<td>';
+  const CELL_TAIL = '</td>\n</tr>\n</tbody></table>\n';
+  const NAMED_REF = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+  // A named reference outside NAMED_REF cannot be decoded here, so a cell
+  // holding one has no reading at all (final review I3): left as it was, the
+  // `&` was re-escaped and `&copy;` (shows ©) read the same as the typed
+  // text `\&copy;` (shows &copy;), so an edit to that text was overwritten
+  // by the original bytes. Such a cell is now reused only when byte-equal.
+  const UNKNOWN_REF = {};
+  function decodeRef(m, dec, hex, name) {
+    if (name !== undefined) {
+      if (NAMED_REF[name] !== undefined) return NAMED_REF[name];
+      throw UNKNOWN_REF;
+    }
+    const n = dec !== undefined ? parseInt(dec, 10) : parseInt(hex, 16);
+    return n === 0 || n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff) ? '�' : String.fromCodePoint(n);
+  }
+  // Text between tags: references decoded, then & < > " re-escaped, so two
+  // spellings of one character give one string. Tags are left as they are.
+  // HTML comments are dropped first: nothing shows them, the editor's DOM
+  // walk skips them (so the canonical spelling never has one), and
+  // inline-md.js's own read-back (htmlMarks()) skips them too. That keeps
+  // an untouched cell's comments, e.g. the `<!-- [[source, Cl.x]] -->`
+  // citation anchors in paperwork's hwe1 tables, which the canonical
+  // spelling would drop.
+  function normalizeCellHtml(html) {
+    return html.replace(/<!--[\s\S]*?-->/g, '').split(/(<[^>]*>)/).map((part, i) => (i % 2 ? part : part
+      .replace(/&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|([A-Za-z][A-Za-z0-9]*));/g, decodeRef)
+      .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'))).join('');
+  }
+  // The normalized HTML of `field` as the one cell of a one-column table, or
+  // null when it is not read as exactly that (then it never reads the same
+  // as anything).
+  function cellReading(parse, field) {
+    if (readCache.has(field)) return readCache.get(field);
+    let v = null;
+    try {
+      const html = parse('| h |\n| - |\n| ' + field + ' |');
+      if (typeof html === 'string' && html.startsWith(CELL_HEAD) && html.endsWith(CELL_TAIL)) {
+        const inner = html.slice(CELL_HEAD.length, html.length - CELL_TAIL.length);
+        if (inner.indexOf('</td>') === -1) v = normalizeCellHtml(inner);
+      }
+    } catch (e) {
+      v = null;
+    }
+    // FIFO, not a clear: a table larger than the cap read itself cold on every
+    // commit when the whole cache was dropped (final review M1).
+    if (readCache.size >= READ_CACHE_MAX) readCache.delete(readCache.keys().next().value);
+    readCache.set(field, v);
+    return v;
+  }
+  const READ_CACHE_MAX = 100000;
+  // One string per cell such that readsSame(a, b) === (readingKey(a) ===
+  // readingKey(b)): a cell with a reading is keyed by it, one without by its
+  // bytes, so it only ever pairs with itself. pairBodyRows() hashes rows on it.
+  function readingKey(parse, x) {
+    if (!parse) return 'B' + x;
+    const r = cellReading(parse, x);
+    return r === null ? 'B' + x : 'R' + r;
+  }
+  function readsSame(parse, a, b) {
+    if (a === b) return true;
+    const ra = cellReading(parse, a);
+    return ra !== null && ra === cellReading(parse, b);
+  }
+  // '~' (sub), '^' (sup) or '$' (KaTeX) after an even backslash run (R5).
+  const EXTENSION_CHAR = /(?:^|[^\\])(?:\\\\)*[~^$]/;
+
+  // The original table's rows for reuse: { header, body } where `header` is
+  // { fields, line } and `body` holds one { fields, line } per body row, or
+  // null for a line splitFields() cannot read (it is then never paired).
+  // `line` is the source line trimmed. Unlike columnWidthsOf(), a ragged row
+  // does not void the table: reuse is decided per cell. null when there is
+  // no original or its header line is not a row.
+  function originalRowsOf(originalMd) {
+    if (typeof originalMd !== 'string' || originalMd === '') return null;
+    const rows = originalMd.split('\n').filter((l) => l.trim() !== '');
+    if (rows.length < 2) return null;
+    const row = (l) => { const f = splitFields(l); return f ? { fields: f, line: l.trim() } : null; };
+    const header = row(rows[0]);
+    if (!header) return null;
+    return { header, body: rows.slice(2).map(row) };
+  }
+
+  // Pairs each current body row with an original body row (an index into
+  // `origBody`, or -1). A row "matches" when every mapped cell reads the
+  // same. (1) a forward greedy scan pairs matching rows in order — the
+  // anchors; (2) a row left over that matches some unused original anywhere
+  // is paired with it (a moved row); (3) the rows still left between two
+  // anchors are paired in order with the unused originals between the same
+  // anchors — that is an edited row, whose other cells are then reused one
+  // by one. A wrong pair only costs preserved bytes: every reuse is gated by
+  // readsSame() again, cell by cell.
+  // Linear in rows (final review M1: the scans were quadratic, 3000 rows
+  // that all differ took 3 s): each row is hashed on its mapped cells'
+  // readingKey(), so "matches" is one Map lookup.
+  function pairBodyRows(curRows, origBody, colMap, keyOf) {
+    const mapped = [];
+    colMap.forEach((k, i) => { if (k !== undefined) mapped.push(i); });
+    const pair = new Array(curRows.length).fill(-1);
+    if (mapped.length === 0) return pair;
+    const SEP = '\u0000';
+    const origKey = origBody.map((o) => {
+      if (!o) return null;
+      const parts = [];
+      for (let x = 0; x < mapped.length; x++) {
+        const f = o.fields[colMap[mapped[x]]];
+        if (f === undefined) return null;
+        parts.push(keyOf(f.trim()));
+      }
+      return parts.join(SEP);
+    });
+    const curKey = curRows.map((row) => mapped.map((i) => keyOf(row[i])).join(SEP));
+    // key -> { list: ascending original indices, p1: step-1 cursor, p2: step-2 cursor }
+    const byKey = new Map();
+    origKey.forEach((k, q) => {
+      if (k === null) return;
+      let e = byKey.get(k);
+      if (!e) { e = { list: [], p1: 0, p2: 0 }; byKey.set(k, e); }
+      e.list.push(q);
+    });
+    const used = new Array(origBody.length).fill(false);
+    const anchor = new Array(curRows.length).fill(false);
+    // (1) forward greedy: the first unused match at or after j. Every original
+    // used in this step lies before j, so a cursor that skips indices < j
+    // finds it, and it only moves forward.
+    let j = 0;
+    for (let c = 0; c < curRows.length; c++) {
+      const e = byKey.get(curKey[c]);
+      if (!e) continue;
+      while (e.p1 < e.list.length && e.list[e.p1] < j) e.p1++;
+      if (e.p1 < e.list.length) {
+        const q = e.list[e.p1++];
+        pair[c] = q; used[q] = true; anchor[c] = true; j = q + 1;
+      }
+    }
+    // (2) a leftover row that matches an unused original anywhere (moved).
+    for (let c = 0; c < curRows.length; c++) {
+      if (pair[c] !== -1) continue;
+      const e = byKey.get(curKey[c]);
+      if (!e) continue;
+      while (e.p2 < e.list.length && used[e.list[e.p2]]) e.p2++;
+      if (e.p2 < e.list.length) { const q = e.list[e.p2++]; pair[c] = q; used[q] = true; }
+    }
+    // (3) the rows still left between two anchors take the unused originals
+    // between the same anchors, in order.
+    const nextAnchorQ = new Array(curRows.length + 1);
+    nextAnchorQ[curRows.length] = origBody.length;
+    for (let c = curRows.length - 1; c >= 0; c--) nextAnchorQ[c] = anchor[c] ? pair[c] : nextAnchorQ[c + 1];
+    let q = 0;
+    for (let c = 0; c < curRows.length; c++) {
+      if (anchor[c]) { q = pair[c] + 1; continue; }
+      if (pair[c] !== -1) continue;
+      const nextQ = nextAnchorQ[c + 1];
+      while (q < nextQ && (used[q] || !origBody[q])) q++;
+      if (q < nextQ) { pair[c] = q; used[q] = true; q++; }
+    }
+    return pair;
+  }
+
+  // The contents a row is emitted with: each cell's original field where it
+  // may be reused, else its canonical content. `whole` is true when every
+  // cell was reused and the columns are the original's, in order — the row
+  // may then be the original line itself (decided at emission, once widths
+  // are known).
+  function reuseRow(parse, canon, cellBad, orig, colMap, nOrigCols) {
+    if (!orig) return { contents: canon, whole: false };
+    let whole = canon.length === orig.fields.length && canon.length === nOrigCols;
+    const contents = canon.map((c, i) => {
+      const k = colMap[i];
+      if (k !== i) whole = false;
+      const field = k === undefined ? undefined : orig.fields[k];
+      if (field === undefined || cellBad[i]) { whole = false; return c; }
+      const f = field.trim();
+      if (f === c) return c;
+      if (!EXTENSION_CHAR.test(f) && readsSame(parse, f, c)) return f;
+      whole = false;
+      return c;
+    });
+    return { contents, whole };
+  }
+
   // ' content ' right-padded out to `width`. NEVER truncates: a cell whose
   // content grew past the original column simply widens that column, and a
   // deliberately blank hand-aligned cell (e.g. `|     |` kept wide on
@@ -380,13 +630,22 @@
     // Render every cell's content up front (same order the pre-v3.0.1 code
     // walked: header first, then each body row left-to-right), so the width
     // pass below and the emission pass after it share one rendering.
-    const headerContents = headerCells.map((c) => cellContentOf(c, unsupported));
-    const bodyContentRows = bodyRows.map((tr) =>
-      elementChildren(tr).filter(isCell).map((c) => cellContentOf(c, unsupported)));
+    // `bad` marks a cell that reported unsupported: it is never reused, so a
+    // reuse can never stand in for (or hide) such a cell.
+    const cellOf = (c) => {
+      const before = unsupported.length;
+      const md = cellContentOf(c, unsupported);
+      return { md, bad: unsupported.length !== before };
+    };
+    const headerCellMd = headerCells.map(cellOf);
+    const bodyCellMd = bodyRows.map((tr) => elementChildren(tr).filter(isCell).map(cellOf));
+    // The canonical contents; replaced below by the reused ones (F1).
+    let headerContents = headerCellMd.map((x) => x.md);
+    let bodyContentRows = bodyCellMd.map((row) => row.map((x) => x.md));
 
     // Read the ORIGINAL widths first, then line each CURRENT header column
-    // up with the original column it corresponds to BY TEXT, not by raw
-    // index. A column inserted in the MIDDLE (insertColumn() in client.js)
+    // up with the original column it corresponds to BY TEXT (since v3.17.8,
+    // by how the text reads: `same` below), not by raw index. A column inserted in the MIDDLE (insertColumn() in client.js)
     // shifts every later column's index by one without changing what that
     // column actually is — matching by index alone would hand the shifted
     // column a stale neighbour's width, and the freshly-inserted empty
@@ -411,6 +670,17 @@
     // patch release carries. See test/table-width.test.js cases 14, 15, 20,
     // 21, 23 and 24, which pin every branch of the above.
     const original = columnWidthsOf(originalMd);
+    // F1: with a parser, names are compared by how they READ (a header
+    // spelled 'a\_b' in the file is the DOM's 'a_b'); without one, by bytes,
+    // as before. `src` is the original's rows for reuse (null: no reuse).
+    const parse = getCellParser();
+    const same = parse ? (a, b) => readsSame(parse, a, b) : (a, b) => a === b;
+    const src = parse ? originalRowsOf(originalMd) : null;
+    const origNames = original ? original.headerFields
+      : (src ? src.header.fields.map((f) => f.trim()) : null);
+    // colIdx[i]: the original column current column i was matched to.
+    const colIdx = new Array(headerContents.length);
+    let moved = false;
     let widths = null;
     // Set for a column that falls off the END of the original header list
     // (every original column has already been matched by the time this one
@@ -445,8 +715,7 @@
     //     separator did not actually change (F1, final review) — see the
     //     verbatim gate at the emission site.
     const matchedSepFields = new Array(headerContents.length);
-    if (original) {
-      const matched = new Array(headerContents.length);
+    if (origNames) {
       // v3.0.2: a FORWARD SCAN, not the pre-v3.0.2 lockstep compare. The
       // lockstep version left `j` parked on the first original column that
       // did not match, so it could never recover from one mismatch — and
@@ -460,15 +729,14 @@
       for (let i = 0; i < headerContents.length; i++) {
         const name = headerContents[i].trim();
         let k = -1;
-        for (let q = j; q < original.headerFields.length; q++) {
-          if (original.headerFields[q].trim() === name) { k = q; break; }
+        for (let q = j; q < origNames.length; q++) {
+          if (same(origNames[q].trim(), name)) { k = q; break; }
         }
         if (k >= 0) {
-          matched[i] = original.widths[k];
-          matchedSepFields[i] = original.sepFields[k];
+          colIdx[i] = k;
+          if (original) matchedSepFields[i] = original.sepFields[k];
           j = k + 1;
         } else {
-          matched[i] = undefined;
           // The EMPTY name is exempt from the reorder test below, and the
           // exemption is load-bearing, not defensive: insertColumn()
           // (lib/editor/client.js:6448-6465) creates a th (or td) with no
@@ -479,7 +747,7 @@
           // whole-table refusal — a straight regression against v3.0.1 on
           // the ordinary insert-a-column-twice flow.
           if (name !== '') unmatchedNames.push(name);
-          if (j >= original.headerFields.length) sepFallbackNatural[i] = true;
+          if (original && j >= origNames.length) sepFallbackNatural[i] = true;
         }
       }
       // A column that could not find itself in what remains of the original,
@@ -489,10 +757,50 @@
       // so it still discards the width source for the WHOLE table. A name
       // that is absent from the original entirely is an insert or a rename:
       // nothing stale to carry, so its neighbours keep their widths.
-      const moved = unmatchedNames.some((n) =>
-        original.headerFields.some((f) => f.trim() === n));
+      moved = unmatchedNames.some((n) =>
+        origNames.some((f) => same(f.trim(), n)));
+      // F1: the cells of a column the scan did not match (a moved one) are
+      // still reused when exactly one unmatched original column has its name.
+      // This feeds reuse only; the width refusal above stands.
+      if (src) {
+        const taken = new Set(colIdx.filter((k) => k !== undefined));
+        for (let i = 0; i < headerContents.length; i++) {
+          const name = headerContents[i].trim();
+          if (colIdx[i] !== undefined || name === '') continue;
+          const hits = [];
+          for (let q = 0; q < origNames.length; q++) {
+            if (!taken.has(q) && same(origNames[q].trim(), name)) hits.push(q);
+          }
+          if (hits.length === 1) { colIdx[i] = hits[0]; taken.add(hits[0]); }
+        }
+      }
+    }
+
+    // F1: reuse each untouched cell's original bytes (see reuseRow()), before
+    // the widths are settled, so the reused contents are what they measure.
+    let headerWhole = false;
+    const bodyWhole = bodyContentRows.map(() => false);
+    const bodyOrig = bodyContentRows.map(() => null);
+    if (src) {
+      const nOrigCols = src.header.fields.length;
+      const h = reuseRow(parse, headerContents, headerCellMd.map((x) => x.bad), src.header, colIdx, nOrigCols);
+      headerContents = h.contents;
+      headerWhole = h.whole;
+      const pair = pairBodyRows(bodyContentRows, src.body, colIdx, (x) => readingKey(parse, x));
+      bodyContentRows = bodyContentRows.map((canon, r) => {
+        const orig = pair[r] === -1 ? null : src.body[pair[r]];
+        const b = reuseRow(parse, canon, bodyCellMd[r].map((x) => x.bad), orig, colIdx, nOrigCols);
+        bodyWhole[r] = b.whole;
+        bodyOrig[r] = orig;
+        return b.contents;
+      });
+    }
+
+    if (original) {
       if (!moved) {
-        widths = matched;
+        // Not moved means the name rescue above found nothing (an unmatched
+        // name is absent from the original), so colIdx is the scan's alone.
+        widths = colIdx.map((k) => (k === undefined ? undefined : original.widths[k]));
         // A matched column is then widened, for every row of that column
         // at once (header + separator + every body row), to whatever the
         // grown content now needs — the padding floor rises but never
@@ -515,8 +823,14 @@
       }
     }
 
+    // F1: a row whose cells were all reused, in the original columns, is the
+    // original line itself (trimmed), padding and all, unless a column it
+    // holds was widened past that line's own field.
+    const asWritten = (whole, orig) => whole && orig.fields.every((f, i) =>
+      !widths || widths[i] === undefined || widths[i] <= f.length);
     const lines = [];
-    lines.push(serializeRow(headerContents, widths));
+    lines.push(asWritten(headerWhole, src && src.header) ? src.header.line
+      : serializeRow(headerContents, widths));
     lines.push('|' + headerCells.map((c, i) => {
       // Preference order for a column's separator width:
       //   1. widths[i] — this column is a full hand-aligned width source
@@ -592,10 +906,11 @@
       return sepCellFor(align, w);
     }).join('|') + '|');
 
-    bodyContentRows.forEach((contents) => lines.push(serializeRow(contents, widths)));
+    bodyContentRows.forEach((contents, r) => lines.push(asWritten(bodyWhole[r], bodyOrig[r])
+      ? bodyOrig[r].line : serializeRow(contents, widths)));
 
     return { md: lines.join('\n'), unsupported };
   }
 
-  return { serializeTable };
+  return { serializeTable, setCellParser };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helping-ai-workflow/md2doc",
-  "version": "3.17.7",
+  "version": "3.17.8",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, Graphviz, and draw.io support",
   "keywords": [
     "markdown",