@helping-ai-workflow/md2doc 3.13.0 → 3.14.0

package/lib/editor/inline-md.js

@@ -47,6 +47,50 @@
     return out;
   }
 
+  // v3.13.1 T2 (F-1): text a person typed at the start of a paragraph or
+  // list-item line that a renderer would read as a block marker. Measured
+  // before this: typing `## `, `- `, `> ` or `1. ` at a paragraph start saved
+  // the line unescaped, and the next render silently turned the paragraph
+  // into a heading, list or quote.
+  //
+  // Input is escapeText() output, possibly several lines (a hard break's
+  // backslash-newline, or a lazy continuation). Each line, after up to three
+  // spaces of indent, gets the FIRST matching rule below; nothing else is
+  // touched. The list is the decision:
+  //   ATX heading      `#`..`######` then space/tab/end   -> `\#…`
+  //   bullet           `-` or `+` then space/tab/end      -> `\-…` / `\+…`
+  //   blockquote       `>` (no space needed)              -> `\>…`
+  //   ordered          1-9 digits, `.` or `)`, space/end  -> `1\.` / `1\)`
+  //   setext/rule      a run of `=` or of `-`, alone      -> `\===` / `\---`
+  //   spaced rule      3+ `-` with spaces between, alone  -> `\-- -`
+  //   table row        `|`                                -> `\|…`
+  // `*`, `_`, backtick, `~`, `<` and `[` never get here unescaped
+  // (escapeText()). A line whose first character is `\` matches nothing,
+  // which is what keeps already-escaped text byte-stable. `-5 dBm` and
+  // `1.5 V` match nothing either: the marker must be followed by a space, a
+  // tab or the end of the line. Indented code (4+ spaces) is out of scope.
+  const BLOCK_START_RULES = [
+    { re: /^#{1,6}(?=[ \t]|$)/, fix: (rest) => '\\' + rest },
+    { re: /^[-+](?=[ \t]|$)/, fix: (rest) => '\\' + rest },
+    { re: /^>/, fix: (rest) => '\\' + rest },
+    { re: /^(\d{1,9})([.)])(?=[ \t]|$)/, fix: (rest) => rest.replace(/^(\d{1,9})([.)])/, '$1\\$2') },
+    { re: /^(=+|-+)[ \t]*$/, fix: (rest) => '\\' + rest },
+    // A thematic break may have spaces between its dashes (`-- -`,
+    // `----  -`); the run rule above only sees an unbroken one.
+    { re: /^-(?:[ \t]*-){2,}[ \t]*$/, fix: (rest) => '\\' + rest },
+    { re: /^\|/, fix: (rest) => '\\' + rest },
+  ];
+  function escapeBlockStarts(md) {
+    return String(md).split('\n').map((line) => {
+      const ind = /^ {0,3}/.exec(line)[0];
+      const rest = line.slice(ind.length);
+      for (let i = 0; i < BLOCK_START_RULES.length; i++) {
+        if (BLOCK_START_RULES[i].re.test(rest)) return ind + BLOCK_START_RULES[i].fix(rest);
+      }
+      return line;
+    }).join('\n');
+  }
+
   // Real contenteditable output wraps plain runs in attribute-less <span>s
   // (Chrome/Firefox formatting artifacts). Those are transparent. A <span>
   // carrying any of these attributes is a real style/class/behavior carrier
@@ -223,6 +267,10 @@
   // STRONG, DEL/S, U, the citation label) only ever needs `.md`, because
   // its own outer delimiter is a fixed, known tag regardless of what's
   // nested inside.
+  function markIsSearchHit(node) {
+    if (typeof node.getAttribute !== 'function') return false;
+    return (' ' + (node.getAttribute('class') || '') + ' ').indexOf(' search-hit ') !== -1;
+  }
   function walkChildren(nodes, unsupported) {
     let out = '';
     let firstSegment = true;
@@ -248,6 +296,15 @@
         firstSegment = false;
         continue;
       }
+      if (name === 'MARK' && markIsSearchHit(node)) {
+        // v3.14.0 T9: the reader's search paints its hits as this element and
+        // it is transient, so it serializes as what it wraps.
+        const inner = walkChildren(node.childNodes, unsupported);
+        out += inner.md;
+        if (inner.md.length) lastMarkTag = inner.lastMarkTag;
+        firstSegment = false;
+        continue;
+      }
       if (name === 'SPAN') {
         if (spanHasAttributes(node)) {
           unsupported.push(name);
@@ -312,6 +369,14 @@
         firstSegment = false;
         continue;
       }
+      if (name === 'BR' && typeof node.getAttribute === 'function' &&
+          node.getAttribute('data-ed-tail') === '1') {
+        // v3.14.0 T8: the editor's tail <br> (insertBrAtCaret() in client.js)
+        // only gives a line break at the end of a surface a line to stand on.
+        // It is not content: nothing written, and like an empty text node it
+        // leaves lastMarkTag / firstSegment as they were.
+        continue;
+      }
       if (name === 'BR') {
         // Spec §3.12. Two different things arrive here as the same element:
         //   * a <br> the EDIT-MODE renderer marked (lib/md2doc.js's
@@ -358,5 +423,5 @@
     return serializeInline(rootEl).unsupported.length === 0;
   }
 
-  return { serializeInline, canWysiwyg, escapeText };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts };
 });

package/lib/editor/list-md.js

@@ -224,7 +224,9 @@
 
       // strip leading whitespace left behind by a dropped leading element
       // (e.g. a checkbox <input>) — see header note.
-      const itemMd = rawItemMd.replace(/^[ \t]+/, '');
+      // v3.13.1 T2 (F-1): text that begins with a block marker is escaped,
+      // or the item's own text would re-lex as a nested heading/list/quote.
+      const itemMd = inlineMd.escapeBlockStarts(rawItemMd.replace(/^[ \t]+/, ''));
 
       // Two-part marker: bullet (ordered ordinal or plain '- ') and an
       // optional checkbox prefix. The two parts are independent so that
@@ -617,6 +619,11 @@
         // zero-width character it never asked for, and the item would stop
         // reading as empty to every `itemMd === ''` test in this function.
         if (SETEXT_ESCAPE_RE.test(itemMd)) itemMd = '';
+        // v3.13.1 T2 (F-1): an item whose text begins with `## `, `- `, `> `,
+        // `1. ` (…) is written escaped, or the next render reads it as a
+        // nested block. Only re-serialized items get here; a bystander
+        // replayed from its source lines never does.
+        itemMd = inlineMd.escapeBlockStarts(itemMd);
       }
 
       // Anything in the block that is neither chrome nor the text surface is

package/lib/editor/toolbar-model.js

@@ -101,7 +101,7 @@ const MARK_IDS = Object.freeze(Object.keys(MARK_TAG_BY_ID));
 //   'inert'   pressing the button would do nothing at all
 
 // ctx: {blockType, indent, headingDepth, inList, listOrdered, hasSelection,
-//       marks, dirty}
+//       marks, dirty, transient}
 // -> { [id]: {active: bool, mixed: bool, disabled: bool, label?: string} }
 function deriveState(ctx) {
   const c = ctx || {};
@@ -151,6 +151,16 @@ function deriveState(ctx) {
   // primary case (spec review ruling: gating it on inList made it dead for
   // that case).
 
+  // v3.14.0 T4 (D15): an EMPTY transient paragraph has no text to convert, so
+  // the conversions that wrap existing text (quote, numbered list, check) and
+  // the list-depth buttons stay off until it has some. ctx.transient is
+  // 'empty' | 'text' | null; the client derives it from the DOM.
+  if (c.transient === 'empty') {
+    for (const id of ['quote', 'ordered-list', 'check', 'indent', 'outdent']) {
+      state[id].disabled = true;
+    }
+  }
+
   // No block at all (rerenderAll's zeroed state): everything disabled except
   // the handful of buttons that don't depend on having a focused block.
   if (!hasBlock) {