@helping-ai-workflow/md2doc 3.17.8 → 3.17.9

package/lib/editor/table-md.js

@@ -279,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;
@@ -361,8 +364,29 @@
   // 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 html.replace(/<!--[\s\S]*?-->/g, '').split(/(<[^>]*>)/).map((part, i) => (i % 2 ? part : part
+    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('');
   }
@@ -410,6 +434,15 @@
   // `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() !== '');
@@ -417,7 +450,13 @@
     const row = (l) => { const f = splitFields(l); return f ? { fields: f, line: l.trim() } : null; };
     const header = row(rows[0]);
     if (!header) return null;
-    return { header, body: rows.slice(2).map(row) };
+    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
@@ -432,14 +471,16 @@
   // 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);
-    if (mapped.length === 0) return pair;
     const SEP = '\u0000';
     const origKey = origBody.map((o) => {
-      if (!o) return null;
+      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]]];
@@ -459,26 +500,61 @@
     });
     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++) {
-      const e = byKey.get(curKey[c]);
-      if (!e) continue;
-      while (e.p1 < e.list.length && e.list[e.p1] < j) e.p1++;
-      if (e.p1 < e.list.length) {
-        const q = e.list[e.p1++];
-        pair[c] = q; used[q] = true; anchor[c] = true; j = q + 1;
-      }
+      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;
-      const e = byKey.get(curKey[c]);
-      if (!e) continue;
-      while (e.p2 < e.list.length && used[e.list[e.p2]]) e.p2++;
-      if (e.p2 < e.list.length) { const q = e.list[e.p2++]; pair[c] = q; used[q] = true; }
+      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.
@@ -787,9 +863,15 @@
       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 b = reuseRow(parse, canon, bodyCellMd[r].map((x) => x.bad), orig, colIdx, nOrigCols);
+        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;
@@ -810,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) => {
@@ -825,9 +909,10 @@
 
     // 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.
-    const asWritten = (whole, orig) => whole && orig.fields.every((f, i) =>
-      !widths || widths[i] === undefined || widths[i] <= f.length);
+    // 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(asWritten(headerWhole, src && src.header) ? src.header.line
       : serializeRow(headerContents, widths));

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