@helping-ai-workflow/md2doc 3.17.2 → 3.17.3

package/lib/editor/blockmap.js

@@ -374,13 +374,73 @@ function pushListItemBlocks(listToken, cursor, indent, blocks, nextId, inherited
   }
 }
 
+// v3.17.3 N2 (R36): LINK REFERENCE DEFINITIONS LEAVE NO TOKEN. marked's lexer
+// consumes '[r]: http://u' (its trailing blank lines included: the rule ends in
+// `\n+`) into `tokens.links` and pushes nothing, so the cursor never advanced
+// over those lines and every later block named a line above its own. Typing X
+// at the end of 'P.' in '# D\n\nA.\n\n[r]: http://u\n\nP.\n' wrote
+// '# D\n\nA.\n\nP.X\n\nP.\n': the definition was replaced and the old 'P.'
+// left behind.
+//
+// So at every top-level boundary that sits at a line start, marked's own
+// definition rule is asked whether a definition begins there, and each one it
+// matches is stepped over (several in a row, a title on its own line). That is
+// the lexer's decision, not a lookalike: at a boundary the lexer reaches `def`
+// only after space, indented code, fences, heading, hr, blockquote, list and
+// html have all declined, and none of those can start on a line whose first
+// character after at most three spaces is '['. Where the rule matches, the
+// lexer took a definition. A boundary inside a line (after a paragraph whose
+// raw ends without its newline) is never tested: the source there starts with
+// '\n', which no definition matches, and testing from the line start would
+// re-read the paragraph's own last line. A definition inside a list item or a
+// blockquote needs nothing here: those raws are faithful slices that already
+// contain its lines.
+const DEF_RULES = marked.Lexer.rules.block;
+function definitionRule() {
+  const o = marked.defaults;
+  return (o.pedantic ? DEF_RULES.pedantic : o.gfm ? DEF_RULES.gfm : DEF_RULES.normal).def;
+}
+// The dropped definitions that start at line `line`: how many lines they take
+// (their trailing blank lines included) and which of those lines hold text.
+function droppedDefinitions(text, lineStarts, line, rule) {
+  let skipped = 0;
+  const textLines = [];
+  while (line + skipped <= lineStarts.length) {
+    const m = rule.exec(text.slice(lineStarts[line + skipped - 1]));
+    if (!m) break;
+    const parts = m[0].split('\n');
+    if (parts.length === 1) break; // a definition at EOF: no block follows it
+    parts.slice(0, -1).forEach((l, k) => { if (l.trim() !== '') textLines.push(line + skipped + k); });
+    skipped += parts.length - 1;
+  }
+  return { skipped, textLines };
+}
+
 function buildBlockMap(mdText) {
   const tokens = marked.lexer(mdText);
   const blocks = [];
   let cursor = 1; // current line number of the token's first character
   const nextId = { v: 0 };
+  // The lexer reads '\r\n' as '\n'; so does the definition rule. Same line count.
+  const text = mdText.replace(/\r\n/g, '\n');
+  const lineStarts = [0];
+  for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1)) lineStarts.push(i + 1);
+  const defRule = definitionRule();
+  let atLineStart = true;
+  // v3.17.3 N2b (R54): the text lines of the definitions dropped since the
+  // last block, handed to the next block as `defLinesAbove` (distances above
+  // its startLine, nearest last). No block owns them, and the client's range
+  // helpers keep them when a gesture rewrites a range that spans them.
+  let pendingDefLines = [];
   for (const t of tokens) {
+    if (atLineStart) {
+      const d = droppedDefinitions(text, lineStarts, cursor, defRule);
+      cursor += d.skipped;
+      pendingDefLines = pendingDefLines.concat(d.textLines);
+    }
+    atLineStart = t.raw.charAt(t.raw.length - 1) === '\n';
     const info = topLevelLineInfo(t);
+    const firstNew = blocks.length;
     if (t.type === 'list') {
       pushListItemBlocks(t, cursor, 0, blocks, nextId);
     } else if (t.type !== 'space') {
@@ -396,6 +456,11 @@ function buildBlockMap(mdText) {
     // text-based count instead — see its own comment for why.
     // If raw has no trailing newline (EOF), the next token doesn't exist,
     // so the off-by-one is unobservable.
+    if (pendingDefLines.length && blocks.length > firstNew) {
+      const b = blocks[firstNew];
+      b.defLinesAbove = pendingDefLines.map((l) => b.startLine - l);
+      pendingDefLines = [];
+    }
     cursor += info.rawNewlines;
   }
   return { blocks, lineCount: mdText.split('\n').length };