@helping-ai-workflow/md2doc 3.17.3 → 3.17.5

package/lib/editor/client.js

@@ -123,8 +123,20 @@
   // caller has the definitions appended. A missing flag costs a second copy,
   // a wrong one the definition, so the flag is only for text that is built
   // by slicing `lines` across every gap of the range.
-  function keepDefinitionLines(state, startLine, endLine, after) {
-    const groups = definitionLinesIn(state, startLine, endLine);
+  //
+  // v3.17.4 D5 (R8): a gesture that replays SOME of its gaps verbatim (a span
+  // move keeps the lines between two blocks that stay neighbours, and drops
+  // the others) cannot say carriesGap for the whole range. It names the source
+  // line numbers it copied instead, `replayedLines` (a Set), and a group whose
+  // every line is in it is skipped; every other group is appended as above.
+  // Still the gesture's own fact, per group instead of all-or-nothing: the
+  // text is never read, so a copy inside a fence is still code. Same costs —
+  // a line named that was not copied loses its definition — so a line goes in
+  // the set only where the caller slices it from `lines` (census row in
+  // test/editor-client.test.js).
+  function keepDefinitionLines(state, startLine, endLine, after, replayedLines) {
+    const groups = definitionLinesIn(state, startLine, endLine)
+      .filter((g) => !(replayedLines && g.at.every((n) => replayedLines.has(n))));
     if (!groups.length) return after;
     if (collapseBlankRuns(after).join('\n') === withoutDefinitionLines(state, startLine, endLine, groups).join('\n')) return null;
     let tail = after.length;
@@ -152,12 +164,15 @@
   // definition the user deleted or changed there is not kept as well.
   // Fix round 3 (R56): `opts.carriesGap` is structural text that already
   // holds every line between the range's blocks verbatim (keepDefinitionLines()).
+  // v3.17.4 D5 (R8): `opts.replayedLines` names the source lines it holds
+  // verbatim when only some gaps are replayed (keepDefinitionLines()).
   function commitRangeEdit(state, startLine, endLine, newText, opts) {
     const refusal = refuseInvertedRange(state, 'commitRangeEdit', startLine, endLine);
     if (refusal) return refusal;
     const before = state.lines.slice(startLine - 1, endLine);
     const typed = newText.split('\n');
-    const after = opts && (opts.verbatim || opts.carriesGap) ? typed : keepDefinitionLines(state, startLine, endLine, typed);
+    const after = opts && (opts.verbatim || opts.carriesGap) ? typed
+      : keepDefinitionLines(state, startLine, endLine, typed, opts && opts.replayedLines);
     if (after === null || before.join('\n') === after.join('\n')) {
       return { lines: state.lines, blocks: state.blocks, op: null };
     }
@@ -1054,6 +1069,21 @@
   // ── DOM wiring (browser only) ─────────────────────────────────────────
   const ED = window.__ED__;
   const inlineMd = window.md2docInlineMd;
+  // The alt field decodes every named character reference the way the reader's
+  // browser does. The reader's alt is an ATTRIBUTE, where a legacy name followed
+  // by more letters (&notit;, &copyx;) stays literal; a textarea (text context)
+  // would give the prefix's character (¬it;), so the probe parses an img alt
+  // inside an inert template. Not a div: Chromium's innerHTML fast path decodes
+  // an attribute there as text (measured, final review I5).
+  {
+    const refProbe = document.createElement('template');
+    inlineMd.setNamedReferenceDecoder((name) => {
+      refProbe.innerHTML = '<img alt="&' + name + ';">';
+      const img = refProbe.content.firstChild;
+      const v = img && img.getAttribute('alt');
+      return typeof v !== 'string' || v === '&' + name + ';' ? undefined : v;
+    });
+  }
   const tableMd = window.md2docTableMd;
   const listMd = window.md2docListMd;
   const indentClamp = window.md2docIndentClamp;
@@ -1576,7 +1606,10 @@
   // beforeunload handler, and the toolbar's state is declared far below.
   function imgTbHasPendingAlt() {
     try {
-      return !!imgTbAlt && !imgTbInput.hidden && imgTbInput.value !== imgTbAlt.original;
+      if (imgTbAlt) return !imgTbInput.hidden && imgTbInput.value !== imgTbAlt.original;
+      // R12: a kept draft is unsaved work while its image is still in the
+      // document (a draft whose source is gone stops counting).
+      return !!imgTbAltDraft && blocks.some((b) => blockSourceOf(b) === imgTbAltDraft.source);
     } catch (e) { return false; }
   }
   // Guarded the same way, for the same reason (the beforeunload handler).
@@ -11181,6 +11214,31 @@
     }
   }
 
+  // v3.17.4 D3 (R7): a block converted to text, a list kind or a quote is
+  // written over its own lines only, so a non-blank line directly above or
+  // below it (a link reference definition, a paragraph) would be read as a lazy
+  // line of it. These two answer, for the converted lines firstLine..lastLine
+  // (1-indexed inclusive), whether a blank line has to be written before and
+  // after them. Heading and code targets are fenced off by their own syntax and
+  // are left alone. `skip` names a side the caller handles itself (a list item
+  // that joins the list there must NOT be separated from it).
+  function convertNeedsBlank(target) {
+    return !(/^h[1-6]$/.test(target) || target === 'code');
+  }
+  function convertLeadBlank(firstLine, target, skip) {
+    if (!convertNeedsBlank(target) || (skip && skip.lead)) return false;
+    const prev = lines[firstLine - 2];
+    return prev !== undefined && String(prev).trim() !== '';
+  }
+  function separatedConvertText(md, firstLine, lastLine, target, skip) {
+    if (!convertNeedsBlank(target)) return md;
+    let out = md;
+    if (convertLeadBlank(firstLine, target, skip)) out = '\n' + out;
+    const next = lines[lastLine];
+    if (!(skip && skip.trail) && next !== undefined && String(next).trim() !== '') out = out + '\n';
+    return out;
+  }
+
   async function convertBlockViaMenuBody(blockEl, target, anchor) {
     if (!blockEl || !target) return;
     // §3.3's membership rules and the whole shared preamble — see
@@ -11270,13 +11328,17 @@
       pieces.push(convertMd.emitAs(stripped.content, target, {}).join('\n'));
     }
     const md = pieces.join('\n\n');
+    // Nothing changed (converting an H2 to 標題 2, a paragraph to 文字, a quote
+    // to 引用): nothing is written and nothing pushed onto the undo stack, so
+    // there is nothing to render or roll back and no selection range to
+    // declare. Asked before the D3 separation, which would otherwise turn an
+    // own-type convert next to a tight neighbour into a blank-line edit.
+    if (md === lines.slice(first.startLine - 1, last.endLine).join('\n')) return;
+    const lead = convertLeadBlank(first.startLine, target) ? 1 : 0;
 
     const result = commitRangeEdit({ lines, blocks, stack },
-      first.startLine, last.endLine, md);
-    // Nothing changed (converting an H2 to 標題 2) — and nothing was pushed
-    // onto the undo stack either, so there is nothing to render or roll back,
-    // and no selection range to declare.
-    if (result.op === null) return;
+      first.startLine, last.endLine, separatedConvertText(md, first.startLine, last.endLine, target));
+    if (result.op === null) return; // same answer from the commit itself: no step pushed
     const prevLines = lines;
     lines = result.lines;
     // §3.3: 「操作後集合塌縮為操作結果所涵蓋的行區間」. Declared IMMEDIATELY
@@ -11284,8 +11346,8 @@
     // the declaration at its very top, so one left standing lands on some
     // later, unrelated render.
     declareCollapse({
-      startLine: first.startLine,
-      endLine: first.startLine + md.split('\n').length - 1,
+      startLine: first.startLine + lead,
+      endLine: first.startLine + lead + md.split('\n').length - 1,
     });
     const editRange = result.op
       ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
@@ -11300,7 +11362,7 @@
     // pre-commit startLine — it is the very line the collapse above declares,
     // i.e. the operated span's post-commit first line. The plain path is the
     // one path that does not move it (the commit replaces the span in place).
-    return first.startLine;
+    return first.startLine + lead;
   }
 
   // Is the editor session switchAwayFrom() would resolve open on THIS block?
@@ -12625,8 +12687,12 @@
       }
     }
 
+    // v3.17.4 D3: a side the items join is not separated; every other side
+    // keeps a blank line to the definition / text next to it.
+    const skip = { lead: !!(merged.joined && merged.joined.above), trail: !!(merged.joined && merged.joined.below) };
+    const lead = convertLeadBlank(merged.startLine, target, skip) ? 1 : 0;
     const result = commitRangeEdit({ lines, blocks, stack },
-      merged.startLine, endLine, md);
+      merged.startLine, endLine, separatedConvertText(md, merged.startLine, endLine, target, skip));
     if (result.op === null) return;
     const prevLines = lines;
     lines = result.lines;
@@ -12634,8 +12700,8 @@
     // (possibly widened) commit range; a list below renumbered in the same
     // commit is not part of the result.
     declareCollapse({
-      startLine: merged.startLine,
-      endLine: merged.startLine + convertedMd.split('\n').length - 1,
+      startLine: merged.startLine + lead,
+      endLine: merged.startLine + lead + convertedMd.split('\n').length - 1,
     });
     const editRange = result.op
       ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
@@ -12648,7 +12714,7 @@
     // v3.2.1 §Task 5: the caller's `focusLine` — the WIDENED range's first
     // line, which is where the merged list actually starts. `recs[0].startLine`
     // would be wrong whenever §4.3 rule 2 ate a separator above the span.
-    return merged.startLine;
+    return merged.startLine + lead;
   }
 
   // The `.ed-li-check` chrome for a li that has just BECOME a task item.
@@ -15701,9 +15767,19 @@
   // old refusal said could not be done (two commits, two undo ops). Lists
   // that are adjacent blocks (a marker change between them, no gap) move as
   // one group, so an item of the second can land under an item of the first.
+  // v3.17.4 D7 (R9): adjacent in the SOURCE too — only blank lines between
+  // them. A definition is no block, so two lists around one are DOM
+  // neighbours; as one group the second list's first item (no headroom)
+  // zeroed the whole batch's delta. They are two groups, as with a paragraph
+  // between, and the definition is a line between segments, copied as it is.
   async function tabSpanAcrossLists(els, recs, dir) {
     const isLi = (el) => el.getAttribute('data-block-type') === 'li';
     const all = allBlockEls();
+    const linesTouch = (x, y) => {
+      const a = blockRecOf(x);
+      const b = blockRecOf(y);
+      return !!a && !!b && lines.slice(a.endLine, b.startLine - 1).every((l) => l.trim() === '');
+    };
     const groups = [];
     for (let i = 0; i < els.length; i++) {
       if (!isLi(els[i])) continue;
@@ -15712,7 +15788,8 @@
         const run = listRunOf(els[i]);
         if (!run.length) { refuseStructuralListEdit(); return; }
         const prev = groups[groups.length - 1];
-        if (prev && all.indexOf(run[0]) === all.indexOf(prev.run[prev.run.length - 1]) + 1) {
+        const prevLast = prev && prev.run[prev.run.length - 1];
+        if (prev && all.indexOf(run[0]) === all.indexOf(prevLast) + 1 && linesTouch(prevLast, run[0])) {
           prev.run = prev.run.concat(run);
           g = prev;
         } else {
@@ -15749,7 +15826,8 @@
     });
     // Segments in document order: each list group re-serialized, each other
     // member's own lines (a heading re-depthed). Whatever lies between two
-    // segments — blank lines, by the check above — is copied as it is.
+    // segments — blank lines and the definition lines no block owns, by the
+    // check above — is copied as it is.
     const segs = [];
     for (let i = 0; i < recs.length; i++) {
       if (isLi(els[i])) continue;
@@ -20591,6 +20669,9 @@
     // Two items that were already neighbours in two DIFFERENT lists stay two
     // lists, with whatever separated them.
     const keepsApart = (x, y) => all[all.indexOf(x) + 1] === y && runOf.get(x) !== runOf.get(y);
+    // v3.17.4 D5 (R8): the source lines of every gap copied below, so a
+    // definition among them is not appended a second time.
+    const replayedLines = new Set();
     let lastEl = null;
     for (let k = 0; k < seq.length;) {
       let unit;
@@ -20625,8 +20706,10 @@
       if (lastEl) {
         const a = blockRecOf(lastEl);
         const b = blockRecOf(unit[0]);
-        if (all[all.indexOf(lastEl) + 1] === unit[0]) out.push(...lines.slice(a.endLine, b.startLine - 1));
-        else out.push('');
+        if (all[all.indexOf(lastEl) + 1] === unit[0]) {
+          out.push(...lines.slice(a.endLine, b.startLine - 1));
+          for (let n = a.endLine + 1; n < b.startLine; n++) replayedLines.add(n);
+        } else out.push('');
       }
       const base0 = out.length;
       unitLines.forEach((l, n) => {
@@ -20641,7 +20724,7 @@
     if (seq[seq.length - 1] !== regionEls[regionEls.length - 1] && lastRec.endLine < lines.length &&
         String(lines[lastRec.endLine]).trim() !== '') out.push('');
 
-    const result = commitRangeEdit({ lines, blocks, stack }, firstRec.startLine, lastRec.endLine, out.join('\n'));
+    const result = commitRangeEdit({ lines, blocks, stack }, firstRec.startLine, lastRec.endLine, out.join('\n'), { replayedLines });
     if (result.op === null) return;
     endBurstWithoutResolve();
     const prevLines = lines;
@@ -22191,7 +22274,7 @@
     // final fix wave (R93) it also holds the task checkbox (`pressedCheck`):
     // three classes and the checkbox.
     let checkPress = null; // { el, epoch, snap }: the last press on a task checkbox (R89, R93)
-    let degradedPress = null; // { el, epoch, identity }: the last press on a degraded block (R102)
+    let degradedPress = null; // degradedPressRecord(): the last press on a degraded block (R102)
     let degradedReleaseOpened = false; // T9b (R50): the last press's release already opened its block
     document.addEventListener('mousedown', (e) => {
       degradedReleaseOpened = false;
@@ -22217,10 +22300,7 @@
       // the click handler can find it again after that commit's render
       // replaced it. Never an identity taken during a flight (R94).
       const pressedBlock = !pressedCheck && e.target && e.target.closest ? e.target.closest('.ed-block') : null;
-      degradedPress = pressedBlock && isDegradedBlock(pressedBlock)
-        ? { el: pressedBlock, epoch: reconcileEpoch,
-            identity: commitsSettled() && !reconcileBlocksCommits() ? captureBlockIdentity(pressedBlock) : null }
-        : null;
+      degradedPress = pressedBlock && isDegradedBlock(pressedBlock) ? degradedPressRecord(pressedBlock) : null;
       // v3.15.0 final fix wave (R93): the task checkbox joins the list, for
       // the reason the trace above records. Its press blurred the surface
       // being typed in, that commit's render replaced the checkbox before the
@@ -22524,6 +22604,24 @@
       ev.clientX < blockEl.getBoundingClientRect().left;
   }
 
+  // R102 / E4 (R13): what a press on a degraded block records, before its blur
+  // starts the commit of whatever was being typed. `epoch`, the reconciliation
+  // it saw. `identity`, only when nothing is in flight and the screen is
+  // `lines` (never one taken during a flight, R94). Otherwise, while a write
+  // is in flight, its `print` as the screen draws it, whether that print named
+  // this block alone at the press (`printUnique`, with no undo or redo
+  // rendering) and the undo/redo render count then (`historyAt`). Final review
+  // I3: taken at the PRESS, because the release may come after the write has
+  // landed and replaced the node, when there is nothing left to print.
+  function degradedPressRecord(blockEl) {
+    const settled = commitsSettled();
+    const identity = settled && !reconcileBlocksCommits() ? captureBlockIdentity(blockEl) : null;
+    const print = !identity && !settled ? drawnBlockPrint(blockEl) : null;
+    return { el: blockEl, epoch: reconcileEpoch, identity, print,
+      printUnique: !!print && historyRendersInFlight === 0 && uniqueBlockElByPrint(print) === blockEl,
+      historyAt: historyRenderSeq };
+  }
+
   // The degraded block's open (a raw box, or the in-place code edit), from a
   // click on it (`e`) or from the release of a press whose click was lost
   // (`upBlock`, the block the button came up over: the gesture is the
@@ -22534,6 +22632,29 @@
     const identity = press ? press.identity
       : (commitsSettled() && !reconcileBlocksCommits() ? captureBlockIdentity(blockEl) : null);
     const topAtClick = blockEl.getBoundingClientRect().top;
+    // v3.17.4 E4 (R13): no identity because a write was in flight at the press
+    // (R94). Measured before: a quote clicked 50 ms after a split drew the
+    // notice once the render landed and opened nothing, since the render
+    // replaced the node and there was nothing to find it again by. So the
+    // block is printed as it read on screen at the press, and after the write
+    // it is found again by that print (settledGestureBlock()'s rule, R17 / R46:
+    // unique at the press and after the write, no undo or redo meanwhile, no
+    // reconciliation owed); refused with the notice only when that fails. The
+    // order below stays switchAwayFrom() then settleCommits(): R102's open of
+    // a block whose screen agrees with `lines` needs the switch to run before
+    // any reconciliation is owed, and a wait placed first would let the owed
+    // redraw run ahead of the open.
+    // Final review I3: the print is the press's own (degradedPressRecord()),
+    // so a release that comes after the write landed can still find the block;
+    // a click with no press of its own prints the block now. Either way the
+    // re-find requires the press's reconciliation epoch (checked below for
+    // every path), its undo/redo render count, and no reconciliation owed.
+    const pressPrint = !!(press && press.print);
+    const flightPrint = pressPrint ? press.print
+      : (!identity && !commitsSettled() ? drawnBlockPrint(blockEl) : null);
+    const refindable = pressPrint ? press.printUnique
+      : !!flightPrint && historyRendersInFlight === 0 && uniqueBlockElByPrint(flightPrint) === blockEl;
+    const historyAt = pressPrint ? press.historyAt : historyRenderSeq;
     const ok = await switchAwayFrom();
     if (!ok) return;
     await settleCommits();
@@ -22541,7 +22662,11 @@
     // the one block of its type with that source — a start line is no proof
     // (R95's removal of an emptied paragraph shifts lines unlogged, and an
     // identical quote then sat on the clicked one's line and was opened).
-    const live = refindBlock(blockEl, identity);
+    let live = refindBlock(blockEl, identity);
+    if (!live && refindable && epochAtPress === reconcileEpoch && historyAt === historyRenderSeq &&
+        !reconcileBlocksCommits()) {
+      live = uniqueBlockElByPrint(flightPrint);
+    }
     if (!live || reconcileEpoch !== epochAtPress ||
         (reconcileBlocksCommits() && !blockReadsAsDrawn(live))) {
       showError(DROPPED_GESTURE_MESSAGE, null, null);
@@ -24287,12 +24412,13 @@
   // code block, a diagram, an image, a raw box, the code edit or a transient
   // paragraph at either end refuses the drop with a notice, and the source
   // keeps its text; so does a drop outside every block (fix round 1, R38: the
-  // search box, the link field, the page around the document). A drop inside
-  // the drag's own block is left to the browser (its two halves land in one
-  // burst, which commits them together), and a drag that did not start in the
+  // search box, the link field, the page around the document). v3.17.4 D1
+  // (R4): a drop inside the drag's own text surface is the editor's move too
+  // (moveDroppedText(), one op): left to the browser, Chromium's own move
+  // wrote a U+00A0 where it closed the gap. A drag that did not start in the
   // document, or that carries files, is not this code's at all.
   //
-  // `textDrag`: { blockEl, surface, range, text, handled } from dragstart to
+  // `textDrag`: { blockEl, surface, range, text, handled, hadFiles } from dragstart to
   // just after dragend, or null. `surface` / `range` are null when the drag
   // is not a text selection in a plain surface (a table cell, an image).
   // `handled` (set at the drop): this code took the drop, so any input the
@@ -24302,7 +24428,7 @@
   // the drop was cancelled; the guard is there so an engine that does cannot
   // write the source behind the move.
   let textDrag = null;
-  const TEXT_DROP_REFUSED_MESSAGE = '文字只能拖放到另一個段落、標題或清單項目裡，原文保持不動';
+  const TEXT_DROP_REFUSED_MESSAGE = '這段文字無法放在這裡，原文保持不動';
 
   function elementOfNode(node) {
     return node && (node.nodeType === 1 ? node : node.parentElement);
@@ -24340,10 +24466,12 @@
     return t && contentEl.contains(t) ? t.closest('.ed-block') : null;
   }
   // The drag this code answers for `e`, or null: an in-document drag
-  // (`textDrag`), never one that carries files — a picture or a .drawio from
+  // (`textDrag`). An event that carries files belongs to it only when its
+  // dragstart carried them too (a picture dragged out of the page, refused
+  // rather than uploaded as a copy, v3.17.4 D4); a picture or a .drawio from
   // the desktop is wireImageDrop()'s whatever state a previous drag left.
   function textDragFor(e) {
-    return textDrag && !dragCarriesFiles(e) ? textDrag : null;
+    return textDrag && (!dragCarriesFiles(e) || textDrag.hadFiles) ? textDrag : null;
   }
 
   function wireTextDrop() {
@@ -24365,7 +24493,9 @@
       if (!t || !contentEl.contains(t)) return;
       const blockEl = t.closest('.ed-block');
       if (!blockEl || !contentEl.contains(blockEl)) return;
-      const drag = { blockEl, surface: null, range: null, text: '', handled: false };
+      // `hadFiles` (v3.17.4 D4, R6): the dragstart already carried Files, so an
+      // in-page drag (a picture) is told apart from a file dropped from outside.
+      const drag = { blockEl, surface: null, range: null, text: '', handled: false, hadFiles: dragCarriesFiles(e) };
       const sel = window.getSelection();
       const surface = textDropSurfaceOf(blockEl);
       if (surface && sel.rangeCount && !sel.isCollapsed) {
@@ -24395,7 +24525,13 @@
       const drag = textDragFor(e);
       if (!drag) return;
       const t = elementOfNode(e.target);
-      if (!t || dragBlockAt(e) === drag.blockEl || t.isContentEditable) return;
+      if (!t || t.isContentEditable) return;
+      // A drag that carried Files from its dragstart (a picture) over its own
+      // non-text block is taken here too, so wireImageDrop's bubble dragover
+      // cannot answer it with a copy (v3.17.4 D4).
+      const ownFiles = drag.hadFiles && dragBlockAt(e) === drag.blockEl && !textDropSurfaceOf(drag.blockEl);
+      if (dragBlockAt(e) === drag.blockEl && !ownFiles) return;
+      if (ownFiles) e.stopPropagation();
       e.preventDefault();
       if (e.dataTransfer) e.dataTransfer.dropEffect = 'move';
     };
@@ -24410,7 +24546,30 @@
       const drag = textDragFor(e);
       if (!drag || waveEditorIsModal()) return;
       const destBlockEl = dragBlockAt(e);
-      if (destBlockEl === drag.blockEl) return;
+      if (destBlockEl === drag.blockEl) {
+        // A block that is not a text surface (a code block's code edit, a
+        // table's cells, a raw box, a picture block's alt field) keeps its own
+        // drop handling inside itself, as before v3.17.4.
+        if (!textDropSurfaceOf(drag.blockEl)) {
+          // Carrying Files from its dragstart (a picture dropped back on
+          // itself): neither an upload nor a replace, and no notice (v3.17.4
+          // D4). Without Files the block's own drop handling is left alone.
+          if (drag.hadFiles) { e.preventDefault(); e.stopPropagation(); drag.handled = true; }
+          return;
+        }
+        e.preventDefault();
+        e.stopPropagation();
+        drag.handled = true;
+        // v3.17.4 D1 (R4): a drag with no text selection (a picture inside
+        // the paragraph drags itself) dropped in its own block does nothing,
+        // with no notice; so does a drop point off the surface's text.
+        if (!drag.surface || !drag.text) return;
+        const ownOffset = surfaceOffsetFromPoint(drag.surface, e.clientX, e.clientY);
+        if (ownOffset === null) return;
+        // The selected text moved within its own block: the editor's move.
+        moveDroppedText(drag.blockEl, drag.range, drag.blockEl, ownOffset).catch(structuralKeyFailed);
+        return;
+      }
       e.preventDefault();
       e.stopPropagation();
       drag.handled = true;
@@ -24452,8 +24611,9 @@
   // `**bravo**` dropped into `**delta**` wrote `**de**bravo**lta**`, which
   // reparses with bravo NOT bold. A link dropped inside a link has no
   // Markdown at all (links do not nest; measured, the destination link came
-  // back broken), and inside inline code no mark can be written, so those
-  // two are refused: false.
+  // back broken), and inside inline code no mark and no line break can be written (a
+  // code span holds text only; a break used to vanish silently, v3.17.4 D2),
+  // so those two are refused: false.
   const MARK_KIND = { STRONG: 'b', B: 'b', EM: 'i', I: 'i', DEL: 's', S: 's', STRIKE: 's', U: 'u', CODE: 'code', A: 'a' };
   function fitFragmentToDrop(frag, atNode, surface) {
     const kinds = {};
@@ -24462,7 +24622,7 @@
     }
     const els = Array.prototype.slice.call(frag.querySelectorAll('*'));
     if (kinds.a && els.some((el) => el.nodeName === 'A')) return false;
-    if (kinds.code && els.some((el) => el.nodeName !== 'BR')) return false;
+    if (kinds.code && els.length) return false;
     els.forEach((el) => {
       if (!kinds[MARK_KIND[el.nodeName]] || el.nodeName === 'A') return;
       while (el.firstChild) el.parentNode.insertBefore(el.firstChild, el);
@@ -24528,6 +24688,10 @@
   // (refindBlock(), as performBlockDrop() does). From there on it is
   // synchronous up to commitTypingThenStructure() (the v3.13.1 guard); a
   // failed render keeps the moved text on screen as a pending structure (D7).
+  // v3.17.4 D1 (R4): `srcBlockEl` may be `destBlockEl` (a move inside one
+  // block); `destOffset` is then in the surface's text BEFORE the move, a
+  // drop inside the dragged text [from, to] writes nothing, and one past it
+  // lands `to - from` earlier once the text has left.
   async function moveDroppedText(srcBlockEl, srcRange, destBlockEl, destOffset) {
     const srcSurface0 = textDropSurfaceOf(srcBlockEl);
     if (!srcSurface0 || !srcSurface0.contains(srcRange.startContainer) ||
@@ -24536,6 +24700,10 @@
     const to = offsetInSurface(srcSurface0, srcRange.endContainer, srcRange.endOffset);
     const dragged = srcSurface0.textContent.slice(from, to);
     if (!(to > from)) { refuseTextDrop(); return; }
+    const same = srcBlockEl === destBlockEl;
+    if (same && destOffset >= from && destOffset <= to) return;
+    // Where the text goes in, counted once the dragged text has left.
+    const insertAt = same && destOffset > to ? destOffset - (to - from) : destOffset;
     // v3.15.0 R100 (b), as performBlockDrop(): no identity is taken while a
     // commit is in flight; both ends must still be on screen once it lands.
     if (!commitsSettled()) {
@@ -24555,7 +24723,7 @@
     const dest = refindBlock(destBlockEl, destIdentity, destSelf);
     const srcSurface = src ? textDropSurfaceOf(src) : null;
     const destSurface = dest ? textDropSurfaceOf(dest) : null;
-    if (!srcSurface || !destSurface || src === dest ||
+    if (!srcSurface || !destSurface || (src === dest) !== same ||
         srcSurface.textContent.slice(from, to) !== dragged || destOffset > destSurface.textContent.length) {
       showError(DROPPED_GESTURE_MESSAGE, null, null);
       return;
@@ -24564,7 +24732,11 @@
     const a = textMoveEnd(src, srcSurface);
     const b = textMoveEnd(dest, destSurface);
     if (!a || !b) { refuseTextDrop(); return; }
-    if (a.kind === 'run' && b.kind === 'run' && a.run[0] === b.run[0]) {
+    if (same) {
+      // One block: one end (a list item's run with `lis: [src]`).
+      if (a.kind === 'run' && !listRunSupportsStructuralEdit(a.run, src)) { refuseTextDrop(); return; }
+      ends = [a];
+    } else if (a.kind === 'run' && b.kind === 'run' && a.run[0] === b.run[0]) {
       if (!listRunSupportsStructuralEdit(a.run, [src, dest])) { refuseTextDrop(); return; }
       ends = [{ kind: 'run', run: a.run, lis: [src, dest], first: a.first, last: a.last }];
     } else {
@@ -24581,9 +24753,26 @@
     // The fragment is built, fitted to where it lands and asked of the inline
     // serializer before anything on screen changes; the source's own nodes
     // are untouched by all three (cloneContents()).
-    const at = pointInSurface(destSurface, destOffset);
     const frag = fragmentWithMarks(range, srcSurface);
-    if (!fitFragmentToDrop(frag, at[0], destSurface)) { refuseTextDrop(); return; }
+    // Where it lands: in one block, the point is taken after the dragged text
+    // has left, so the fit reads a copy of the surface with that delete
+    // already done (the same steps as the real one below).
+    let at = pointInSurface(destSurface, destOffset);
+    let fitAt = at;
+    let fitSurface = destSurface;
+    if (same) {
+      fitSurface = srcSurface.cloneNode(true);
+      const p0 = pointInSurface(fitSurface, from);
+      const q0 = pointInSurface(fitSurface, to);
+      const gone = document.createRange();
+      gone.setStart(p0[0], p0[1]);
+      gone.setEnd(q0[0], q0[1]);
+      gone.deleteContents();
+      dropEmptyInlines(fitSurface);
+      fitSurface.normalize();
+      fitAt = pointInSurface(fitSurface, insertAt);
+    }
+    if (!fitFragmentToDrop(frag, fitAt[0], fitSurface)) { refuseTextDrop(); return; }
     // A heading is one line: a hard break in the moved text becomes a space.
     if (dest.getAttribute('data-block-type') === 'heading') {
       Array.prototype.slice.call(frag.querySelectorAll('br')).forEach((br) => {
@@ -24600,6 +24789,7 @@
       range.deleteContents();
       dropEmptyInlines(srcSurface);
       srcSurface.normalize();
+      if (same) at = pointInSurface(destSurface, insertAt);
       const firstIn = frag.firstChild;
       const lastIn = frag.lastChild;
       const ins = document.createRange();
@@ -24651,7 +24841,7 @@
     const destId = dest.getAttribute('data-block-id');
     const ok = await commitTypingThenStructure({ typed: null, text: s.text, carriesGap: s.carriesGap === true,
       range: () => [first, last], oldRange: [first, last], lineMap: s.lineMap,
-      pending: { surfaces: [srcSurface, destSurface], serialize } });
+      pending: { surfaces: same ? [srcSurface] : [srcSurface, destSurface], serialize } });
     if (!ok) return;
     // The moved text stays selected where it landed, as the browser's own
     // move leaves it.
@@ -24659,7 +24849,7 @@
     const surface = landed ? blockContentEl(landed) : null;
     if (!surface || !surface.classList.contains('ed-wys-armed')) return;
     surface.focus();
-    restoreSelection(surface, destOffset, destOffset + movedLen);
+    restoreSelection(surface, insertAt, insertAt + movedLen);
   }
 
   // ── 追加 2: paste ──────────────────────────────────────────────────────
@@ -27256,7 +27446,7 @@
     if (wasAlt && opts && opts.keepDraft && imgTbInput.value !== wasAlt.original) {
       const rec = imgTbBlock && imgTbBlock.isConnected ? blockRecOf(imgTbBlock) : null;
       imgTbAltDraft = rec ? { source: blockSourceOf(rec), value: imgTbInput.value } : null;
-    } else imgTbAltDraft = null;
+    } else if (wasAlt) imgTbAltDraft = null;
     imgTbAlt = null;
     imgTbBlock = null;
     imgTbKeyboard = false;
@@ -27428,15 +27618,23 @@
       if (e.isComposing || e.keyCode === 229) { e.stopPropagation(); return; }
       e.preventDefault(); e.stopPropagation(); exitImageAltMode(true); return;
     }
-    if (e.key !== 'Enter' || e.isComposing) return;
+    // R11: leaving the keyboard-opened field by Tab / Shift+Tab commits it
+    // like Enter and returns focus to the image's block selection (the
+    // commit re-renders the block, so no button is left to walk on to). The
+    // mouse-opened field keeps the browser's own Tab.
+    const byTab = e.key === 'Tab' && imgTbKeyboard && !e.isComposing && e.keyCode !== 229;
+    if ((e.key !== 'Enter' && !byTab) || e.isComposing) return;
     e.preventDefault();
     e.stopPropagation();
     const alt = imgTbAlt;
     const blk = imgTbBlock;
     const value = imgTbInput.value;
+    const keptSel = byTab && blockSelection ? { anchorLine: blockSelection.anchorLine, focusLine: blockSelection.focusLine } : null;
     hideImageToolbar();
     if (!alt || value === alt.original) return;
-    applyImageEdit(blk, alt.identity, { alt: value }).catch(showUnexpectedFailure);
+    applyImageEdit(blk, alt.identity, { alt: value })
+      .then(() => { if (keptSel) setBlockSelection(keptSel); })
+      .catch(showUnexpectedFailure);
   });
   imgTbInput.addEventListener('blur', (e) => {
     if (!imgTbAlt) return;

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;
@@ -524,17 +641,21 @@
   // the ampersand and the backslash are written as the character references
   // the browser reads back as the same character. The reader side below
   // undoes those, plus the backslash escapes older files hold.
-  // Final review M2 (R25 / R7): and every other character reference the
-  // reader decodes — marked passes them into the alt attribute untouched and
-  // the browser decodes them — so the field shows what the reader shows: a
-  // decimal or hex number, and the named amp, lt, gt, quot, apos and nbsp. With
-  // only `&amp;`, `&#96;` and `&#92;` read before, a source `a &lt; b` showed "a &lt; b" in the field
-  // and, once edited, was written `a &amp;lt; b`, which the reader shows as
-  // "a &lt; b". A name outside that list stays as written in the field, and
-  // is written so that it renders as that text.
+  // Final review M2 (R25 / R7), widened by v3.17.4 E1 (R10): every character
+  // reference the reader decodes — marked passes them into the alt attribute
+  // untouched and the browser decodes them — so the field shows what the
+  // reader shows. A decimal or hex number needs no table. A name goes through
+  // the installed decoder (the client installs one that asks the page itself,
+  // so every name the browser knows decodes); with none installed, the six
+  // names amp, lt, gt, quot, apos and nbsp. A name the decoder does not know
+  // stays as written in the field, and is written so that it renders as that
+  // text. An edited alt is written as the decoded character itself.
   const ALT_ESCAPE = { '[': '\\[', ']': '\\]', '&': '&amp;', '`': '&#96;', '\\': '&#92;' };
   const ALT_NAMED_CHAR = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: '\u00a0' };
-  const ALT_UNESCAPE = /\\([!-\/:-@\[-`{-~])|&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|(amp|lt|gt|quot|apos|nbsp));/g;
+  const defaultNamedReference = (name) => ALT_NAMED_CHAR[name];
+  let namedReference = defaultNamedReference;
+  function setNamedReferenceDecoder(fn) { namedReference = typeof fn === 'function' ? fn : defaultNamedReference; }
+  const ALT_UNESCAPE = /\\([!-\/:-@\[-`{-~])|&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|([A-Za-z][A-Za-z0-9]*));/g;
   // A number the HTML parser would not give as itself (zero, a surrogate,
   // past U+10FFFF) is U+FFFD there, so it is here too.
   function altCodePoint(n) {
@@ -544,7 +665,8 @@
     if (c !== undefined) return c;
     if (dec !== undefined) return altCodePoint(parseInt(dec, 10));
     if (hex !== undefined) return altCodePoint(parseInt(hex, 16));
-    return ALT_NAMED_CHAR[name];
+    const r = namedReference(name);
+    return typeof r === 'string' ? r : m;
   }
 
   function parseImageParagraph(text) {
@@ -576,5 +698,5 @@
     return out;
   }
 
-  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder };
 });

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/md2doc.js

@@ -1082,6 +1082,13 @@ ${itemsHtml}
       openSvg = 0;
       return isSvgOnly(src);
     }
+    // v3.17.4 E5: an svg that is real inline html among a block's own inline
+    // tokens (a code span naming it is not one). The reader marks the block
+    // with data-svg-plate so dark mode plates it, whatever text sits beside it.
+    function hasInlineSvg(toks) {
+      return Array.isArray(toks) && toks.some((tk) => tk && ((tk.type === 'html' && /<svg[\s>]/i.test(String(tk.raw || ''))) ||
+        (tk.type === 'text' && hasInlineSvg(tk.tokens))));
+    }
 
     const baseHtml = renderer.html.bind(renderer);
     renderer.html = function(token) {
@@ -1241,6 +1248,9 @@ ${itemsHtml}
     };
     const baseParagraph = renderer.paragraph.bind(renderer);
     renderer.paragraph = function(token) {
+      // A loose item's text paragraph is made up by marked from the already
+      // rendered body, so its svg is real html there (a code span is escaped).
+      const madeUp = skipMadeUpParagraph;
       if (skipMadeUpParagraph) {
         skipMadeUpParagraph = false;
       } else {
@@ -1250,6 +1260,9 @@ ${itemsHtml}
       if (!opts.editMode && wrapsSvgParagraph(token.raw)) {
         return baseParagraph(token).replace(/^<p>/, '<p class="inline-svg">');
       }
+      if (!opts.editMode && (hasInlineSvg(token.tokens) || (madeUp && /<svg[\s>]/i.test(String(token.text || ''))))) {
+        return baseParagraph(token).replace(/^<p>/, '<p data-svg-plate="1">');
+      }
       return baseParagraph(token);
     };
 
@@ -1264,7 +1277,11 @@ ${itemsHtml}
       } finally {
         looseItemText = outerLoose;
       }
-      if (!token.task) return html;
+      // v3.17.4 E5: a tight item's own text sits straight in the li (no p). Marked
+      // last, because the task wrapping below anchors on a bare li tag.
+      const plateTight = (h) => (!opts.editMode && !token.loose && hasInlineSvg(token.tokens))
+        ? h.replace(/^<li( class="[^"]*")?/, '$& data-svg-plate="1"') : h;
+      if (!token.task) return plateTight(html);
       // v3.10.0: a task item drops its bullet and keeps its own text in a span,
       // so a checked item's strike-through stops at its own words — CSS
       // text-decoration cannot be undone on a nested child list. Shapes: tight
@@ -1273,8 +1290,8 @@ ${itemsHtml}
       // first: a block child's opening tag, the loose item's </p>, or </li>.
       const cls = token.checked ? 'task-item is-checked' : 'task-item';
       const m = html.match(/^<li>([\s\S]*?<input[^>]*>)([\s\S]*?)(<(?:ul|ol|blockquote|pre|table|div|p|h[1-6])[\s>][\s\S]*|<\/p>[\s\S]*|<\/li>\s*)$/);
-      if (!m) return html.replace(/^<li>/, '<li class="' + cls + '">');
-      return '<li class="' + cls + '">' + m[1] + ' <span class="task-text">' + m[2].trim() + '</span>' + m[3];
+      if (!m) return plateTight(html.replace(/^<li>/, '<li class="' + cls + '">'));
+      return plateTight('<li class="' + cls + '">' + m[1] + ' <span class="task-text">' + m[2].trim() + '</span>' + m[3]);
     };
 
     const baseBlockquote = renderer.blockquote.bind(renderer);
@@ -1405,7 +1422,7 @@ ${itemsHtml}
           // v3.14.0 T10: the reader wraps an svg-only block in .inline-svg for the
           // dark white plate; edit mode keeps its DOM, so it marks the wrapper.
           const svgPlate = ((t.type === 'html' && t.block && wrapsSvg(t.text)) ||
-            (t.type === 'paragraph' && wrapsSvgParagraph(t.raw))) ? ' data-svg-plate="1"' : '';
+            (t.type === 'paragraph' && (wrapsSvgParagraph(t.raw) || hasInlineSvg(t.tokens)))) ? ' data-svg-plate="1"' : '';
           parts.push(
             `<div class="ed-block" data-block-id="${b.id}" data-block-type="${b.type}"${svgPlate}>` +
             inner + '</div>'

package/lib/theme/tokens.js

@@ -168,7 +168,8 @@ function themeCss() {
     '    ' + D + ' .content .drawio { background: #ffffff; border-radius: 6px; box-shadow: 0 0 0 10px #ffffff; }',
     // R7 甲: a Markdown-native inline svg (wrapped in .inline-svg by the renderer) gets the
     // same white plate; its ink stays the light text colour because the plate is always white.
-    '    ' + D + ' .content .inline-svg > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] > p > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] .ed-li-text > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] .ed-li-text > p > svg { background: #ffffff; color: #1f2328; border-radius: 4px; box-shadow: 0 0 0 10px #ffffff; }',
+    // A task item's svg sits one level down, inside span.task-text (tight li or loose p).
+    '    ' + D + ' .content .inline-svg > svg, ' + D + ' .content p[data-svg-plate="1"] > svg, ' + D + ' .content li[data-svg-plate="1"] > svg, ' + D + ' .content li[data-svg-plate="1"] > p > svg, ' + D + ' .content li[data-svg-plate="1"] > .task-text > svg, ' + D + ' .content p[data-svg-plate="1"] > .task-text > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] > p > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] .ed-li-text > svg, ' + D + ' .content .ed-block[data-svg-plate="1"] .ed-li-text > p > svg { background: #ffffff; color: #1f2328; border-radius: 4px; box-shadow: 0 0 0 10px #ffffff; }',
     '    ' + D + ' .lightbox-canvas > svg[data-md2doc-recoloured] { background: var(--md-bg); }',
     '  }',
     '  .md2doc-theme-toggle { position: fixed; right: 20px; bottom: 20px; z-index: 60; width: 40px; height: 40px;',

package/package.json

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