fix: use marker-width indent for ordered-list continuation (#80)

Author: harlan-zw

crates/core/src/convert.rs

@@ -18,8 +18,6 @@ static HEADING_PREFIXES: [&str; 6] = ["# ", "## ", "### ", "#### ", "##### ", "#
 
 /// Pre-computed blockquote prefixes for depths 1-6 (avoids `"> ".repeat()`)
 static BQ_PREFIXES: [&str; 7] = ["", "> ", "> > ", "> > > ", "> > > > ", "> > > > > ", "> > > > > > "];
-/// Pre-computed unordered list item prefixes for indent depths 0-5
-static UL_PREFIXES: [&str; 6] = ["- ", "  - ", "    - ", "      - ", "        - ", "          - "];
 
 // Clean mode bitmask flags
 const CLEAN_EMPTY_LINKS: u8 = 1;
@@ -247,6 +245,16 @@ pub struct ConvertState {
     in_heading: bool,
     /// Buffer position at heading start (for extracting heading text)
     heading_buffer_start: usize,
+
+    /// Cumulative indent string for list-item continuation content. Grows by
+    /// each ancestor `<li>`'s marker width (`"- "` = 2, `"N. "` = digits(N)+2),
+    /// so code blocks, paragraphs, and nested blocks inside a list item land
+    /// in the content column that CommonMark requires. Pushed on `<li>` enter,
+    /// popped on `<li>` close.
+    list_indent: String,
+    /// Per-`<li>` contribution width stack, parallel to `list_indent`. Used to
+    /// truncate the correct number of bytes on close without re-walking ancestors.
+    list_indent_widths: Vec<u8>,
 }
 
 impl ConvertState {
@@ -322,6 +330,9 @@ impl ConvertState {
             fragment_links: Vec::new(),
             in_heading: false,
             heading_buffer_start: 0,
+
+            list_indent: String::new(),
+            list_indent_widths: Vec::with_capacity(8),
         };
         // Resolve clean config into bitmask
         let effective_clean_urls;
@@ -968,36 +979,33 @@ impl ConvertState {
             return;
         }
 
-        // Indent code block content inside a list item so the fenced block stays
-        // within the list item's content column. Skip indent for blank lines and
-        // lines that already begin with whitespace — preserves the original
-        // indentation structure from the HTML and matches the JS engine.
+        // Indent code block content inside a list item so every line starts at
+        // the list item's content column. CommonMark closes the list item when
+        // a line is indented less than that column, so we prepend list_indent
+        // on top of any existing in-source indentation. Blank lines are left
+        // alone so they stay blank.
         let li_depth = self.depth_map[TAG_LI as usize] as usize;
         let indented_storage;
         let text = if self.depth_map[TAG_PRE as usize] > 0 && li_depth > 0
             && (text.contains('\n') || last_char == b'\n') {
-            let indent = "  ".repeat(li_depth);
+            let indent = self.list_indent.as_str();
             let mut out = String::with_capacity(text.len() + indent.len() * 2);
             let bytes = text.as_bytes();
             // Prepend indent for the first line when the buffer ended with a
-            // newline (code fence opener) and this text doesn't already start
-            // with leading whitespace.
+            // newline (code fence opener). Blank first line stays blank.
             if last_char == b'\n' {
                 let first = bytes.first().copied().unwrap_or(0);
-                if first != b' ' && first != b'\t' && first != b'\n' {
-                    out.push_str(&indent);
+                if first != b'\n' && first != 0 {
+                    out.push_str(indent);
                 }
             }
             let mut prev = 0usize;
             for (i, &b) in bytes.iter().enumerate() {
                 if b == b'\n' {
                     out.push_str(&text[prev..=i]);
                     let next = i + 1;
-                    if next < bytes.len() {
-                        let c = bytes[next];
-                        if c != b' ' && c != b'\t' && c != b'\n' {
-                            out.push_str(&indent);
-                        }
+                    if next < bytes.len() && bytes[next] != b'\n' {
+                        out.push_str(indent);
                     }
                     prev = next;
                 }
@@ -1104,8 +1112,7 @@ impl ConvertState {
                         "> ".repeat(depth)
                     };
                     if self.depth_map[TAG_LI as usize] > 0 {
-                        let indent = "  ".repeat(self.depth_map[TAG_LI as usize] as usize);
-                        prefix = format!("\n{indent}{prefix}");
+                        prefix = format!("\n{}{}", self.list_indent, prefix);
                     }
                     Some(Cow::Owned(prefix))
                 }
@@ -1115,14 +1122,14 @@ impl ConvertState {
                     let lang = Self::get_language_from_class(node.attributes.get("class"));
                     let li_depth = self.depth_map[TAG_LI as usize] as usize;
                     if li_depth > 0 {
-                        let indent = "  ".repeat(li_depth);
+                        let indent = self.list_indent.as_str();
                         let mut s = String::with_capacity(2 + indent.len() * 2 + 4 + lang.len() + 1);
                         s.push_str("\n\n");
-                        s.push_str(&indent);
+                        s.push_str(indent);
                         s.push_str("```");
                         s.push_str(lang);
                         s.push('\n');
-                        s.push_str(&indent);
+                        s.push_str(indent);
                         Some(Cow::Owned(s))
                     } else if lang.is_empty() {
                         Some(Cow::Borrowed("```\n"))
@@ -1170,23 +1177,21 @@ impl ConvertState {
                 if self.in_table_cell() {
                     return Some(Cow::Borrowed("<li>"));
                 }
-                let ul_depth = self.depth_map[TAG_UL as usize] as usize;
-                let ol_depth = self.depth_map[TAG_OL as usize] as usize;
-                let depth = if ul_depth + ol_depth > 0 { ul_depth + ol_depth - 1 } else { 0 };
-                let is_ordered = ol_depth > 0 && _ancestors.last().is_some_and(|p| p.tag_id == Some(TAG_OL));
-                if !is_ordered && depth < UL_PREFIXES.len() {
-                    Some(Cow::Borrowed(UL_PREFIXES[depth]))
+                // Parent determines marker: <ol> → "N. " (digits of N + 2
+                // columns), else "- " (2 columns). The indent emitted here is
+                // the parent's accumulated list_indent — this LI's own marker
+                // contribution is pushed onto list_indent AFTER this output
+                // is written to the buffer.
+                let is_ordered = _ancestors.last().is_some_and(|p| p.tag_id == Some(TAG_OL));
+                let mut s = String::with_capacity(self.list_indent.len() + 6);
+                s.push_str(&self.list_indent);
+                if is_ordered {
+                    use std::fmt::Write;
+                    let _ = write!(s, "{}. ", node.index + 1);
                 } else {
-                    let mut s = String::with_capacity(depth * 2 + 6);
-                    for _ in 0..depth { s.push_str("  "); }
-                    if is_ordered {
-                        use std::fmt::Write;
-                        let _ = write!(s, "{}. ", node.index + 1);
-                    } else {
-                        s.push_str("- ");
-                    }
-                    Some(Cow::Owned(s))
+                    s.push_str("- ");
                 }
+                Some(Cow::Owned(s))
             }
             TAG_A => {
                 if node.attributes.contains_key("href") { Some(Cow::Borrowed("[")) } else { None }
@@ -1273,12 +1278,12 @@ impl ConvertState {
                 if self.depth_map[TAG_PRE as usize] > 0 {
                     let li_depth = self.depth_map[TAG_LI as usize] as usize;
                     if li_depth > 0 {
-                        let indent = "  ".repeat(li_depth);
+                        let indent = self.list_indent.as_str();
                         let mut s = String::with_capacity(1 + indent.len() * 2 + 5);
                         s.push('\n');
-                        s.push_str(&indent);
+                        s.push_str(indent);
                         s.push_str("```\n\n");
-                        s.push_str(&indent);
+                        s.push_str(indent);
                         Some(Cow::Owned(s))
                     } else {
                         Some(Cow::Borrowed("\n```"))
@@ -1838,6 +1843,35 @@ impl ConvertState {
             self.emit_enter_element();
         }
 
+        // After the LI prefix is emitted, push this LI's marker-width worth of
+        // spaces to list_indent so subsequent continuation content (code blocks,
+        // paragraphs, nested blocks) lands in the correct content column. The
+        // width depends on the marker: "- " = 2, "N. " = digits(N) + 2.
+        // Push for every LI open so close_node can pop unconditionally; width 0
+        // when skipped or in a table cell keeps the stack balanced without
+        // affecting the indent string.
+        if tag_id == Some(TAG_LI)
+            && let Some(li) = self.stack.last()
+        {
+            let width: usize = if !skip_node && !self.in_table_cell() {
+                let stack_len = self.stack.len();
+                let parent_is_ordered = stack_len >= 2
+                    && self.stack[stack_len - 2].tag_id == Some(TAG_OL);
+                if parent_is_ordered {
+                    let n = li.index + 1;
+                    // n >= 1 so ilog10 never panics; +1 converts floor(log10) to digit count.
+                    let digits = (n.ilog10() + 1) as usize;
+                    digits + 2
+                } else {
+                    2
+                }
+            } else {
+                0
+            };
+            self.list_indent_widths.push(u8::try_from(width).unwrap_or(u8::MAX));
+            for _ in 0..width { self.list_indent.push(' '); }
+        }
+
         self.has_encoded_html_entity = false;
 
         if self.stack.last().is_some_and(|n| n.is_non_nesting) && !self_closing {
@@ -1924,6 +1958,12 @@ impl ConvertState {
                         self.depth_map[id as usize] = self.depth_map[id as usize].saturating_sub(1);
                     }
                     self.update_escape_ctx_on_close(id);
+                    if id == TAG_LI
+                        && let Some(w) = self.list_indent_widths.pop()
+                    {
+                        let new_len = self.list_indent.len().saturating_sub(w as usize);
+                        self.list_indent.truncate(new_len);
+                    }
                 }
                 self.depth -= 1;
                 self.has_encoded_html_entity = false;
@@ -1945,6 +1985,12 @@ impl ConvertState {
                 self.depth_map[id as usize] = self.depth_map[id as usize].saturating_sub(1);
             }
             self.update_escape_ctx_on_close(id);
+            if id == TAG_LI
+                && let Some(w) = self.list_indent_widths.pop()
+            {
+                let new_len = self.list_indent.len().saturating_sub(w as usize);
+                self.list_indent.truncate(new_len);
+            }
         }
 
         self.in_non_nesting = self.stack.last().is_some_and(|n| n.is_non_nesting);

crates/core/tests/conversion.rs

@@ -224,9 +224,12 @@ fn nested_unordered_list() {
 
 #[test]
 fn nested_ordered_list() {
+    // Nested ordered lists require 3-space continuation indent (length of
+    // the outer "1. " marker) so CommonMark parses the inner list as nested
+    // rather than as peer items of the outer.
     assert_eq!(
         convert("<ol><li>Level 1<ol><li>Level 1.1</li></ol></li><li>Level 2</li></ol>"),
-        "1. Level 1\n  1. Level 1.1\n2. Level 2"
+        "1. Level 1\n   1. Level 1.1\n2. Level 2"
     );
 }
 
@@ -238,9 +241,48 @@ fn mixed_nested_lists() {
     );
 }
 
+#[test]
+fn ordered_list_with_code_block_uses_marker_width_indent() {
+    // Ordered list continuation must be indented by the marker width
+    // (3 columns for "1. ") so the fenced code block parses as part of the
+    // list item. 2-space indent would dump the code block outside the list.
+    let html = "<ol><li><p>x</p><pre><code>y</code></pre><p>z</p></li></ol>";
+    assert_eq!(
+        convert(html),
+        "1. x\n\n   ```\n   y\n   ```\n\n   z"
+    );
+}
+
+#[test]
+fn ordered_list_double_digit_marker_uses_wider_indent() {
+    // Once the marker reaches 2 digits ("10. " = 4 columns), continuation
+    // indent must widen to match.
+    let html = "<ol>\
+        <li>a</li><li>b</li><li>c</li><li>d</li><li>e</li>\
+        <li>f</li><li>g</li><li>h</li><li>i</li>\
+        <li>j<ol><li>nested</li></ol></li></ol>";
+    let md = convert(html);
+    assert!(md.ends_with("10. j\n    1. nested"),
+        "expected 4-space indent before nested item, got: {md:?}");
+}
+
+#[test]
+fn nested_ul_inside_ol_uses_ordered_parent_indent() {
+    // <ol><li><ul><li>inner</li></ul></li></ol>: the inner "- " must be
+    // indented by the outer "1. " width (3), not 2.
+    let html = "<ol><li>outer<ul><li>inner</li></ul></li></ol>";
+    assert_eq!(
+        convert(html),
+        "1. outer\n   - inner"
+    );
+}
+
 // https://github.com/harlan-zw/mdream/issues/77
 #[test]
-fn loose_ordered_list_items_separated_by_blank_line() {
+fn loose_ordered_list_with_code_block_renders_as_commonmark_loose_list() {
+    // The user's reproducer from issue #77. With 3-space indent the markdown
+    // renders in CommonMark as a 2-item list with nested code block; with the
+    // old 2-space indent the code block fell outside the list entirely.
     let html = r#"
 <ol>
 <li>
@@ -253,17 +295,10 @@ fn loose_ordered_list_items_separated_by_blank_line() {
 </li>
 </ol>
 "#;
-    let expected = r#"
-1. text
-
-  ```
-  text
-  ```
-
-  text
-2. text
-"#;
-    assert_eq!(convert(html), expected.trim());
+    assert_eq!(
+        convert(html),
+        "1. text\n\n   ```\n   text\n   ```\n\n   text\n2. text"
+    );
 }
 
 // https://github.com/harlan-zw/mdream/issues/76
@@ -308,7 +343,7 @@ fn inline_code_after_whitespace_in_list_item_does_not_duplicate_separator() {
 #[test]
 fn inline_code_inside_wrappers_inside_list_no_stray_space() {
     // No leading space should be injected when the wrapper opener is the last
-    // thing emitted — otherwise pairing breaks for strikethrough and link
+    // thing emitted, otherwise pairing breaks for strikethrough and link
     // text, and the space leaks into HTML passthrough content.
     assert_eq!(
         convert("<ul><li><del><code>x</code></del></li></ul>"),