@helping-ai-workflow/md2doc 3.17.3 → 3.17.4

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

@@ -524,17 +524,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 `&`, ``` and `\` read before, a source `a < b` showed "a < b" in the field
-  // and, once edited, was written `a < b`, which the reader shows as
-  // "a < 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 = { '[': '\\[', ']': '\\]', '&': '&', '`': '`', '\\': '\' };
   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 +548,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 +581,5 @@
     return out;
   }
 
-  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder };
 });

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