@helping-ai-workflow/md2doc 3.17.6 → 3.17.7

package/lib/editor/inline-md.js

@@ -154,6 +154,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 +398,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 +422,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 +432,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 +442,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 +451,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 +471,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 +494,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 +559,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 +943,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
@@ -345,6 +384,7 @@ function htmlToMarkdown(html) {
   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/package.json

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