@helping-ai-workflow/md2doc 3.10.0 → 3.11.0

package/lib/editor/convert-md.js

@@ -91,19 +91,24 @@ function stripMarker(sourceLines, blockKind) {
   if (blockKind === 'li') {
     const m = src[0].match(LI_MARKER);
     if (!m) return { content: [], ok: false };
-    // A MULTI-LINE li refuses. The previous code flattened continuations with
-    // replace(/^\s+/, ''), which is exactly the guess the code branch below
-    // refuses to make for an indented code block -- and it silently destroys
-    // whatever structure the continuation carried (a nested fence, an indented
-    // sub-block). Today the \u00a74.1 gate refuses a multi-line li as an operation
-    // target before this is ever reached, so this is defence in depth; dead
-    // code in this repo has a history of later gaining a caller, and it must
-    // not be a mine when it does.
-    if (src.length > 1) return { content: [], ok: false };
     let first = src[0].slice(m[0].length);
     const box = first.match(TASK_BOX);
     if (box) first = first.slice(box[0].length);
-    return { content: [first], ok: true };
+    // v3.11: a MULTI-LINE li (a hard-wrapped item, or a hard break) converts
+    // too. Its continuation lines belong to the item's own paragraph — any
+    // nested block would have made the run unsupported and refused before
+    // this — so each loses exactly the item's CONTENT column (the marker's
+    // width: anything deeper keeps its relative indent) or, on a lazy line
+    // indented less than that, all of its leading whitespace. That is not the
+    // old blanket replace(/^\s+/, '') the code branch below refuses to guess
+    // with: an over-indented line keeps its extra columns.
+    const col = m[0].length;
+    const rest = src.slice(1).map((l) => {
+      let k = 0;
+      while (k < col && l.charAt(k) === ' ') k++;
+      return k === col ? l.slice(col) : l.replace(/^\s+/, '');
+    });
+    return { content: [first].concat(rest), ok: true };
   }
 
   if (blockKind === 'heading') {
@@ -160,7 +165,9 @@ function emitAs(content, target, opts) {
     // A heading is one line by definition. Joining is the only lossless move
     // available; splitting would make one gesture produce two blocks.
     const hashes = '#'.repeat(Number(target.slice(1)));
-    const text = body.join(' ');
+    // A multi-line body (a converted hard-wrapped item) becomes one heading
+    // line; trailing hard-break spaces would otherwise land mid-heading.
+    const text = body.length > 1 ? body.map((l) => l.trim()).join(' ') : body.join(' ');
     // An EMPTY heading emits no trailing space, or converting '##' to a
     // heading of the same level would rewrite the line to '## '.
     return [text === '' ? prefix + hashes : prefix + hashes + ' ' + text];

package/lib/editor/inline-md.js

@@ -106,6 +106,14 @@
 
   function serializeAnchor(node, unsupported) {
     const href = node.getAttribute('href');
+    // A raw HTML anchor (`<a id="ref-x"></a>`, NO href attribute) is not a
+    // markdown link: emitting '[label]()' for it erased the anchor on the
+    // first edit of its block. Unsupported, so the block keeps its source.
+    // An empty href ('' — from '[x]()') is still a link.
+    if (href === null) {
+      unsupported.push('A');
+      return '';
+    }
     const text = node.textContent;
     // citation: <a href="#slug">[body]</a> -> [[body]]
     if (href && href.charAt(0) === '#' && /^\[.*\]$/.test(text)) {

package/lib/editor/list-md.js

@@ -450,6 +450,15 @@
   // replace from rewriting lines the user never looked at.
   function serializeBlocks(blockEls, opts) {
     const carryOver = (opts && opts.carryOver) || null;
+    // v3.11 (batch-2 §6): `opts.blankBefore(blockEl, prevItemEl)` — true when a
+    // blank line separates this item from the item emitted before it. The
+    // CALLER decides (client.js reads it off the file: a loose list keeps the
+    // blank lines it had, and a new neighbour takes the spacing of the list it
+    // joins). The blank line gets a lineMeta entry with blockId null and
+    // `blank: true`, so
+    // `lineMeta.length === md.split('\n').length` still holds.
+    const blankBefore = (opts && typeof opts.blankBefore === 'function') ? opts.blankBefore : null;
+    let prevItemEl = null;
     const unsupported = [];
     const unsupportedByLi = [];
     const multiLineBlockIds = [];
@@ -586,8 +595,16 @@
         // keep. (isBlankBlockText() stays as-is for the block's own direct
         // children, where the template's inter-element whitespace can legally
         // be a single space with no newline.)
-        const inlineKids = [];
+        let inlineKids = [];
         allChildNodes(textEl).forEach((c) => { if (!isBlankText(c)) inlineKids.push(c); });
+        // v3.11 (batch-2 §6): a LOOSE item's surface is one <p> — its content
+        // is that paragraph's, and the blank lines that made the list loose
+        // are restated between items (opts.blankBefore below), not carried by
+        // the <p>. Two or more <p> (a multi-paragraph item) still reach the
+        // inline serializer whole and stay unsupported.
+        if (inlineKids.length === 1 && inlineKids[0].nodeType === 1 && inlineKids[0].nodeName === 'P') {
+          inlineKids = allChildNodes(inlineKids[0]);
+        }
         const res = inlineMd.serializeInline({ childNodes: inlineKids });
         itemMd = res.md;
         res.unsupported.forEach((u) => innerUnsupported.push(u));
@@ -709,6 +726,14 @@
       // Round 6: join an open task prefix (above) to this line, dropping the
       // columns it already wrote; then, if THIS item is itself a content-free
       // task item, become the prefix instead of emitting.
+      // A line joined onto an open task prefix is the same physical line, so
+      // it never takes a blank in front of it.
+      const blankHere = !pending && lines.length > 0 && !!blankBefore && !!blankBefore(blockEl, prevItemEl);
+      prevItemEl = blockEl;
+      if (blankHere) {
+        lines.push('');
+        lineMeta.push({ blockId: null, indentPrefix: '', marker: '', blank: true });
+      }
       let head = indentPrefix + marker;
       // `indentPrefix` in lineMeta is the text PHYSICALLY standing before this
       // line's own marker. Normally that is the accumulated width; on a line a

package/lib/md2doc.js

@@ -360,10 +360,14 @@ function renderEditModeList(listToken, blocks, biRef, out) {
     const runStart = liRunStartsHere(biRef, b) ? ' data-run-start="1"' : '';
     const listStartAttr = listStart ? ' data-list-start="1"' : '';
     listStart = false;
+    // v3.11 (batch-2 §6): marked's own looseness for this list token, read
+    // by the lexer off the source (a blank line between items). The editor
+    // gives a NEW neighbour in this list the same spacing.
+    const looseAttr = listToken.loose ? ' data-list-loose="1"' : '';
     parts.push(
       `<div class="ed-block" data-block-id="${b.id}" data-block-type="li"` +
       ` data-list-type="${b.listType}" data-task="${b.task ? 1 : 0}" data-indent="${b.indent}"` +
-      runStart + listStartAttr + ` style="--ed-indent:${b.indent}">` +
+      runStart + listStartAttr + looseAttr + ` style="--ed-indent:${b.indent}">` +
       `<span class="ed-li-marker" aria-hidden="true"></span>` + check +
       `<div class="ed-li-text">${inner}</div>` +
       `</div>`

package/package.json

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