@helping-ai-workflow/md2doc 3.17.4 → 3.17.6

package/lib/editor/inline-md.js

@@ -126,13 +126,19 @@
   // (verified round-trip-identical either way), so we always pad once a
   // fence is needed — simpler, and preserves the original single-backtick
   // test's exact padded form.
-  function serializeCode(node) {
+  //
+  // `opts.codePipe` (v3.17.6, table cells only): what a '|' in the code text
+  // is written as. table-md.js passes a placeholder here and turns it into
+  // `\|` after its own whole-cell '|' pass, which must not see it. The
+  // fence is measured on the real text; the placeholder holds no backtick.
+  function serializeCode(node, opts) {
     const raw = node.textContent;
     const runs = raw.match(/`+/g);
     const longestRun = runs ? Math.max.apply(null, runs.map((r) => r.length)) : 0;
-    if (longestRun === 0) return '`' + raw + '`';
+    const body = opts && opts.codePipe !== undefined ? raw.split('|').join(opts.codePipe) : raw;
+    if (longestRun === 0) return '`' + body + '`';
     const fence = new Array(longestRun + 2).join('`');
-    return fence + ' ' + raw + ' ' + fence;
+    return fence + ' ' + body + ' ' + fence;
   }
 
   // IMPORTANT 3 (degrade-never-lose): the citation form only round-trips
@@ -148,7 +154,7 @@
     return inner.indexOf(']') === -1;
   }
 
-  function serializeAnchor(node, unsupported) {
+  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
     // markdown link: emitting '[label]()' for it erased the anchor on the
@@ -167,10 +173,14 @@
       unsupported.push('A');
       return '';
     }
-    const label = walkChildren(node.childNodes, unsupported).md;
+    const label = walkChildren(node.childNodes, unsupported, opts).md;
     return '[' + label + '](' + (href || '') + ')';
   }
 
+  // (What a mark's own edges must look like -- whitespace and punctuation
+  // just inside its delimiters -- is a separate rule, v3.17.5, written above
+  // `splitEdges` / `appendPiece` further down.)
+  //
   // v3.4.0 / backlog 3 (Ruling T6-7, then a fix-round regression): STRONG
   // and EM each emit a fixed, context-blind '*'-based delimiter for their
   // own tag — '**'/'**' or '*'/'*' — with no awareness of what the
@@ -267,11 +277,121 @@
   // STRONG, DEL/S, U, the citation label) only ever needs `.md`, because
   // its own outer delimiter is a fixed, known tag regardless of what's
   // nested inside.
+  // v3.17.5 M1 + R1: a delimiter run only counts when CommonMark's flanking
+  // rule accepts it, and STRONG / EM / DEL used to wrap their content blind.
+  // Measured on 4d7669f, all three rendered literal asterisks in the reader:
+  //   Delete down to a leading space     `alpha ** charlie** delta`
+  //   Ctrl+B on 「引號」                  `前面**「引號」**後面`
+  //   Ctrl+B on `charlie ` (with space)  `alpha **charlie **delta`
+  // The rule, in marked 14's own classes (whitespace = JS `\s`, punctuation =
+  // `\p{P}\p{S}`): the character just INSIDE a run may not be whitespace, and
+  // when it is punctuation the character just OUTSIDE must be whitespace,
+  // punctuation or the edge of the text.
+  //
+  // Two fixes, one per half of the rule:
+  //   * whitespace inside -> moved outside (`splitEdges`), byte for byte, so
+  //     ` charlie` in bold becomes ` **charlie**`; a mark holding nothing
+  //     else is no mark at all. A hard break (`\` + newline) at an edge
+  //     moves out whole: peeling only its newline would leave the backslash
+  //     escaping the delimiter.
+  //   * punctuation inside, a word character outside -> `<!-- -->` between
+  //     them (`appendPiece`). The comment is the same inert separator the
+  //     same-tag guard above uses; marked masks an HTML tag as punctuation,
+  //     so the run then has punctuation on both sides, which the rule allows.
+  //     Only `*` runs need it: marked's `~~` is not punctuation-flanking
+  //     (`~~中文。~~後面` parses), and `_` is never emitted.
+  // The punctuation check runs where two pieces are joined, on the bytes
+  // themselves, because the character outside a run may belong to a sibling,
+  // or to a parent's sibling when the run starts or ends a bare SPAN: every
+  // level joins its own pieces, so a run at the edge of a nested call is
+  // checked again by its parent. A run's inside is found by skipping its bare
+  // `*`s: escapeText() escapes every literal `*`, so a `*` at either end of a
+  // piece is a delimiter unless an odd run of backslashes precedes it.
+  const FLANK_WS = /\s/;
+  const FLANK_PUNCT = /[\p{P}\p{S}]/u;
+  function isWordish(ch) {
+    return ch !== undefined && !FLANK_WS.test(ch) && !FLANK_PUNCT.test(ch);
+  }
+  function lastCodePoint(s, end) {
+    if (end <= 0) return undefined;
+    const lo = s.charCodeAt(end - 1);
+    if (lo >= 0xdc00 && lo <= 0xdfff && end >= 2) {
+      const hi = s.charCodeAt(end - 2);
+      if (hi >= 0xd800 && hi <= 0xdbff) return s.slice(end - 2, end);
+    }
+    return s[end - 1];
+  }
+  function firstCodePoint(s, start) {
+    if (start >= s.length) return undefined;
+    return String.fromCodePoint(s.codePointAt(start));
+  }
+  // The character just inside a leading `*` run, or undefined when `s` does
+  // not open with one.
+  function openingRunInside(s) {
+    let i = 0;
+    while (s[i] === '*') i++;
+    return i ? firstCodePoint(s, i) : undefined;
+  }
+  // The character just inside a trailing `*` run, or undefined when `s` does
+  // not close with one.
+  function closingRunInside(s) {
+    let k = 0;
+    while (k < s.length && s[s.length - 1 - k] === '*') k++;
+    if (!k) return undefined;
+    let b = 0;
+    while (s[s.length - 1 - k - b] === '\\') b++;
+    if (b % 2) return k > 1 ? '*' : undefined; // the run's first `*` is an escaped literal
+    return lastCodePoint(s, s.length - k);
+  }
+  // Two v3.17.5 final-review findings shape the outside characters:
+  //   * I2 -- marked reads the character before an opening run as ONE UTF-16
+  //     unit (`token.raw.slice(-1)`), so an astral symbol there (📌, \p{So})
+  //     is a lone surrogate to it, i.e. a word character. Match that.
+  //   * I1 -- a closing run touching the next piece's opening run fuses with
+  //     it (`**注意：***斜體*`); the character after the fused run is the one
+  //     inside the right piece's run, not its `*`. The opening side needs no
+  //     such care: once the left run has closed, marked sees a `*`
+  //     (punctuation) before the rest, which the rule accepts.
+  function needsFlankSeparator(left, right) {
+    if (!left || !right) return false;
+    const open = openingRunInside(right);
+    if (open !== undefined && FLANK_PUNCT.test(open) && isWordish(left[left.length - 1])) return true;
+    const close = closingRunInside(left);
+    const after = right[0] === '*' ? openingRunInside(right) : firstCodePoint(right, 0);
+    return close !== undefined && FLANK_PUNCT.test(close) && isWordish(after);
+  }
+  function appendPiece(out, piece) {
+    return out + (needsFlankSeparator(out, piece) ? '<!-- -->' : '') + piece;
+  }
+  // `md` -> { lead, core, trail }: whitespace (and whole hard breaks) peeled
+  // off both ends of a mark's content.
+  function splitEdges(md) {
+    let start = 0;
+    let end = md.length;
+    for (;;) {
+      if (start < end && FLANK_WS.test(md[start])) { start++; continue; }
+      // a leading `\` is always a hard break's: a literal one is `\\`
+      if (md[start] === '\\' && md[start + 1] === '\n' && start + 2 <= end) { start += 2; continue; }
+      break;
+    }
+    for (;;) {
+      if (end > start && md[end - 1] === '\n') {
+        let b = 0;
+        while (end - 2 - b >= start && md[end - 2 - b] === '\\') b++;
+        end -= b % 2 ? 2 : 1;
+        continue;
+      }
+      if (end > start && FLANK_WS.test(md[end - 1])) { end--; continue; }
+      break;
+    }
+    return { lead: md.slice(0, start), core: md.slice(start, end), trail: md.slice(end) };
+  }
+
   function markIsSearchHit(node) {
     if (typeof node.getAttribute !== 'function') return false;
     return (' ' + (node.getAttribute('class') || '') + ' ').indexOf(' search-hit ') !== -1;
   }
-  function walkChildren(nodes, unsupported) {
+  function walkChildren(nodes, unsupported, opts) {
     let out = '';
     let firstSegment = true;
     let lastMarkTag = null;
@@ -279,7 +399,7 @@
       const node = nodes[i];
       if (node.nodeType === 3) {
         const text = escapeText(node.textContent);
-        out += text;
+        out = appendPiece(out, text);
         if (text.length) lastMarkTag = null;
         firstSegment = false;
         continue;
@@ -289,9 +409,9 @@
       if (name === 'DIV') {
         let added = '';
         if (!firstSegment) added += '<br>';
-        const inner = walkChildren(node.childNodes, unsupported);
+        const inner = walkChildren(node.childNodes, unsupported, opts);
         added += inner.md;
-        out += added;
+        out = appendPiece(out, added);
         if (added.length) lastMarkTag = inner.md.length ? inner.lastMarkTag : null;
         firstSegment = false;
         continue;
@@ -299,8 +419,8 @@
       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);
-        out += inner.md;
+        const inner = walkChildren(node.childNodes, unsupported, opts);
+        out = appendPiece(out, inner.md);
         if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         firstSegment = false;
         continue;
@@ -309,24 +429,26 @@
         if (spanHasAttributes(node)) {
           unsupported.push(name);
         } else {
-          const inner = walkChildren(node.childNodes, unsupported);
-          out += inner.md;
+          const inner = walkChildren(node.childNodes, unsupported, opts);
+          out = appendPiece(out, inner.md);
           if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         }
         firstSegment = false;
         continue;
       }
-      if (name === 'STRONG' || name === 'B') {
-        out += (lastMarkTag === 'STRONG' ? '<!-- -->' : '') +
-          '**' + walkChildren(node.childNodes, unsupported).md + '**';
-        lastMarkTag = 'STRONG';
-        firstSegment = false;
-        continue;
-      }
-      if (name === 'EM' || name === 'I') {
-        out += (lastMarkTag === 'EM' ? '<!-- -->' : '') +
-          '*' + walkChildren(node.childNodes, unsupported).md + '*';
-        lastMarkTag = 'EM';
+      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);
+        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);
+          lastMarkTag = e.trail ? null : tag;
+        } else if (e.lead || e.trail) {
+          out = appendPiece(out, e.lead + e.trail);
+          lastMarkTag = null;
+        }
         firstSegment = false;
         continue;
       }
@@ -336,8 +458,9 @@
         // accepted on input (some contenteditable/paste paths produce it)
         // but the toolbar/serializer always speak DEL, matching what marked
         // itself emits.
-        out += '~~' + walkChildren(node.childNodes, unsupported).md + '~~';
-        lastMarkTag = null;
+        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;
         firstSegment = false;
         continue;
       }
@@ -352,19 +475,19 @@
         // 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 += '<u>' + walkChildren(node.childNodes, unsupported).md + '</u>';
+        out = appendPiece(out, '<u>' + walkChildren(node.childNodes, unsupported, opts).md + '</u>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'CODE') {
-        out += serializeCode(node);
+        out = appendPiece(out, serializeCode(node, opts));
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'A') {
-        out += serializeAnchor(node, unsupported);
+        out = appendPiece(out, serializeAnchor(node, unsupported, opts));
         lastMarkTag = null;
         firstSegment = false;
         continue;
@@ -402,7 +525,7 @@
         // reach this code.
         const hardBreak = typeof node.getAttribute === 'function' &&
           node.getAttribute('data-hard-break') === '1';
-        out += hardBreak ? '\\\n' : '<br>';
+        out = appendPiece(out, hardBreak ? '\\\n' : '<br>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
@@ -413,9 +536,11 @@
     return { md: out, lastMarkTag };
   }
 
-  function serializeInline(rootEl) {
+  // `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).md;
+    const md = walkChildren(rootEl.childNodes, unsupported, opts).md;
     return { md, unsupported };
   }
 

package/lib/editor/paste-md.js

@@ -55,6 +55,140 @@ function addStrikethroughRule(service) {
   });
 }
 
+// --- bold / italic next to punctuation (v3.17.5 R2) -------------------------
+//
+// CommonMark only takes a `*` run whose inside character, when it is
+// punctuation (marked 14: \p{P}\p{S}), has whitespace, punctuation or the edge
+// of the text on its outside. turndown's own strong / emphasis rules wrap
+// blind, so a pasted `前面<b>「引號」</b>後面` became `前面**「引號」**後面` and
+// the reader showed the asterisks. These two rules replace them and put
+// `<!-- -->` (marked reads an HTML tag as punctuation) on a side that needs
+// it -- the same separator, for the same rule, as walkChildren() in
+// inline-md.js; the classes below are that file's FLANK_WS / FLANK_PUNCT.
+// Whitespace at the edges never reaches them: turndown moves it outside
+// first (`node.flankingWhitespace`), and a side that got some needs nothing.
+//
+// The outside character is read from the DOM, because the markdown around
+// this node does not exist yet: the nearest text before / after it within the
+// block, through bare inline wrappers. A neighbour that writes a delimiter or
+// a bracket of its own there (a parent <b>, <a>, <code>...) is punctuation; an
+// <img>, <br> or <hr> writes `)` or whitespace. Any other element with no text
+// (a Word bookmark `<a name>`, an empty <span>, `<o:p>`) writes nothing and is
+// looked past; the wrappers below write only their content (v3.17.5 final
+// review I3: <u>, <sup>, <ins>... were missing, and an empty neighbour stopped
+// the search).
+//
+// Before the run, the character is one UTF-16 unit, as marked reads it
+// (`token.raw.slice(-1)`): an astral symbol there (📌) is a lone surrogate to
+// it, a word character (final review I2).
+var FLANK_WS = /\s/;
+var FLANK_PUNCT = /[\p{P}\p{S}]/u;
+var TRANSPARENT_INLINE = /^(SPAN|FONT|MARK|SMALL|BIG|ABBR|CITE|DFN|Q|TIME|DATA|BDI|BDO|U|INS|SUB|SUP|KBD|SAMP|VAR|LABEL|O:P)$/;
+var WRITES_ITS_OWN = /^(IMG|BR|HR)$/;
+
+function isWordish(ch) {
+  return ch !== undefined && !FLANK_WS.test(ch) && !FLANK_PUNCT.test(ch);
+}
+
+function edgeChar(text, last) {
+  if (!text) return undefined;
+  return last ? text[text.length - 1] : Array.from(text)[0];
+}
+
+// Only an inline element's text is read as the neighbour. A block, or an
+// element not on these lists, is a line edge or unknown: the answer is
+// "not a word character", so no separator -- which can never put `<!--` at a
+// line start, where marked reads it as an HTML block that ends the paragraph
+// (re-review I1: `<div>前</div><b>「x」</b>`).
+var MARKUP_INLINE = /^(STRONG|B|EM|I|DEL|S|STRIKE|A|CODE)$/;
+
+// An element with no text writes nothing only when it is one of the inline
+// elements above and nothing inside it writes either. An <img>, <br> or <hr>
+// writes `)` or a line break (re-review C1: `<span><br></span>` was looked
+// past, and the separator landed at the start of a line); a block -- or an
+// element not on the lists -- writes a line edge even when empty (round 3,
+// I1': `<p></p>` is a blank line). A bold / italic with no text is dropped by
+// its own rule whatever it holds (`<b><br></b>`).
+function writesNothing(el) {
+  var name = el.nodeName;
+  if (/^(STRONG|B|EM|I)$/.test(name) && !el.textContent.trim()) return true;
+  if (!TRANSPARENT_INLINE.test(name) && !MARKUP_INLINE.test(name)) return false;
+  for (var c = el.firstChild; c; c = c.nextSibling) {
+    if (c.nodeType === 1 && !writesNothing(c)) return false;
+  }
+  return true;
+}
+
+// The character a neighbour writes at the edge facing the run: its last (or
+// first) descendant that writes anything. A <br> / <img> / <hr> there, or a
+// block or unknown element on the way, answers undefined -- so
+// `<span>前<br></span>` is a line edge, not 前.
+function edgeOf(node, last) {
+  if (node.nodeType === 3) return node.textContent ? edgeChar(node.textContent, last) : undefined;
+  if (node.nodeType !== 1) return undefined;
+  if (!TRANSPARENT_INLINE.test(node.nodeName) && !MARKUP_INLINE.test(node.nodeName)) return undefined;
+  for (var c = last ? node.lastChild : node.firstChild; c; c = last ? c.previousSibling : c.nextSibling) {
+    if (c.nodeType === 3 && !c.textContent) continue;
+    if (c.nodeType === 1 && !c.textContent && writesNothing(c)) continue;
+    if (c.nodeType !== 1 && c.nodeType !== 3) continue;
+    return edgeOf(c, last);
+  }
+  return undefined;
+}
+
+function outsideChar(node, dir) {
+  for (var n = node; n; n = n.parentNode) {
+    var sib = n[dir];
+    while (sib && (sib.nodeType === 1 ? !sib.textContent && writesNothing(sib)
+      : sib.nodeType !== 3 || !sib.textContent)) sib = sib[dir];
+    if (sib) return edgeOf(sib, dir === 'previousSibling');
+    var parent = n.parentNode;
+    if (!parent || parent.nodeType !== 1 || !TRANSPARENT_INLINE.test(parent.nodeName)) return undefined;
+  }
+  return undefined;
+}
+
+function insideChar(md, last) {
+  var chars = Array.from(md);
+  if (last) {
+    var i = chars.length - 1;
+    while (i >= 0 && chars[i] === '*') i -= 1;
+    return chars[i];
+  }
+  var j = 0;
+  while (j < chars.length && chars[j] === '*') j += 1;
+  return chars[j];
+}
+
+function flankedReplacement(delimiterOf) {
+  return function (content, node, options) {
+    if (!content.trim()) return '';
+    // turndown moves the text's own edge whitespace outside, but not a <br>'s
+    // `  \n` at an edge (final review): peel that too
+    var lead = /^\s*/.exec(content)[0];
+    var trail = /\s*$/.exec(content)[0];
+    var delim = delimiterOf(options);
+    var md = delim + content.slice(lead.length, content.length - trail.length) + delim;
+    var ws = node.flankingWhitespace || { leading: '', trailing: '' };
+    var before = !lead && !ws.leading && FLANK_PUNCT.test(insideChar(md, false) || '') &&
+      isWordish(outsideChar(node, 'previousSibling'));
+    var after = !trail && !ws.trailing && FLANK_PUNCT.test(insideChar(md, true) || '') &&
+      isWordish(outsideChar(node, 'nextSibling'));
+    return lead + (before ? '<!-- -->' : '') + md + (after ? '<!-- -->' : '') + trail;
+  };
+}
+
+function addFlankingEmphasisRules(service) {
+  service.addRule('strongFlanking', {
+    filter: ['strong', 'b'],
+    replacement: flankedReplacement(function (o) { return o.strongDelimiter; })
+  });
+  service.addRule('emphasisFlanking', {
+    filter: ['em', 'i'],
+    replacement: flankedReplacement(function (o) { return o.emDelimiter; })
+  });
+}
+
 function isFirstTbody(el) {
   var prev = el.previousSibling;
   return (
@@ -209,6 +343,7 @@ function htmlToMarkdown(html) {
     emDelimiter: '*'
   });
   addStrikethroughRule(service);
+  addFlankingEmphasisRules(service);
   addTableRules(service);
   return service.turndown(html == null ? '' : String(html));
 }

package/lib/editor/table-md.js

@@ -70,8 +70,8 @@
   // 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
-  // has no faithful gate-safe emission — see cellHasCodePipe() below —
-  // and reports 'CODE' unsupported instead of corrupting it.
+  // is written as '\|' instead (v3.17.6) — see codePipesOf() below; the one
+  // code text that has no table spelling reports 'CODE' unsupported.
   //
   // Constrained (same as inline-md.js, and for the same reason: the node
   // test drives this with the hand-rolled element stub from
@@ -123,32 +123,63 @@
     return s.replace(/\r\n|\r|\n/g, '<br>');
   }
 
-  // Finding 4: a '|' inside a <code> span has no faithful gate-safe
-  // emission — escapePipes() above runs on the WHOLE cell's serialized md
-  // and can't tell a code span's content from plain text, so naively
-  // applying it would corrupt the code span (turning `` `a|b` `` into the
-  // broken `` `a&#124;b` ``, which never decodes back inside a code span).
-  // `\|` (some other renderers' escape) is the gate's documented trap, so
-  // there's no safe escape at all here — degrade-never-lose: detect a CODE
-  // element anywhere in the cell whose textContent contains '|' and report
-  // it unsupported instead, same signal an IMG/SPAN/etc. already uses to
-  // degrade the whole table to raw-edit (see canWysiwygForTable() in
-  // client.js). Recurses through the cell's element children looking for
-  // CODE — constrained to childNodes/nodeType/nodeName like the rest of
-  // this file (no querySelector, per the node-test stub).
-  function cellHasCodePipe(node) {
+  // A '|' inside a <code> span (v3.17.6; Finding 4 of 2026-08-25 refused
+  // every one). escapePipes() above cannot be used on it: '&#124;' is never
+  // decoded inside a code span, so `` `a|b` `` would come back as `a&#124;b`.
+  // GFM's own spelling is '\|': the table tokenizer drops that backslash when
+  // it splits the row into cells, before the cell is parsed inline, so the
+  // code span shows a bare '|'. It is also what paperwork asks for. Its
+  // quality gate (G-MD-TABLE-PIPE,
+  // `scan_table_rows_for_unescaped_pipe_in_backtick` in scripts/gate/shared.py,
+  // 10.4.0) hard-FAILs an unescaped pipe inside a backtick span of a table
+  // row and gives '\|' as the fix. The paperwork-workspace-rtk design-docs
+  // are written that way, and those tables used to fall back to raw-edit.
+  //
+  // Correction, recorded because the old comment here said otherwise: it
+  // called '\|' "the gate's documented trap". Nothing in paperwork 10.4.0
+  // backs that. The only trap note about an escaped pipe there is a docstring
+  // in scripts/gate/hwe1.py (`_hwe1_requirement_units`): that helper splits
+  // hwe1 requirement rows with a plain split("|"), so it would cut such a
+  // cell in two, and the docstring itself says no gate reads that cell text
+  // today. It is a hazard for whoever extends that helper. It is not a rule
+  // against the form, and design-doc gates do not use that helper.
+  //
+  // One code text still has no spelling. marked's splitCells() treats a pipe
+  // as escaped when an ODD run of backslashes precedes it, then deletes one
+  // backslash. Code text with an even run before its '|' (none, two, …) is
+  // written with one more backslash and reads back exactly. With an odd run,
+  // that extra backslash makes the run even and the pipe becomes a cell
+  // boundary. That case reports 'CODE' unsupported, and the whole table falls
+  // back to raw-edit as before (canWysiwygForTable() in client.js).
+  //
+  // Returns { pipes, unwritable } over every CODE element in the cell. It
+  // recurses through elements that are not CODE and does not descend into
+  // CODE, because serializeCode() writes a CODE element's textContent whole.
+  // It sticks to childNodes/nodeType/nodeName like the rest of this file (no
+  // querySelector, per the node-test stub).
+  const ODD_BACKSLASH_PIPE = /(?:^|[^\\])(?:\\\\)*\\\|/;
+  function codePipesOf(node, acc) {
+    const out = acc || { pipes: 0, unwritable: false };
     const kids = elementChildren(node);
     for (let i = 0; i < kids.length; i++) {
       const k = kids[i];
       if (k.nodeName === 'CODE') {
-        if (k.textContent.indexOf('|') !== -1) return true;
-      } else if (cellHasCodePipe(k)) {
-        return true;
+        const t = k.textContent;
+        out.pipes += t.split('|').length - 1;
+        if (ODD_BACKSLASH_PIPE.test(t)) out.unwritable = true;
+      } else {
+        codePipesOf(k, out);
       }
     }
-    return false;
+    return out;
   }
 
+  // The placeholder serializeCode() writes for a code '|' while the cell's
+  // markdown goes through escapePipes(). A private-use character, so real
+  // text almost never holds it. If one does, the count check in
+  // cellContentOf() catches it and the cell degrades rather than guessing.
+  const CODE_PIPE_MARK = '\uE000';
+
   // ── v3.0.1 欄寬保留 ────────────────────────────────────────────────────
   // A cell FIELD is the text between two '|' delimiters, PADDING INCLUDED:
   // in '| a   | b |' the fields are ' a   ' and ' b '. A column only counts
@@ -159,8 +190,8 @@
   // width of 3 is indistinguishable from this serializer's own minimal
   // form, which is exactly 3 on every row by construction).
   //
-  // A raw '|' never appears inside a cell in source THIS serializer produced
-  // (it emits '&#124;'), but a hand-written table may use the '\|' escape, so
+  // 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.
   function splitFields(line) {
     const t = line.trim();
@@ -312,10 +343,12 @@
   // `unsupported` for the same cell), so width measurement and emission
   // below both read from these same strings.
   function cellContentOf(cell, unsupported) {
-    if (cellHasCodePipe(cell)) unsupported.push('CODE');
-    const res = inlineMd.serializeInline(cell);
+    const code = codePipesOf(cell);
+    const res = inlineMd.serializeInline(cell, { codePipe: CODE_PIPE_MARK });
     res.unsupported.forEach((u) => unsupported.push(u));
-    return escapeNewlines(escapePipes(res.md));
+    const parts = escapeNewlines(escapePipes(res.md)).split(CODE_PIPE_MARK);
+    if (code.unwritable || parts.length - 1 !== code.pipes) unsupported.push('CODE');
+    return parts.join('\\|');
   }
 
   function serializeRow(contents, widths) {

package/package.json

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