@helping-ai-workflow/md2doc 3.17.7 → 3.17.9

package/lib/editor/client.js

@@ -17387,7 +17387,16 @@
         // after a space (`**a **`) is not a closing delimiter in markdown.
         const r = document.createRange();
         r.selectNodeContents(cell);
-        if (trimRangeToText(r)) wrapRangeIn(r, tag, cell);
+        if (trimRangeToText(r)) {
+          // v3.17.8 D2 (final review I2): a cell whose text is one code span
+          // (a signal-name column) trims to the code's own text node, and the
+          // wrap landed inside the <code>, which the save drops. The mark goes
+          // around the code instead (`**`b`**`), as it goes around every other
+          // cell's text.
+          const code = tag !== 'CODE' ? wholeSelectionMark(r, 'CODE', cell) : null;
+          if (code) r.selectNode(code);
+          wrapRangeIn(r, tag, cell);
+        }
       }
     });
     snapBurstIfActive(burst.editEl, 'range-mark');
@@ -21616,6 +21625,15 @@
 
   // Applies the toggle policy for a plain mark type (STRONG/EM/CODE/DEL/U —
   // link has its own entry point below because it also needs a URL).
+  // v3.17.8 D2: Markdown cannot hold a mark inside a code span (serializeCode()
+  // writes the code's textContent), so a WRAP of anything but the code itself is
+  // refused when the selection lies wholly inside one <code>. One helper, read
+  // by selectionMarkStates() (the buttons' 'inert') and by the actions (the
+  // keyboard reaches them without a button), so the two cannot drift. Unwrapping
+  // a mark that wraps the code from outside stays allowed: that is spellable.
+  function wrapRefusedInCode(range, tag, root) {
+    return tag !== 'CODE' && !!wholeSelectionMark(range, 'CODE', root);
+  }
   function applyMarkToggle(tag) {
     if (cellRangeBurst()) { applyMarkToCellRange(tag); return; }
     const root = selToolbarEditEl;
@@ -21646,6 +21664,11 @@
       return;
     }
     if (!trimRangeToText(range)) return;   // 全空白／collapsed 選取：no-op
+    // v3.17.8 D2: judged on the TRIMMED range, as the wrap sees it. A double
+    // click on a code span's last word also selects the space after it; the
+    // untrimmed range then ends outside the <code>, the trim pulls it back in,
+    // and the wrap landed inside the code (final review I1).
+    if (wrapRefusedInCode(range, tag, root)) return;
     snapBurstIfActive(root, 'mark-pre');
     reselectAndReposition(wrapRangeIn(range, tag, root));
     snapBurstIfActive(root, 'mark');
@@ -21990,6 +22013,7 @@
     // An all-whitespace range trims to nothing: bail before the field opens,
     // or accepting it would wrap a bare space in an <a>.
     if (!trimRangeToText(range)) return;
+    if (wrapRefusedInCode(range, 'A', root)) return;   // v3.17.8 D2
     openLinkField({ root, range, existing: null, prefill: '' });
   }
 
@@ -23382,7 +23406,9 @@
   //    <strong> was gone, the paragraph's text was unchanged, and the file
   //    saved back with no `**` in it. So drawing every button inert there
   //    would grey out a button that acts.
-  //  * 'A' never reaches it. The link button does not go through
+  //  * (v3.17.8 D2) A selection wholly inside one <code> makes every other
+  //    tag's would-wrap state 'inert' too, 'A' included: wrapRefusedInCode().
+  //  * Otherwise 'A' never reaches it. The link button does not go through
   //    applyMarkToggle() at all — applyLinkToggle() has the same first two
   //    branches, and since v3.4.0 its third refuses an all-whitespace
   //    selection through trimRangeToText() before the URL field opens. The
@@ -23405,11 +23431,13 @@
     if (!hasFormattableSelection(sel)) return null;
     const root = selToolbarEditEl;
     const range = sel.getRangeAt(0);
-    const wrappable = trimRangeToText(range.cloneRange());
+    const trimmed = range.cloneRange();
+    const wrappable = trimRangeToText(trimmed);
     const out = {};
     for (const tag of MARK_TAGS) {
       if (wholeSelectionMark(range, tag, root)) out[tag] = 'whole';
       else if (overlappingMarks(range, tag, root).length > 0) out[tag] = 'partial';
+      else if (wrapRefusedInCode(wrappable ? trimmed : range, tag, root)) out[tag] = 'inert';   // v3.17.8 D2, trimmed as the wrap sees it
       else if (wrappable || tag === 'A') out[tag] = 'none';
       else out[tag] = 'inert';
     }
@@ -26109,6 +26137,15 @@
   // file kept the plain word. This listener is registered ahead of the
   // `native-format-pre` one below (both capture phase on document, so they
   // run in that order), so the burst exists when that one snaps it.
+  // v3.17.8 D2: the browser's own Ctrl+B / I / U must not wrap inside a code
+  // span either (it would draw <b> in a <code> that the save then drops).
+  document.addEventListener('beforeinput', (e) => {
+    if (!NATIVE_FORMAT_INPUT_TYPES.has(e.inputType) || e.inputType === 'formatRemove') return;
+    const surface = e.target && e.target.closest ? e.target.closest('.ed-wys-armed, .ed-wys-cell') : null;
+    const sel = window.getSelection();
+    if (!surface || !sel || !sel.rangeCount || sel.isCollapsed) return;
+    if (wholeSelectionMark(sel.getRangeAt(0), 'CODE', surface)) e.preventDefault();
+  }, true);
   document.addEventListener('beforeinput', (e) => {
     if (e.defaultPrevented) return;
     const t = e.inputType;

package/lib/editor/inline-md.js

@@ -25,6 +25,7 @@
     return ch !== undefined && /\w/.test(ch);
   }
 
+  const REFERENCE_SHAPE = /^&#?\w+;/;
   function escapeText(s) {
     let out = '';
     for (let i = 0; i < s.length; i++) {
@@ -36,6 +37,13 @@
       if (c === ']') { out += '\\]'; continue; }
       if (c === '<') { out += '&lt;'; continue; }
       if (c === '~') { out += '\\~'; continue; }
+      // v3.17.8 D3: an `&` that starts something shaped like a character
+      // reference (`&amp;`, `&#38;`, `&x_1;`) is written `\&`, or the reader
+      // decodes what the person typed (`a &amp; b` showed `a & b`). The shape
+      // is marked's own, `&#?\w+;` (its escape() leaves exactly that alone),
+      // so it covers every reference a browser could decode. Any other `&`
+      // (`AT&T`, `&copy` with no `;`) is shown as typed and stays bare.
+      if (c === '&' && REFERENCE_SHAPE.test(s.slice(i, i + 40))) { out += '\\&'; continue; }
       if (c === '_') {
         const prev = s[i - 1];
         const next = s[i + 1];

package/lib/editor/paste-md.js

@@ -381,6 +381,20 @@ function htmlToMarkdown(html) {
     codeBlockStyle: 'fenced',
     emDelimiter: '*'
   });
+  // v3.17.8 D3: turndown's escape() covers Markdown punctuation only, so
+  // pasted TEXT that spells HTML came back as markup: `<b>x</b>` turned bold,
+  // `<!-- c -->` vanished, `&amp;` showed as `&`. A `<` that could open a tag,
+  // a comment or an autolink is written `&lt;`, and an `&` shaped like a
+  // character reference is written `\&` -- the spellings inline-md.js's
+  // escapeText() gives typed text. A bare `<` (`1 < 2`) or `&` (`AT&T`) is
+  // already shown as typed and stays bare. Code is not escaped by turndown
+  // at all, and needs none: a code span is literal.
+  var baseEscape = service.escape;
+  service.escape = function (s) {
+    return baseEscape.call(this, s)
+      .replace(/&(?=#?\w+;)/g, '\\&')
+      .replace(/<(?=[A-Za-z\/!?])/g, '&lt;');
+  };
   addStrikethroughRule(service);
   addFlankingEmphasisRules(service);
   addTableRules(service);

package/lib/editor/table-md.js

@@ -29,14 +29,14 @@
   // nothing to do with text alignment. Reading them as alignment would be a
   // bug; they are deliberately never consulted below.
   //
-  // ── Emission form (spec §4 / task-5 brief, amended by v3.0.1) ──────────
-  // There are TWO emission forms, and exactly one gate selects between them:
-  // whether serializeTable() was handed an `originalMd` it could turn into a
-  // usable width source (columnWidthsOf() parsed it, AND the greedy
-  // header-TEXT walk in serializeTable() matched EVERY original column, in
-  // order — the all-or-nothing gate). No second argument, an unparseable or
-  // ragged original, a renamed header, a dropped column: all of them land on
-  // form A.
+  // ── Emission form (spec §4 / task-5 brief, amended by v3.0.1, v3.17.8) ─
+  // There are TWO emission forms for the padding. Form B applies when
+  // serializeTable() was handed an `originalMd` it could turn into a width
+  // source: columnWidthsOf() parsed it (not ragged) and the forward header
+  // scan in serializeTable() found no MOVED column. Since v3.0.2 a renamed
+  // or dropped column no longer voids it; only that column loses its width.
+  // No second argument, an unparseable or ragged original, a moved column:
+  // all of them land on form A.
   //
   //   A. MINIMAL form (pre-v3.0.1, unchanged, and still what
   //      `serializeTable(tableEl)` with no second argument emits — byte for
@@ -60,18 +60,30 @@
   //      separators Prettier and VS Code emit ('| ----- | --- |') survive a
   //      no-op instead of being rebuilt flush ('|-------|-----|').
   //
-  // Independent of the form: a literal '|' inside
-  // a cell -> '&#124;'; a cell newline is the literal '<br>' inline-md.js's
+  // Cell bytes (v3.17.8 F1, both forms): a cell whose original field reads
+  // the same as its current content (see readsSame()) is written with the
+  // original field's bytes, trimmed; every other cell gets the canonical
+  // spelling below. A header row or body row whose cells were ALL reused, in
+  // the original columns, with no column widened past that line's own
+  // fields, is the original line itself (trimmed), odd padding like '|a|b|'
+  // included. Body rows are paired with original rows by pairBodyRows(), so a
+  // row inserted, deleted or moved leaves the others as they were. With no
+  // parser nothing is reused, and the output is what it was before v3.17.8.
+  //
+  // Canonical spelling: a literal '|' inside a cell's text -> '&#124;'; a
+  // cell newline is the literal '<br>' inline-md.js's
   // serializeInline() already emits for both a real <br> node and a
   // contenteditable <div> line-split boundary — AND (final-review Finding 1
   // defense-in-depth) any raw '\n'/'\r' that still reaches a text node is
   // collapsed to '<br>' here too, via escapeNewlines() below, so a cell can
   // never split serializeTable()'s output into more physical lines than
-  // it has rows. No trailing whitespace on any emitted line (every row/
-  // separator line is built as '|'-delimited fields, so it always ends in
-  // '|', never in whitespace, by construction). A '|' inside a <code> span
-  // is written as '\|' instead (v3.17.6) — see codePipesOf() below; the one
-  // code text that has no table spelling reports 'CODE' unsupported.
+  // it has rows. A '|' inside a <code> span is written as '\|' instead
+  // (v3.17.6) — see codePipesOf() below; the one code text that has no
+  // table spelling reports 'CODE' unsupported. A reused field never holds a
+  // newline or an unescaped '|' (it is one field of one source line). No
+  // trailing whitespace on any emitted line: a built row or separator is
+  // '|'-delimited fields, and an original line is trimmed and, to be read
+  // at all, ends in an unescaped '|' (splitFields()).
   //
   // Constrained (same as inline-md.js, and for the same reason: the node
   // test drives this with the hand-rolled element stub from
@@ -190,22 +202,35 @@
   // width of 3 is indistinguishable from this serializer's own minimal
   // form, which is exactly 3 on every row by construction).
   //
-  // Source THIS serializer produced holds '\|' only inside code spans (plain
-  // text gets '&#124;'), and a hand-written table may use '\|' anywhere, so
-  // the split must not break on an escaped delimiter.
+  // A hand-written table may use '\|' anywhere, and since v3.17.8 so may
+  // this serializer's output (a reused field keeps the author's '\|'), so
+  // the split must not break on an escaped delimiter. Escaped means what
+  // marked's splitCells() means (v3.17.8 F3): an ODD run of backslashes
+  // before the '|'. A backslash and the character after it are taken as one
+  // pair, so '\\|' is an escaped backslash and then a delimiter; before this
+  // the split read that '|' as escaped, the row came out one field short and
+  // the whole table lost its width memory. A line whose last '|' is escaped
+  // has no closing delimiter and is not a row this can read (see the end).
   function splitFields(line) {
     const t = line.trim();
-    if (t.charAt(0) !== '|' || t.charAt(t.length - 1) !== '|' || t.length < 2) return null;
-    const inner = t.slice(1, -1);
+    if (t.charAt(0) !== '|' || t.length < 2) return null;
     const out = [];
     let cur = '';
-    for (let i = 0; i < inner.length; i++) {
-      const c = inner.charAt(i);
-      if (c === '\\' && inner.charAt(i + 1) === '|') { cur += '\\|'; i += 1; continue; }
+    for (let i = 1; i < t.length; i++) {
+      const c = t.charAt(i);
+      if (c === '\\' && i + 1 < t.length) { cur += c + t.charAt(i + 1); i += 1; continue; }
       if (c === '|') { out.push(cur); cur = ''; continue; }
       cur += c;
     }
-    out.push(cur);
+    // A line whose last '|' is escaped (`| p | q \|`) has no closing
+    // delimiter: not a row this can read, so it is never reused and the table
+    // has no width memory. v3.17.8's final-review round 1 split it the old way
+    // instead (last '|' closes the row) to keep the width memory, and the
+    // re-review found that this loses an edit: the field ` q \` read alone is
+    // `q \`, but in its line it reads `q |`, so an edit from `q |` to `q \`
+    // read "the same" and the original line came back (N1). Width memory
+    // for such a rare table is not worth that.
+    if (cur !== '') return null;
     return out;
   }
 
@@ -254,6 +279,9 @@
     const uniform = widths.map(() => true);
     let sepFields = null;
     for (let r = 1; r < rows.length; r++) {
+      // A lazy body line (no '|' at all, v3.17.9 D7) has no fields and so no
+      // widths: it neither voids nor sets the table's width memory.
+      if (r >= 2 && rows[r].indexOf('|') === -1) continue;
       const fields = splitFields(rows[r]);
       // A ragged original is not a width source — bail rather than guess.
       if (!fields || fields.length !== widths.length) return null;
@@ -268,6 +296,304 @@
     return { widths, headerFields: first.map((f) => f.trim()), sepFields };
   }
 
+  // ── v3.17.8 F1: an untouched cell keeps its bytes ─────────────────────
+  // Every cell is serialized from the DOM, so a cell nobody edited comes
+  // back in this file's canonical spelling: a plain '[' as '\[', a
+  // plain-text '\|' as '&#124;'. The meaning is the same; the git diff is
+  // not. So a current cell reuses its ORIGINAL field (trimmed) when the two
+  // spellings READ the same, and that is decided by parsing, not by rules:
+  // a private `new Marked({ gfm: true, breaks: false })` (the same family as
+  // inline-md.js's getInlineParser(); server.js injects marked before the
+  // editor modules) renders each spelling as the one cell of a one-column
+  // table, and the two cell HTMLs are compared after character references
+  // in their text are decoded (marked passes '&#124;' through, the browser
+  // shows '|'). A cell is parsed once per string (readCache).
+  //
+  // The plain parser has none of md2doc's sub / sup / KaTeX extensions, so
+  // an original holding an unescaped '~', '^' or '$' is reused only when it
+  // is byte-equal to the canonical spelling (R5). No parser (a page without
+  // marked, or setCellParser(null)): nothing is reused and every byte is
+  // what the serializer wrote before v3.17.8.
+  let cellParser; // undefined: not looked up yet; null: none available
+  const readCache = new Map();
+  function getCellParser() {
+    if (cellParser !== undefined) return cellParser;
+    cellParser = null;
+    try {
+      let lib = null;
+      if (typeof module === 'object' && module.exports && typeof require === 'function') lib = require('marked');
+      else if (typeof self !== 'undefined' && self.marked) lib = self.marked;
+      if (lib && typeof lib.Marked === 'function') {
+        const m = new lib.Marked({ gfm: true, breaks: false });
+        cellParser = (s) => m.parse(s);
+      }
+    } catch (e) {
+      cellParser = null;
+    }
+    return cellParser;
+  }
+  // Tests swap the parser: a function (markdown -> HTML), null to switch
+  // reuse off, or nothing to go back to the lookup above.
+  function setCellParser(fn) {
+    cellParser = typeof fn === 'function' ? fn : (fn === null ? null : undefined);
+    readCache.clear();
+  }
+
+  const CELL_HEAD = '<table>\n<thead>\n<tr>\n<th>h</th>\n</tr>\n</thead>\n<tbody><tr>\n<td>';
+  const CELL_TAIL = '</td>\n</tr>\n</tbody></table>\n';
+  const NAMED_REF = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+  // A named reference outside NAMED_REF cannot be decoded here, so a cell
+  // holding one has no reading at all (final review I3): left as it was, the
+  // `&` was re-escaped and `&copy;` (shows ©) read the same as the typed
+  // text `\&copy;` (shows &copy;), so an edit to that text was overwritten
+  // by the original bytes. Such a cell is now reused only when byte-equal.
+  const UNKNOWN_REF = {};
+  function decodeRef(m, dec, hex, name) {
+    if (name !== undefined) {
+      if (NAMED_REF[name] !== undefined) return NAMED_REF[name];
+      throw UNKNOWN_REF;
+    }
+    const n = dec !== undefined ? parseInt(dec, 10) : parseInt(hex, 16);
+    return n === 0 || n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff) ? '�' : String.fromCodePoint(n);
+  }
+  // Text between tags: references decoded, then & < > " re-escaped, so two
+  // spellings of one character give one string. Tags are left as they are.
+  // HTML comments are dropped first: nothing shows them, the editor's DOM
+  // walk skips them (so the canonical spelling never has one), and
+  // inline-md.js's own read-back (htmlMarks()) skips them too. That keeps
+  // an untouched cell's comments, e.g. the `<!-- [[source, Cl.x]] -->`
+  // citation anchors in paperwork's hwe1 tables, which the canonical
+  // spelling would drop.
+  //
+  // v3.17.9 D7: a STRAY end tag (no start tag of that name earlier in the
+  // cell) is dropped too, for the same reason: the browser's parser ignores
+  // it, so the DOM never has it (`</content>` under a table). Kept, so the
+  // cell reads by its bytes as before: `</p>` and `</br>`, which the parser
+  // turns into an empty paragraph and a line break, and the table-structure
+  // names (some close the cell, some are ignored; keeping a tag only means
+  // the cell is reused when byte-equal, so the list errs on the safe side).
+  const STRAY_END_KEPT = /^(?:p|br|table|caption|colgroup|col|tbody|thead|tfoot|tr|td|th|template)$/;
+  function dropStrayEndTags(parts) {
+    const open = Object.create(null);
+    for (let i = 1; i < parts.length; i += 2) {
+      const m = /^<(\/?)([A-Za-z][A-Za-z0-9-]*)/.exec(parts[i]);
+      if (!m) continue;
+      const name = m[2].toLowerCase();
+      if (!m[1]) { open[name] = (open[name] || 0) + 1; continue; }
+      if (open[name]) { open[name] -= 1; continue; }
+      if (!STRAY_END_KEPT.test(name)) parts[i] = '';
+    }
+    return parts;
+  }
+  function normalizeCellHtml(html) {
+    return dropStrayEndTags(html.replace(/<!--[\s\S]*?-->/g, '').split(/(<[^>]*>)/)).map((part, i) => (i % 2 ? part : part
+      .replace(/&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|([A-Za-z][A-Za-z0-9]*));/g, decodeRef)
+      .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'))).join('');
+  }
+  // The normalized HTML of `field` as the one cell of a one-column table, or
+  // null when it is not read as exactly that (then it never reads the same
+  // as anything).
+  function cellReading(parse, field) {
+    if (readCache.has(field)) return readCache.get(field);
+    let v = null;
+    try {
+      const html = parse('| h |\n| - |\n| ' + field + ' |');
+      if (typeof html === 'string' && html.startsWith(CELL_HEAD) && html.endsWith(CELL_TAIL)) {
+        const inner = html.slice(CELL_HEAD.length, html.length - CELL_TAIL.length);
+        if (inner.indexOf('</td>') === -1) v = normalizeCellHtml(inner);
+      }
+    } catch (e) {
+      v = null;
+    }
+    // FIFO, not a clear: a table larger than the cap read itself cold on every
+    // commit when the whole cache was dropped (final review M1).
+    if (readCache.size >= READ_CACHE_MAX) readCache.delete(readCache.keys().next().value);
+    readCache.set(field, v);
+    return v;
+  }
+  const READ_CACHE_MAX = 100000;
+  // One string per cell such that readsSame(a, b) === (readingKey(a) ===
+  // readingKey(b)): a cell with a reading is keyed by it, one without by its
+  // bytes, so it only ever pairs with itself. pairBodyRows() hashes rows on it.
+  function readingKey(parse, x) {
+    if (!parse) return 'B' + x;
+    const r = cellReading(parse, x);
+    return r === null ? 'B' + x : 'R' + r;
+  }
+  function readsSame(parse, a, b) {
+    if (a === b) return true;
+    const ra = cellReading(parse, a);
+    return ra !== null && ra === cellReading(parse, b);
+  }
+  // '~' (sub), '^' (sup) or '$' (KaTeX) after an even backslash run (R5).
+  const EXTENSION_CHAR = /(?:^|[^\\])(?:\\\\)*[~^$]/;
+
+  // The original table's rows for reuse: { header, body } where `header` is
+  // { fields, line } and `body` holds one { fields, line } per body row, or
+  // null for a line splitFields() cannot read (it is then never paired).
+  // `line` is the source line trimmed. Unlike columnWidthsOf(), a ragged row
+  // does not void the table: reuse is decided per cell. null when there is
+  // no original or its header line is not a row.
+  //
+  // v3.17.9 D7: a body line with no '|' at all is still a row to marked (GFM:
+  // any non-blank line continues the table), e.g. a stray `</content>` right
+  // under a table. marked's splitCells() reads it as the whole line in the
+  // first cell and the rest empty, and so does this (`lazy: true`). Before
+  // this it was never paired, and an edit anywhere in the table rewrote it
+  // as `|  |  |`: the browser drops a stray end tag, so its cells are empty
+  // in the DOM. A line holding a '|' but not starting with one stays
+  // unreadable here, as before.
+  function originalRowsOf(originalMd) {
+    if (typeof originalMd !== 'string' || originalMd === '') return null;
+    const rows = originalMd.split('\n').filter((l) => l.trim() !== '');
+    if (rows.length < 2) return null;
+    const row = (l) => { const f = splitFields(l); return f ? { fields: f, line: l.trim() } : null; };
+    const header = row(rows[0]);
+    if (!header) return null;
+    const lazy = (l) => {
+      if (l.indexOf('|') !== -1) return null;
+      const fields = header.fields.map(() => '');
+      fields[0] = l.trim();
+      return { fields, line: l.trim(), lazy: true };
+    };
+    return { header, body: rows.slice(2).map((l) => row(l) || lazy(l)) };
+  }
+
+  // Pairs each current body row with an original body row (an index into
+  // `origBody`, or -1). A row "matches" when every mapped cell reads the
+  // same. (1) a forward greedy scan pairs matching rows in order — the
+  // anchors; (2) a row left over that matches some unused original anywhere
+  // is paired with it (a moved row); (3) the rows still left between two
+  // anchors are paired in order with the unused originals between the same
+  // anchors — that is an edited row, whose other cells are then reused one
+  // by one. A wrong pair only costs preserved bytes: every reuse is gated by
+  // readsSame() again, cell by cell.
+  // Linear in rows (final review M1: the scans were quadratic, 3000 rows
+  // that all differ took 3 s): each row is hashed on its mapped cells'
+  // readingKey(), so "matches" is one Map lookup.
+  // A lazy original (v3.17.9 D7) has no key through the column map: its
+  // cells are positions, not named columns, so it is matched by position
+  // (see `pos` below), in the file's order like every other row.
+  function pairBodyRows(curRows, origBody, colMap, keyOf) {
+    const mapped = [];
+    colMap.forEach((k, i) => { if (k !== undefined) mapped.push(i); });
+    const pair = new Array(curRows.length).fill(-1);
+    const SEP = '\u0000';
+    const origKey = origBody.map((o) => {
+      if (!o || o.lazy || mapped.length === 0) return null;
+      const parts = [];
+      for (let x = 0; x < mapped.length; x++) {
+        const f = o.fields[colMap[mapped[x]]];
+        if (f === undefined) return null;
+        parts.push(keyOf(f.trim()));
+      }
+      return parts.join(SEP);
+    });
+    const curKey = curRows.map((row) => mapped.map((i) => keyOf(row[i])).join(SEP));
+    // key -> { list: ascending original indices, p1: step-1 cursor, p2: step-2 cursor }
+    const byKey = new Map();
+    origKey.forEach((k, q) => {
+      if (k === null) return;
+      let e = byKey.get(k);
+      if (!e) { e = { list: [], p1: 0, p2: 0 }; byKey.set(k, e); }
+      e.list.push(q);
+    });
+    const used = new Array(origBody.length).fill(false);
+    const anchor = new Array(curRows.length).fill(false);
+    // A table with a lazy original (v3.17.9 D7) is first matched position by
+    // position over every cell: `pos` holds each original's positional key,
+    // lazy or not, and a row takes the first unused original at or after j
+    // whose every cell reads the same, before any match through the column
+    // map. Through the map a renamed header leaves few cells (or none) to
+    // match on, so an ordinary original whose mapped cells happen to match
+    // (all empty, say) could take the row a lazy line is in. Kept in the
+    // file's order (re-review round 3 C1): paired before everything else, a
+    // lazy line took the first row reading like it, and an ordinary row that
+    // read the same as a lazy line below it swapped lines with it on a no-op.
+    let pos = null;
+    let curPos = null;
+    const lazyAt = origBody.findIndex((o) => o && o.lazy);
+    if (lazyAt !== -1) {
+      const n = origBody[lazyAt].fields.length;
+      const posKey = (get) => Array.from({ length: n }, (_, i) => keyOf(get(i))).join(SEP);
+      pos = new Map();
+      origBody.forEach((o, q) => {
+        if (!o) return;
+        const k = posKey((i) => (o.fields[i] === undefined ? '' : o.fields[i].trim()));
+        let e = pos.get(k);
+        if (!e) { e = { list: [], p1: 0, p2: 0 }; pos.set(k, e); }
+        e.list.push(q);
+      });
+      curPos = curRows.map((row) => posKey((i) => (row[i] === undefined ? '' : row[i])));
+    }
+    // (1) forward greedy: the first unused match at or after j. Every original
+    // used in this step lies before j, so a cursor that skips indices < j
+    // finds it, and it only moves forward.
+    const firstFrom = (e) => {
+      if (!e) return -1;
+      while (e.p1 < e.list.length && e.list[e.p1] < j) e.p1++;
+      return e.p1 < e.list.length ? e.p1 : -1;
+    };
+    let j = 0;
+    for (let c = 0; c < curRows.length; c++) {
+      let e = pos ? pos.get(curPos[c]) : undefined;
+      let at = firstFrom(e);
+      if (at === -1) { e = byKey.get(curKey[c]); at = firstFrom(e); }
+      if (at === -1) continue;
+      const q = e.list[at];
+      e.p1 = at + 1;
+      pair[c] = q; used[q] = true; anchor[c] = true; j = q + 1;
+    }
+    // (2) a leftover row that matches an unused original anywhere (moved).
+    const firstUnused = (e) => {
+      if (!e) return -1;
+      while (e.p2 < e.list.length && used[e.list[e.p2]]) e.p2++;
+      return e.p2 < e.list.length ? e.list[e.p2++] : -1;
+    };
+    for (let c = 0; c < curRows.length; c++) {
+      if (pair[c] !== -1) continue;
+      let q = pos ? firstUnused(pos.get(curPos[c])) : -1;
+      if (q === -1) q = firstUnused(byKey.get(curKey[c]));
+      if (q !== -1) { pair[c] = q; used[q] = true; }
+    }
+    // (3) the rows still left between two anchors take the unused originals
+    // between the same anchors, in order.
+    const nextAnchorQ = new Array(curRows.length + 1);
+    nextAnchorQ[curRows.length] = origBody.length;
+    for (let c = curRows.length - 1; c >= 0; c--) nextAnchorQ[c] = anchor[c] ? pair[c] : nextAnchorQ[c + 1];
+    let q = 0;
+    for (let c = 0; c < curRows.length; c++) {
+      if (anchor[c]) { q = pair[c] + 1; continue; }
+      if (pair[c] !== -1) continue;
+      const nextQ = nextAnchorQ[c + 1];
+      while (q < nextQ && (used[q] || !origBody[q])) q++;
+      if (q < nextQ) { pair[c] = q; used[q] = true; q++; }
+    }
+    return pair;
+  }
+
+  // The contents a row is emitted with: each cell's original field where it
+  // may be reused, else its canonical content. `whole` is true when every
+  // cell was reused and the columns are the original's, in order — the row
+  // may then be the original line itself (decided at emission, once widths
+  // are known).
+  function reuseRow(parse, canon, cellBad, orig, colMap, nOrigCols) {
+    if (!orig) return { contents: canon, whole: false };
+    let whole = canon.length === orig.fields.length && canon.length === nOrigCols;
+    const contents = canon.map((c, i) => {
+      const k = colMap[i];
+      if (k !== i) whole = false;
+      const field = k === undefined ? undefined : orig.fields[k];
+      if (field === undefined || cellBad[i]) { whole = false; return c; }
+      const f = field.trim();
+      if (f === c) return c;
+      if (!EXTENSION_CHAR.test(f) && readsSame(parse, f, c)) return f;
+      whole = false;
+      return c;
+    });
+    return { contents, whole };
+  }
+
   // ' content ' right-padded out to `width`. NEVER truncates: a cell whose
   // content grew past the original column simply widens that column, and a
   // deliberately blank hand-aligned cell (e.g. `|     |` kept wide on
@@ -380,13 +706,22 @@
     // Render every cell's content up front (same order the pre-v3.0.1 code
     // walked: header first, then each body row left-to-right), so the width
     // pass below and the emission pass after it share one rendering.
-    const headerContents = headerCells.map((c) => cellContentOf(c, unsupported));
-    const bodyContentRows = bodyRows.map((tr) =>
-      elementChildren(tr).filter(isCell).map((c) => cellContentOf(c, unsupported)));
+    // `bad` marks a cell that reported unsupported: it is never reused, so a
+    // reuse can never stand in for (or hide) such a cell.
+    const cellOf = (c) => {
+      const before = unsupported.length;
+      const md = cellContentOf(c, unsupported);
+      return { md, bad: unsupported.length !== before };
+    };
+    const headerCellMd = headerCells.map(cellOf);
+    const bodyCellMd = bodyRows.map((tr) => elementChildren(tr).filter(isCell).map(cellOf));
+    // The canonical contents; replaced below by the reused ones (F1).
+    let headerContents = headerCellMd.map((x) => x.md);
+    let bodyContentRows = bodyCellMd.map((row) => row.map((x) => x.md));
 
     // Read the ORIGINAL widths first, then line each CURRENT header column
-    // up with the original column it corresponds to BY TEXT, not by raw
-    // index. A column inserted in the MIDDLE (insertColumn() in client.js)
+    // up with the original column it corresponds to BY TEXT (since v3.17.8,
+    // by how the text reads: `same` below), not by raw index. A column inserted in the MIDDLE (insertColumn() in client.js)
     // shifts every later column's index by one without changing what that
     // column actually is — matching by index alone would hand the shifted
     // column a stale neighbour's width, and the freshly-inserted empty
@@ -411,6 +746,17 @@
     // patch release carries. See test/table-width.test.js cases 14, 15, 20,
     // 21, 23 and 24, which pin every branch of the above.
     const original = columnWidthsOf(originalMd);
+    // F1: with a parser, names are compared by how they READ (a header
+    // spelled 'a\_b' in the file is the DOM's 'a_b'); without one, by bytes,
+    // as before. `src` is the original's rows for reuse (null: no reuse).
+    const parse = getCellParser();
+    const same = parse ? (a, b) => readsSame(parse, a, b) : (a, b) => a === b;
+    const src = parse ? originalRowsOf(originalMd) : null;
+    const origNames = original ? original.headerFields
+      : (src ? src.header.fields.map((f) => f.trim()) : null);
+    // colIdx[i]: the original column current column i was matched to.
+    const colIdx = new Array(headerContents.length);
+    let moved = false;
     let widths = null;
     // Set for a column that falls off the END of the original header list
     // (every original column has already been matched by the time this one
@@ -445,8 +791,7 @@
     //     separator did not actually change (F1, final review) — see the
     //     verbatim gate at the emission site.
     const matchedSepFields = new Array(headerContents.length);
-    if (original) {
-      const matched = new Array(headerContents.length);
+    if (origNames) {
       // v3.0.2: a FORWARD SCAN, not the pre-v3.0.2 lockstep compare. The
       // lockstep version left `j` parked on the first original column that
       // did not match, so it could never recover from one mismatch — and
@@ -460,15 +805,14 @@
       for (let i = 0; i < headerContents.length; i++) {
         const name = headerContents[i].trim();
         let k = -1;
-        for (let q = j; q < original.headerFields.length; q++) {
-          if (original.headerFields[q].trim() === name) { k = q; break; }
+        for (let q = j; q < origNames.length; q++) {
+          if (same(origNames[q].trim(), name)) { k = q; break; }
         }
         if (k >= 0) {
-          matched[i] = original.widths[k];
-          matchedSepFields[i] = original.sepFields[k];
+          colIdx[i] = k;
+          if (original) matchedSepFields[i] = original.sepFields[k];
           j = k + 1;
         } else {
-          matched[i] = undefined;
           // The EMPTY name is exempt from the reorder test below, and the
           // exemption is load-bearing, not defensive: insertColumn()
           // (lib/editor/client.js:6448-6465) creates a th (or td) with no
@@ -479,7 +823,7 @@
           // whole-table refusal — a straight regression against v3.0.1 on
           // the ordinary insert-a-column-twice flow.
           if (name !== '') unmatchedNames.push(name);
-          if (j >= original.headerFields.length) sepFallbackNatural[i] = true;
+          if (original && j >= origNames.length) sepFallbackNatural[i] = true;
         }
       }
       // A column that could not find itself in what remains of the original,
@@ -489,10 +833,56 @@
       // so it still discards the width source for the WHOLE table. A name
       // that is absent from the original entirely is an insert or a rename:
       // nothing stale to carry, so its neighbours keep their widths.
-      const moved = unmatchedNames.some((n) =>
-        original.headerFields.some((f) => f.trim() === n));
+      moved = unmatchedNames.some((n) =>
+        origNames.some((f) => same(f.trim(), n)));
+      // F1: the cells of a column the scan did not match (a moved one) are
+      // still reused when exactly one unmatched original column has its name.
+      // This feeds reuse only; the width refusal above stands.
+      if (src) {
+        const taken = new Set(colIdx.filter((k) => k !== undefined));
+        for (let i = 0; i < headerContents.length; i++) {
+          const name = headerContents[i].trim();
+          if (colIdx[i] !== undefined || name === '') continue;
+          const hits = [];
+          for (let q = 0; q < origNames.length; q++) {
+            if (!taken.has(q) && same(origNames[q].trim(), name)) hits.push(q);
+          }
+          if (hits.length === 1) { colIdx[i] = hits[0]; taken.add(hits[0]); }
+        }
+      }
+    }
+
+    // F1: reuse each untouched cell's original bytes (see reuseRow()), before
+    // the widths are settled, so the reused contents are what they measure.
+    let headerWhole = false;
+    const bodyWhole = bodyContentRows.map(() => false);
+    const bodyOrig = bodyContentRows.map(() => null);
+    if (src) {
+      const nOrigCols = src.header.fields.length;
+      const h = reuseRow(parse, headerContents, headerCellMd.map((x) => x.bad), src.header, colIdx, nOrigCols);
+      headerContents = h.contents;
+      headerWhole = h.whole;
+      const pair = pairBodyRows(bodyContentRows, src.body, colIdx, (x) => readingKey(parse, x));
+      // A lazy line's cells are positions in marked's split, not columns with
+      // a name, and its text is often in the file only (D7): a renamed header
+      // must not unmatch it. So it is mapped by position; every cell is still
+      // gated by readsSame(), so an edited cell is never overwritten.
+      const byPosition = headerContents.map((_, i) => (i < nOrigCols ? i : undefined));
+      bodyContentRows = bodyContentRows.map((canon, r) => {
+        const orig = pair[r] === -1 ? null : src.body[pair[r]];
+        const map = orig && orig.lazy ? byPosition : colIdx;
+        const b = reuseRow(parse, canon, bodyCellMd[r].map((x) => x.bad), orig, map, nOrigCols);
+        bodyWhole[r] = b.whole;
+        bodyOrig[r] = orig;
+        return b.contents;
+      });
+    }
+
+    if (original) {
       if (!moved) {
-        widths = matched;
+        // Not moved means the name rescue above found nothing (an unmatched
+        // name is absent from the original), so colIdx is the scan's alone.
+        widths = colIdx.map((k) => (k === undefined ? undefined : original.widths[k]));
         // A matched column is then widened, for every row of that column
         // at once (header + separator + every body row), to whatever the
         // grown content now needs — the padding floor rises but never
@@ -502,7 +892,9 @@
         // comparing a number against `undefined` is always false, so this
         // loop leaves it alone and padField()'s `|| 0` fallback below
         // gives it independent per-row minimal form instead.
-        const allRows = [headerContents].concat(bodyContentRows);
+        // A lazy line that is written as itself (D7) is no column's content.
+        const allRows = [headerContents].concat(bodyContentRows.filter((_, r) =>
+          !(bodyWhole[r] && bodyOrig[r] && bodyOrig[r].lazy)));
         for (let i = 0; i < widths.length; i++) {
           let needed = widths[i];
           allRows.forEach((row) => {
@@ -515,8 +907,15 @@
       }
     }
 
+    // F1: a row whose cells were all reused, in the original columns, is the
+    // original line itself (trimmed), padding and all, unless a column it
+    // holds was widened past that line's own field. A lazy line (D7) has no
+    // fields to pad, so it is always its own line.
+    const asWritten = (whole, orig) => whole && (orig.lazy || orig.fields.every((f, i) =>
+      !widths || widths[i] === undefined || widths[i] <= f.length));
     const lines = [];
-    lines.push(serializeRow(headerContents, widths));
+    lines.push(asWritten(headerWhole, src && src.header) ? src.header.line
+      : serializeRow(headerContents, widths));
     lines.push('|' + headerCells.map((c, i) => {
       // Preference order for a column's separator width:
       //   1. widths[i] — this column is a full hand-aligned width source
@@ -592,10 +991,11 @@
       return sepCellFor(align, w);
     }).join('|') + '|');
 
-    bodyContentRows.forEach((contents) => lines.push(serializeRow(contents, widths)));
+    bodyContentRows.forEach((contents, r) => lines.push(asWritten(bodyWhole[r], bodyOrig[r])
+      ? bodyOrig[r].line : serializeRow(contents, widths)));
 
     return { md: lines.join('\n'), unsupported };
   }
 
-  return { serializeTable };
+  return { serializeTable, setCellParser };
 });

package/lib/md2doc.js

@@ -233,6 +233,117 @@ try {
     ],
   });
 
+  // v3.17.9 D8: `[[ref-id, §sub]]` → a clickable citation, as an inline
+  // extension for the same reason as sub / sup above. It was a raw-text
+  // pre-pass over the whole file (mdPre), which rewrote it inside code spans,
+  // fenced code, HTML comments and tag attributes too: the code then showed
+  // the anchor's HTML as text, and the editor wrote that HTML back into the
+  // file on the first edit of the block. `text` is the anchor's visible text,
+  // escaped as the old html + text tokens were, so heading ids and the
+  // search index read the same strings as before. The body is literal: no
+  // bold / code / escapes inside a citation any more (the pre-pass left them
+  // to marked), which is what the editor writes back (isCitationEligible).
+  const escCiteAttr = (s) => String(s)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+  marked.use({
+    extensions: [{
+      name: 'citation',
+      level: 'inline',
+      // No start(): marked's inline text rule already stops before every
+      // `[`, and this tokenizer is tried there. A start() that searched the
+      // rest of the paragraph for `[[` ran once per text token (re-review
+      // round 3 C3: quadratic, a 32000-character paragraph of `[a] ` took 0.2 s).
+      tokenizer(src) {
+        const m = /^\[\[([^\]\n]+)\]\]/.exec(src);
+        if (!m) return undefined;
+        const body = m[1].trim();
+        return { type: 'citation', raw: m[0], body, slug: body.split(',', 1)[0].trim(),
+                 text: '[' + escCiteAttr(body) + ']' };
+      },
+      renderer(token) { return `<a href="#${escCiteAttr(token.slug)}">${token.text}</a>`; },
+    }],
+  });
+  // A citation inside a link label or an image alt: marked's label allows one
+  // nested bracket level and `[[...]]` is two, so `[see [[ref]]](#sec)` fell
+  // apart into text (the old pre-pass had removed one level first). Each
+  // citation in the label is masked as `\u0000[body]\u0000` (same length, one
+  // level), marked's own link tokenizer reads the masked text, and the link's
+  // raw / label come back from the real source: a link's label is re-lexed, so
+  // its citations render; an image's alt is the citations' visible text.
+  // A `[[` after an odd backslash run is escaped text, not a citation (the
+  // inline lexer reads `\[` as a literal bracket), so it is left unmasked.
+  // The mask is the regex /(\\*)\[\[([^\]\n]+)\]\]/g scanned by hand, in
+  // one pass (re-review round 3 C3): the tokenizer runs at every `[` of a
+  // paragraph, and the regex let each unclosed `[[` scan to the end of its
+  // line, so one 8000-character line of `[[a ` took 10 s. `stop` is the
+  // first `]` or newline at or after a body's start; it only moves forward.
+  const maskCitations = (s) => {
+    let out = '';
+    let from = 0;
+    let stop = -1;
+    for (let p = s.indexOf('[['); p !== -1; p = s.indexOf('[[', p)) {
+      if (stop < p + 2) {
+        stop = p + 2;
+        while (stop < s.length && s[stop] !== ']' && s[stop] !== '\n') stop++;
+      }
+      if (stop === p + 2 || s[stop] !== ']' || s[stop + 1] !== ']') { p++; continue; }
+      let bs = 0;
+      while (p - bs - 1 >= from && s[p - bs - 1] === '\\') bs++;
+      out += bs % 2 ? s.slice(from, stop + 2) : s.slice(from, p) + '\u0000[' + s.slice(p + 2, stop) + ']\u0000';
+      from = p = stop + 2;
+    }
+    return from ? out + s.slice(from) : s;
+  };
+  // Where the label of a link (or alt of an image) starting at `src` ends:
+  // the index of its closing `]`, or -1. marked's label allows escapes, code
+  // spans (at its own level only: inside a nested bracket a backtick is a
+  // plain character, re-review round 4) and one nested bracket level, and a
+  // masked citation is one level,
+  // so deeper than three raw levels is no label of marked's. Bounded so that
+  // a call costs about the distance to the next brackets: the tokenizer runs
+  // at the start of every token of a paragraph (re-review round 3 C3).
+  const labelEnd = (src) => {
+    const start = src[0] === '!' ? 1 : 0;
+    if (src[start] !== '[') return -1;
+    let depth = 0;
+    for (let i = start; i < src.length; i++) {
+      const ch = src[i];
+      if (ch === '\\') i++;
+      else if (ch === '`' && depth === 1) { const k = src.indexOf('`', i + 1); if (k !== -1) i = k; }
+      else if (ch === '[') { if (++depth > 3) return -1; }
+      else if (ch === ']') { if (--depth === 0) return i; }
+    }
+    return -1;
+  };
+  const defaultLink = marked.Tokenizer.prototype.link;
+  marked.use({ tokenizer: { link(src) {
+    // only an inline link or image whose label holds a `[[` is read here; a
+    // citation in its href or title stays literal (unmasked), as it is in a
+    // link whose label cites nothing (re-review round 3 C4)
+    const e = labelEnd(src);
+    if (e === -1 || src[e + 1] !== '(' || src.lastIndexOf('[[', e) === -1) return false;
+    const masked = maskCitations(src.slice(0, e + 1)) + src.slice(e + 1);
+    const tok = defaultLink.call(this, masked);
+    if (!tok || tok.raw.indexOf('\u0000') === -1) return false;
+    // a mask byte past the label means the scan disagreed with marked's
+    // label; leave the link to marked rather than leak the byte
+    if ((tok.href && tok.href.indexOf('\u0000') !== -1) || (tok.title && tok.title.indexOf('\u0000') !== -1)) return false;
+    tok.raw = src.slice(0, tok.raw.length);
+    if (tok.type === 'image') { tok.text = tok.text.replace(/\u0000/g, ''); return tok; }
+    // The label is lexed with its escapes in place (marked unescapes `\[`
+    // first, which would turn an escaped `\[[x]]` back into a citation).
+    const cap = this.rules.inline.link.exec(masked);
+    const label = src.substr(1, cap[1].length);
+    this.lexer.state.inLink = true;
+    tok.text = label.replace(/\\([\[\]])/g, '$1');
+    tok.tokens = this.lexer.inlineTokens(label);
+    this.lexer.state.inLink = false;
+    return tok;
+  } } });
+
   // $$…$$ (display) and $…$ (inline) math via KaTeX. marked tokenizes code
   // spans/fences first, so $ inside code stays literal; the extension's
   // default no-space-adjacency rules keep prose currency ($5 to $10) unrendered.
@@ -887,6 +998,14 @@ ${itemsHtml}
           if (item.type === 'codespan') {
             return unescapeHtml(item.text || '');
           }
+          // v3.17.9 D8: what the old [[...]] text pre-pass left here, an html
+          // token's markup plus the text, so classifyColumns() (it measures the
+          // markup: a citation column often reads as prose) and heading ids
+          // (stripHtmlTags() removes it) see the strings they always did. A
+          // patch release does not re-lay-out every table that cites.
+          if (item.type === 'citation') {
+            return '<a href="#' + item.slug + '">[' + item.body + ']</a>';
+          }
           if (item.tokens) {
             return flattenTokenText(item.tokens);
           }
@@ -1361,35 +1480,26 @@ ${itemsHtml}
     // concurrently, unlike the one-shot CLI).
     marked.setOptions({ gfm: true, breaks: false, renderer });
 
-    // Pre-process the remaining non-standard inline syntax before marked parses
-    const escAttr = (s) => String(s)
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;');
-    const mdPre = md
-      .replace(/\[\[([^\]\n]+)\]\]/g, (_, inner) => {  // [[ref-id, §sub]] → clickable citation
-        const body = inner.trim();
-        const slug = body.split(',', 1)[0].trim();
-        return `<a href="#${escAttr(slug)}">[${escAttr(body)}]</a>`;
-      });
+    // `[[ref-id, §sub]]` citations are the `citation` inline extension
+    // installed at require time (v3.17.9 D8); there is no text pre-pass, so
+    // marked reads the file's own bytes and the block map's lines are the
+    // file's lines.
 
     // A $$ block's TeX reaches the index through the blockKatex hook at the
     // top of the file, set only while this render's synchronous parse runs.
     if (opts.editMode) {
-      // Ranges are computed on mdPre. The [[...]] preprocessing above only
-      // replaces text within single lines and never adds/removes newlines,
-      // so line ranges stay valid against the ORIGINAL md the client holds
-      // (guarded by the '[[...]] must not shift lines' test).
+      // Ranges are computed on the file's own text (no pre-pass since
+      // v3.17.9), so they are the lines the client holds (still guarded by
+      // the '[[...]] must not shift lines' test).
       const { buildBlockMap } = require('./editor/blockmap.js');
-      blocks = buildBlockMap(mdPre).blocks;
+      blocks = buildBlockMap(md).blocks;
       // marked.lexer() inline-lexes as part of block lexing (verified against
       // marked 14.1.4: a paragraph token's `.tokens` already holds resolved
       // inline tokens such as `strong`/`link`, not raw text) — so
       // marked.parser([t]) on one already-lexed top-level token reproduces
       // exactly what the whole-document parse would emit for that token,
       // using the same renderer/options set above.
-      const tokens = marked.lexer(mdPre);
+      const tokens = marked.lexer(md);
       parts = [];
       // `v` is the block cursor; `prevLi`/`types` are the §3.8 run state the
       // flat list renderer above threads through its own recursion (see
@@ -1465,7 +1575,7 @@ ${itemsHtml}
     } else {
       try {
         blockMathText = appendSectionText;
-        bodyHtml = marked.parse(mdPre);
+        bodyHtml = marked.parse(md);
       } finally {
         blockMathText = null;
       }
@@ -6790,7 +6900,7 @@ ${usesDrawioMultiPage ? `  // v3.4.0 batch2 Task 6: wired through a NAMED, reusa
   // v3.4.0 §4: same short-circuit story for drawio. editMode already baked
   // every part above, so both calls below are no-ops there (no browser is
   // opened) — this is only load-bearing for the non-editMode
-  // `bodyHtml = marked.parse(mdPre)` path, which never went through the
+  // `bodyHtml = marked.parse(md)` path, which never went through the
   // per-part loop. `html` and `bodyHtml` share the same placeholders (html
   // embeds bodyHtml), so both bakes share one lazily-opened browser instead
   // of paying for two.

package/package.json

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