@helping-ai-workflow/md2doc 3.17.6 → 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];
@@ -154,6 +162,13 @@
     return inner.indexOf(']') === -1;
   }
 
+  // The test serializeAnchor() uses to write `[[body]]` (v3.17.7: shared
+  // with serializeInline()'s read-back check).
+  function isCitationNode(node) {
+    const href = typeof node.getAttribute === 'function' ? node.getAttribute('href') : null;
+    const text = node.textContent;
+    return !!href && href.charAt(0) === '#' && /^\[.*\]$/.test(text) && isCitationEligible(node, text);
+  }
   function serializeAnchor(node, unsupported, opts) {
     const href = node.getAttribute('href');
     // A raw HTML anchor (`<a id="ref-x"></a>`, NO href attribute) is not a
@@ -391,10 +406,16 @@
     if (typeof node.getAttribute !== 'function') return false;
     return (' ' + (node.getAttribute('class') || '') + ' ').indexOf(' search-hit ') !== -1;
   }
-  function walkChildren(nodes, unsupported, opts) {
+  // `ctx` (v3.17.7) says how a STRONG / EM nested inside another STRONG / EM
+  // is spelled; see serializeInline(). Absent means the plain `*` spelling.
+  // `touching` (v3.17.7) is the mark tag that ends right before these
+  // nodes, for a transparent wrapper whose first child may need the
+  // same-tag guard against it.
+  function walkChildren(nodes, unsupported, opts, ctx, touching) {
+    const c = ctx || PLAIN;
     let out = '';
     let firstSegment = true;
-    let lastMarkTag = null;
+    let lastMarkTag = touching || null;
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
       if (node.nodeType === 3) {
@@ -409,7 +430,7 @@
       if (name === 'DIV') {
         let added = '';
         if (!firstSegment) added += '<br>';
-        const inner = walkChildren(node.childNodes, unsupported, opts);
+        const inner = walkChildren(node.childNodes, unsupported, opts, c);
         added += inner.md;
         out = appendPiece(out, added);
         if (added.length) lastMarkTag = inner.md.length ? inner.lastMarkTag : null;
@@ -419,7 +440,7 @@
       if (name === 'MARK' && markIsSearchHit(node)) {
         // v3.14.0 T9: the reader's search paints its hits as this element and
         // it is transient, so it serializes as what it wraps.
-        const inner = walkChildren(node.childNodes, unsupported, opts);
+        const inner = walkChildren(node.childNodes, unsupported, opts, c, lastMarkTag);
         out = appendPiece(out, inner.md);
         if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         firstSegment = false;
@@ -429,7 +450,7 @@
         if (spanHasAttributes(node)) {
           unsupported.push(name);
         } else {
-          const inner = walkChildren(node.childNodes, unsupported, opts);
+          const inner = walkChildren(node.childNodes, unsupported, opts, c, lastMarkTag);
           out = appendPiece(out, inner.md);
           if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         }
@@ -438,12 +459,12 @@
       }
       if (name === 'STRONG' || name === 'B' || name === 'EM' || name === 'I') {
         const tag = (name === 'STRONG' || name === 'B') ? 'STRONG' : 'EM';
-        const delim = tag === 'STRONG' ? '**' : '*';
-        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts).md);
+        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts, c.inner).md);
         if (e.core) {
           // a hoisted leading space already separates two same-tag runs
           const guard = !e.lead && lastMarkTag === tag ? '<!-- -->' : '';
-          out = appendPiece(out, e.lead + guard + delim + e.core + delim + e.trail);
+          const delim = c.delims[tag];
+          out = appendPiece(out, e.lead + guard + c.before + delim + e.core + delim + c.after + e.trail);
           lastMarkTag = e.trail ? null : tag;
         } else if (e.lead || e.trail) {
           out = appendPiece(out, e.lead + e.trail);
@@ -458,9 +479,15 @@
         // accepted on input (some contenteditable/paste paths produce it)
         // but the toolbar/serializer always speak DEL, matching what marked
         // itself emits.
-        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts).md);
-        out = appendPiece(out, e.core ? e.lead + '~~' + e.core + '~~' + e.trail : e.lead + e.trail);
-        if (e.core || e.lead || e.trail) lastMarkTag = null;
+        //
+        // v3.17.7 N2: two strikethroughs side by side get the same guard as
+        // two bolds. `~~a~~~~b~~` reads as ONE del holding `a~~~~b` (measured
+        // on 71fedaa: strike `two` right after `~~one~~` wrote exactly that).
+        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts, c).md);
+        const guard = e.core && !e.lead && lastMarkTag === 'DEL' ? '<!-- -->' : '';
+        out = appendPiece(out, e.core ? e.lead + guard + '~~' + e.core + '~~' + e.trail : e.lead + e.trail);
+        if (e.core) lastMarkTag = e.trail ? null : 'DEL';
+        else if (e.lead || e.trail) lastMarkTag = null;
         firstSegment = false;
         continue;
       }
@@ -475,14 +502,18 @@
         // backtick, literal `<u>` typed as plain text is already escaped by
         // the `<` -> `&lt;` rule above, so it can never collide with a real
         // toolbar-made underline.
-        out = appendPiece(out, '<u>' + walkChildren(node.childNodes, unsupported, opts).md + '</u>');
+        out = appendPiece(out, '<u>' + walkChildren(node.childNodes, unsupported, opts, c).md + '</u>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'CODE') {
-        out = appendPiece(out, serializeCode(node, opts));
-        lastMarkTag = null;
+        // v3.17.7 N3: two code spans side by side are one span to a reader
+        // (`` `one``two` `` is the code "one``two"), so they get a guard too.
+        // serializeCode() never writes an empty span, so this always fires
+        // between two real ones.
+        out = appendPiece(out, (lastMarkTag === 'CODE' ? '<!-- -->' : '') + serializeCode(node, opts));
+        lastMarkTag = 'CODE';
         firstSegment = false;
         continue;
       }
@@ -536,13 +567,227 @@
     return { md: out, lastMarkTag };
   }
 
+  // ── v3.17.7 N1: check the bytes with the reader's own parser ─────────────
+  //
+  // A STRONG / EM nested inside another STRONG / EM is written `*` / `**`
+  // like any other, and most of the time marked reads that back. Not always:
+  // marked's emphasis scan (emStrong in marked 14) walks from an opening run
+  // to its closer counting the `*` runs in between, and a run with word
+  // characters on both sides is a "mid" run it may skip under the rule of 3.
+  // Whether a nested mark survives therefore depends on the characters
+  // around its runs. Measured on 71fedaa, each from a toolbar gesture:
+  //   `*`c`**i**tal*`                -> the em is lost, its stars show
+  //   `*~~a**a**~~*`                 -> `~~` is invisible to that scan
+  //   `前面「引號<!-- -->*」**粗**後面，中文*。`
+  // while `*a**i**tal*` and `***ital* bold**` read fine. The rules are
+  // marked's, so marked decides: serializeInline() writes the bytes as
+  // before, parses them, and compares the marks on every character with the
+  // DOM it was given. Only when they differ does it try other spellings for
+  // the nested marks, in this order, keeping the first that reads back:
+  //   1. `__` / `_` for every STRONG / EM inside another (those runs are
+  //      not `*`, so the outer scan does not count them);
+  //   2. the same with `<!-- -->` on both sides of each such mark (a run
+  //      next to `<` is no longer flanked by a word character), then each of
+  //      those guards dropped again if the bytes still read back without it.
+  // If neither reads back the original bytes are kept: what this release
+  // wrote before. Bytes that already read back are never touched, so no
+  // file written by an earlier release changes by being opened and saved.
+  // A fuzz over random strong / em / del / code trees (inline-md.test.js;
+  // 7725 of 20000 read back wrong on 71fedaa) needed nothing beyond step 2.
+  //
+  // A repaired spelling never keeps `<!--` at the start of a line: marked
+  // reads a line-start `<!--` as an HTML block and ends the paragraph there
+  // (v3.17.5 C1), and parseInline() cannot see that. It does not have to:
+  // the only guards step 2 adds sit before an opening run or after a
+  // closing one, and after a newline the character before an opening run
+  // is whitespace, which already does what the guard's `>` does (no
+  // right-flanking, opening allowed). So a step-2 guard at a line start is
+  // dropped before anything is parsed, whether or not the drop pass below
+  // runs (re-review: with the pass skipped past 16 guards, one survived
+  // after a hard break and the reader cut the paragraph there). The walk
+  // itself never writes one (needsFlankSeparator() sees `\n` as a non-word
+  // character).
+  //
+  // The parser is a private `new Marked()` with gfm on and nothing else, in
+  // node and in the editor page alike (server.js injects marked's UMD build
+  // before this file). The reader's own instance carries the md2doc
+  // renderer, whose text hook writes into the render's search index, and
+  // its sub / sup / KaTeX extensions only see `~` / `^` / `$`, which this
+  // comparison is not about. No parser (a page without marked) means no
+  // check: the bytes are written as before.
+  const GUARD = '<!-- -->';
+  const STAR = { STRONG: '**', EM: '*' };
+  const UNDERSCORE = { STRONG: '__', EM: '_' };
+  // PLAIN.inner is PLAIN: the spelling every release before this one used.
+  const PLAIN = { delims: STAR, before: '', after: '', inner: null };
+  PLAIN.inner = PLAIN;
+  function spelling(before) {
+    const nested = { delims: UNDERSCORE, before, after: before, inner: null };
+    nested.inner = nested;
+    return { delims: STAR, before: '', after: '', inner: nested };
+  }
+  const NESTED_UNDERSCORE = spelling('');
+  // One character stands in for each step-2 guard until it is decided, so
+  // only those guards are ever dropped, never one the walk wrote itself. It
+  // must be punctuation to needsFlankSeparator(), as the `<` it stands for
+  // is: with a word-like stand-in the walk skips a guard the real bytes need
+  // (measured: `ital**<!-- -->_…` lost the `<!-- -->` before its `**`).
+  // U+2E3B THREE-EM DASH (\p{Pd}); a block whose text holds one skips step 2.
+  const PENDING = '\u2E3B';
+  const NESTED_GUARDED = spelling(PENDING);
+
+  let inlineParser; // undefined: not looked up yet; null: none available
+  function getInlineParser() {
+    if (inlineParser !== undefined) return inlineParser;
+    inlineParser = 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 });
+        inlineParser = (s) => m.parseInline(s);
+      }
+    } catch (e) {
+      inlineParser = null;
+    }
+    return inlineParser;
+  }
+  // Tests swap the parser: a function, null to switch the check off, or
+  // nothing to go back to the lookup above.
+  function setInlineParser(fn) {
+    inlineParser = typeof fn === 'function' ? fn : (fn === null ? null : undefined);
+  }
+
+  // One entry per non-space character: the character and the sorted set of
+  // S(trong) / E(m) / D(el) around it. A code span is one entry holding its
+  // text without whitespace (a reader strips one space at each end, and
+  // spacing is not what this check is about). Whitespace is left out
+  // (splitEdges() moves it across a delimiter on purpose), and so are line
+  // breaks, link targets and <u>. A citation is written `[[body]]`, which
+  // this private parser (no md2doc extension) reads as that literal text,
+  // so its DOM side counts the outer brackets too: without them the two
+  // sides never agreed and any block holding a citation was never repaired
+  // (final review).
+  const MARK_LETTER = { STRONG: 'S', B: 'S', EM: 'E', I: 'E', DEL: 'D', S: 'D' };
+  const SPACE = /\s/;
+  function domMarks(nodes, marks, out) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.nodeType === 3) {
+        for (const ch of node.textContent) if (!SPACE.test(ch)) out.push(ch + '[' + marks + ']');
+        continue;
+      }
+      if (node.nodeType !== 1) continue;
+      if (node.nodeName === 'CODE') { out.push('`' + node.textContent.replace(/\s+/g, '') + '[' + marks + ']'); continue; }
+      if (node.nodeName === 'A' && isCitationNode(node)) {
+        for (const ch of '[' + node.textContent + ']') if (!SPACE.test(ch)) out.push(ch + '[' + marks + ']');
+        continue;
+      }
+      const k = MARK_LETTER[node.nodeName];
+      const inner = k && marks.indexOf(k) === -1 ? (marks + k).split('').sort().join('') : marks;
+      domMarks(node.childNodes, inner, out);
+    }
+    return out;
+  }
+  const HTML_TAG_MARK = { strong: 'S', em: 'E', del: 'D' };
+  const HTML_ENTITY = { amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" };
+  function htmlMarks(html) {
+    const out = [];
+    const open = [];
+    let code = null;
+    const re = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][a-zA-Z0-9]*)\b[^>]*>|&(amp|lt|gt|quot|#39);|([^<&]+|[<&])/g;
+    const current = () => open.slice().sort().filter((k, i, a) => a.indexOf(k) === i).join('');
+    let m;
+    while ((m = re.exec(html))) {
+      if (m[0].startsWith('<!--')) continue;
+      if (m[2]) {
+        const tag = m[2].toLowerCase();
+        if (tag === 'code') {
+          if (m[1]) { out.push('`' + (code || '').replace(/\s+/g, '') + '[' + current() + ']'); code = null; } else code = '';
+          continue;
+        }
+        const k = HTML_TAG_MARK[tag];
+        if (!k) continue;
+        if (m[1]) { const at = open.lastIndexOf(k); if (at !== -1) open.splice(at, 1); } else open.push(k);
+        continue;
+      }
+      const t = m[3] ? HTML_ENTITY[m[3]] : m[4];
+      if (code !== null) { code += t; continue; }
+      for (const ch of t) if (!SPACE.test(ch)) out.push(ch + '[' + current() + ']');
+    }
+    return out;
+  }
+
   // `opts` is optional; its one field, `codePipe`, is described at
   // serializeCode(). Every caller but table-md.js passes nothing.
   function serializeInline(rootEl, opts) {
     const unsupported = [];
     const md = walkChildren(rootEl.childNodes, unsupported, opts).md;
+    // The spellings below only differ where a STRONG / EM sits inside another
+    // one, so a block without that is written as walked, unparsed: no cost
+    // on the per-keystroke shortcut check or for callers that only want
+    // `unsupported`.
+    if (unsupported.length || !hasNestedStar(rootEl.childNodes, false)) return { md, unsupported };
+    const parse = getInlineParser();
+    if (!parse) return { md, unsupported };
+    const want = domMarks(rootEl.childNodes, '', []).join('|');
+    // table-md.js writes a code `|` as its placeholder; the cell shows `|`
+    // (GFM drops the `\` of `\|` before the cell is parsed inline).
+    const pipe = opts && opts.codePipe;
+    const readsBack = (s) => {
+      try {
+        return htmlMarks(parse(pipe ? s.split(pipe).join('|') : s)).join('|') === want;
+      } catch (e) {
+        return false;
+      }
+    };
+    if (readsBack(md)) return { md, unsupported };
+    const one = walkChildren(rootEl.childNodes, [], opts, NESTED_UNDERSCORE).md;
+    if (readsBack(one)) return { md: one, unsupported };
+    if (domText(rootEl.childNodes).indexOf(PENDING) === -1) {
+      const parts = walkChildren(rootEl.childNodes, [], opts, NESTED_GUARDED).md.split(PENDING);
+      // guard k sits right after parts[k]; none is kept at a line start
+      let before = '';
+      const keep = parts.slice(1).map((_, k) => {
+        before += parts[k];
+        return !/(^|\n)[ \t]*$/.test(before);
+      });
+      const build = () => parts.reduce((acc, part, i) =>
+        (i ? acc + (keep[i - 1] ? GUARD : '') : '') + part, '');
+      if (readsBack(build())) {
+        // Each drop is one more parse of the whole block. Past a handful of
+        // guards keep them all: correct bytes, a few extra `<!-- -->`
+        // (final review measured 400 repaired marks at 3.4 s otherwise).
+        for (let i = 0; i < keep.length && keep.length <= MAX_GUARDS_TO_DROP; i++) {
+          if (!keep[i]) continue;
+          keep[i] = false;
+          if (!readsBack(build())) keep[i] = true;
+        }
+        return { md: build(), unsupported };
+      }
+    }
     return { md, unsupported };
   }
+  const MAX_GUARDS_TO_DROP = 16;
+  const STAR_TAGS = { STRONG: 1, B: 1, EM: 1, I: 1 };
+  // Whether a STRONG / EM sits inside another one, through any wrapper the
+  // walk spells with the context it was given (not CODE, not a link label).
+  function hasNestedStar(nodes, inStar) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.nodeType !== 1 || node.nodeName === 'CODE' || node.nodeName === 'A') continue;
+      const star = STAR_TAGS[node.nodeName] === 1;
+      if (star && inStar) return true;
+      if (hasNestedStar(node.childNodes, inStar || star)) return true;
+    }
+    return false;
+  }
+  function domText(nodes) {
+    let s = '';
+    for (let i = 0; i < nodes.length; i++) s += nodes[i].textContent || '';
+    return s;
+  }
 
   function canWysiwyg(rootEl) {
     return serializeInline(rootEl).unsupported.length === 0;
@@ -706,5 +951,5 @@
     return out;
   }
 
-  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder, setInlineParser };
 });

package/lib/editor/paste-md.js

@@ -215,8 +215,47 @@ function isHeadingRow(tr) {
 // against the header. Escape any `|` that isn't already an escaped `\|`
 // (the latter can arrive when a nested table's own already-escaped cell
 // content is flattened into its parent cell, see cellMarkdown below).
+//
+// v3.17.7 F2: "already escaped" means an ODD run of backslashes before the
+// `|`, which is how marked's splitCells() decides it (the parity rule
+// v3.17.6 wrote down in table-md.js). The old test was one backslash, any
+// run: text `a \| b` (turndown writes its backslash as `\\`) came out
+// `a \\| b`, an even run, and the cell was cut in two (measured on 71fedaa).
 function escapePipes(s) {
-  return String(s).replace(/(?<!\\)\|/g, '\\|');
+  return String(s).replace(/(\\*)\|/g, function (m, run) {
+    return run.length % 2 ? m : run + '\\|';
+  });
+}
+
+// v3.17.7 F2: code whose text has an odd backslash run before a `|` has no
+// spelling in a GFM table cell. The backslash that keeps the pipe in the
+// cell is the one GFM deletes before the code span is read, so the code
+// shows one backslash fewer (or, with one backslash more, the run turns even
+// and the pipe ends the cell); table-md.js refuses the same code (v3.17.6).
+// Paste cannot refuse, so such a span is written as text with EVERY ASCII
+// punctuation character backslash-escaped (CommonMark allows that for all
+// of them): then nothing in it is read as markup -- not `<!--`, not an
+// entity, not md2doc's `^sup^` / `~sub~` / `$math$`. turndown's own
+// escape() leaves those alone (final review: `a<!-- \| -->` lost its text,
+// `^2^` became superscript). The `|` comes out `\|`, an odd run, which
+// escapePipes() then leaves as it is. Every character arrives; only the
+// code style does not.
+var ODD_BACKSLASH_PIPE = /(?:^|[^\\])(?:\\\\)*\\\|/;
+function addUnspellableCellCodeRule(service) {
+  service.addRule('unspellableCellCode', {
+    filter: function (node) {
+      if (node.nodeName !== 'CODE') return false;
+      if (node.parentNode && node.parentNode.nodeName === 'PRE') return false;
+      if (!ODD_BACKSLASH_PIPE.test(node.textContent || '')) return false;
+      for (var p = node.parentNode; p; p = p.parentNode) {
+        if (p.nodeName === 'TD' || p.nodeName === 'TH') return true;
+      }
+      return false;
+    },
+    replacement: function (content, node) {
+      return (node.textContent || '').replace(/[!-\/:-@\[-`{-~]/g, '\\$&');
+    }
+  });
 }
 
 // Only the ROWS THIS TABLE OWNS -- direct <tr> children, and <tr> children
@@ -342,9 +381,24 @@ 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);
+  addUnspellableCellCodeRule(service);
   return service.turndown(html == null ? '' : String(html));
 }
 

package/lib/editor/server.js

@@ -8,6 +8,12 @@ const { renderMarkdown, buildKatexStyleTag, diagramEnginePaths } = require('../m
 const { createDotPreview } = require('./dot-preview.js');
 
 const LINEOPS_SRC = fs.readFileSync(path.join(__dirname, 'lineops.js'), 'utf8');
+// v3.17.7: marked's browser build (the package's exported `marked.min.js`,
+// UMD, defines the global `marked`), so inline-md.js can parse the bytes it
+// is about to save and check that the reader shows the marks the editor held
+// (serializeInline()). Injected before inline-md.js; inline-md.js looks the
+// global up at its first serialize, so the order is for reading, not load.
+const MARKED_SRC = fs.readFileSync(require.resolve('marked/marked.min.js'), 'utf8');
 const INLINE_MD_SRC = fs.readFileSync(path.join(__dirname, 'inline-md.js'), 'utf8');
 const TABLE_MD_SRC = fs.readFileSync(path.join(__dirname, 'table-md.js'), 'utf8');
 // Task 4 (Phase 3): list-md.js's browser factory reads `root.md2docInlineMd`
@@ -776,6 +782,7 @@ async function createEditorServer({
         const inject =
           `<script>window.__ED__ = ${payload.replace(/</g, '\\u003c')}</script>\n` +
           `<script>${LINEOPS_SRC}</script>\n` +
+          `<script>${MARKED_SRC}</script>\n` +
           `<script>${INLINE_MD_SRC}</script>\n` +
           `<script>${TABLE_MD_SRC}</script>\n` +
           `<script>${LIST_MD_SRC}</script>\n` +

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.6",
+  "version": "3.17.8",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, Graphviz, and draw.io support",
   "keywords": [
     "markdown",