@helping-ai-workflow/md2doc 3.17.4 → 3.17.5

package/lib/editor/inline-md.js

@@ -171,6 +171,10 @@
     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,6 +271,116 @@
   // 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;
@@ -279,7 +393,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;
@@ -291,7 +405,7 @@
         if (!firstSegment) added += '<br>';
         const inner = walkChildren(node.childNodes, unsupported);
         added += inner.md;
-        out += added;
+        out = appendPiece(out, added);
         if (added.length) lastMarkTag = inner.md.length ? inner.lastMarkTag : null;
         firstSegment = false;
         continue;
@@ -300,7 +414,7 @@
         // 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;
+        out = appendPiece(out, inner.md);
         if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         firstSegment = false;
         continue;
@@ -310,23 +424,25 @@
           unsupported.push(name);
         } else {
           const inner = walkChildren(node.childNodes, unsupported);
-          out += inner.md;
+          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).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 +452,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).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 +469,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).md + '</u>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'CODE') {
-        out += serializeCode(node);
+        out = appendPiece(out, serializeCode(node));
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'A') {
-        out += serializeAnchor(node, unsupported);
+        out = appendPiece(out, serializeAnchor(node, unsupported));
         lastMarkTag = null;
         firstSegment = false;
         continue;
@@ -402,7 +519,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;

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/package.json

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