html-to-markdown 2.29.0 → 3.0.0

data/vendor/html-to-markdown-rs/src/converter/main.rs

@@ -15,14 +15,14 @@ use std::collections::BTreeMap;
 
 use crate::converter::dom_context::DomContext;
 use crate::converter::main_helpers::{
-    extract_head_metadata, format_metadata_frontmatter, handle_hocr_document, has_custom_element_tags,
-    repair_with_html5ever, trim_line_end_whitespace, trim_trailing_whitespace,
+    extract_head_metadata, format_metadata_frontmatter, has_custom_element_tags, repair_with_html5ever,
+    trim_line_end_whitespace, trim_trailing_whitespace,
 };
 use crate::converter::plain_text::extract_plain_text;
 use crate::converter::preprocessing_helpers::{has_inline_block_misnest, should_drop_for_preprocessing};
 use crate::converter::utility::caching::build_dom_context;
 use crate::converter::utility::content::normalized_tag_name;
-use crate::converter::utility::preprocessing::{preprocess_html, strip_script_and_style_tags};
+use crate::converter::utility::preprocessing::{preprocess_html, strip_hidden_elements, strip_script_and_style_tags};
 use crate::converter::utility::serialization::serialize_tag_to_html;
 use crate::options::OutputFormat;
 
@@ -31,12 +31,13 @@ use crate::error::Result;
 use crate::options::ConversionOptions;
 
 use crate::converter::context::{Context, InlineCollectorHandle};
+use crate::types::structure_collector::StructureCollectorHandle;
 
 /// Converts HTML to Markdown using the provided conversion options.
 ///
 /// This is the main entry point for HTML to Markdown conversion.
 pub fn convert_html(html: &str, options: &ConversionOptions) -> Result<String> {
-    convert_html_impl(html, options, None, None, None)
+    convert_html_impl(html, options, None, None, None, None).map(|(md, _)| md)
 }
 
 /// Converts HTML to Markdown with a custom visitor for callbacks during traversal.
@@ -49,26 +50,13 @@ pub fn convert_html_with_visitor(
     options: &ConversionOptions,
     visitor: Option<crate::visitor::VisitorHandle>,
 ) -> Result<String> {
-    convert_html_impl(html, options, None, None, visitor)
-}
-
-/// Converts HTML to Markdown with an async visitor for callbacks during traversal.
-///
-/// Async variant with async visitor callbacks for Promise-based bindings.
-#[cfg(feature = "async-visitor")]
-#[allow(clippy::future_not_send)]
-pub async fn convert_html_with_visitor_async(
-    html: &str,
-    options: &ConversionOptions,
-    visitor: Option<crate::visitor_helpers::AsyncVisitorHandle>,
-) -> Result<String> {
-    convert_html_impl_async(html, options, None, None, visitor).await
+    convert_html_impl(html, options, None, None, visitor, None).map(|(md, _)| md)
 }
 
 /// Internal implementation of HTML to Markdown conversion.
 ///
-/// This function handles the actual conversion logic with optional inline image collection,
-/// metadata extraction, and visitor callbacks depending on enabled features.
+/// Returns `(markdown, Option<DocumentStructure>)`.  The structure is populated when
+/// `options.include_document_structure == true` and a `structure_collector` handle is provided.
 #[cfg_attr(
     any(not(feature = "inline-images"), not(feature = "metadata"), not(feature = "visitor")),
     allow(unused_variables)
@@ -82,10 +70,13 @@ pub(crate) fn convert_html_impl(
     #[cfg(not(feature = "metadata"))] _metadata_collector: Option<()>,
     #[cfg(feature = "visitor")] visitor: Option<crate::visitor::VisitorHandle>,
     #[cfg(not(feature = "visitor"))] _visitor: Option<()>,
-) -> Result<String> {
+    structure_collector: Option<StructureCollectorHandle>,
+) -> Result<(String, Option<crate::types::DocumentStructure>)> {
     // Strip script and style tags completely to prevent parser confusion from HTML-like content
     // inside script/style elements. This preserves JSON-LD for metadata extraction.
     let stripped = strip_script_and_style_tags(html);
+    // Strip elements with the `hidden` attribute before parsing.
+    let stripped = strip_hidden_elements(&stripped);
     let mut preprocessed = preprocess_html(&stripped).into_owned();
     let mut preprocessed_len = preprocessed.len();
 
@@ -113,11 +104,6 @@ pub(crate) fn convert_html_impl(
     let mut parser = dom.parser();
     let mut output = String::with_capacity(preprocessed_len.saturating_add(preprocessed_len / 4));
 
-    // Check and handle hOCR documents
-    if handle_hocr_document(&dom, parser, options, &mut output) {
-        return Ok(output);
-    }
-
     let mut dom_ctx = build_dom_context(&dom, parser, preprocessed_len);
 
     // Check for inline-block misnesting and repair if needed
@@ -211,13 +197,37 @@ pub(crate) fn convert_html_impl(
     }
 
     #[cfg(all(feature = "metadata", feature = "visitor"))]
-    let ctx = Context::new(options, inline_collector, metadata_collector, visitor);
+    let ctx = Context::new(
+        options,
+        inline_collector,
+        metadata_collector,
+        visitor,
+        structure_collector.as_ref().map(std::rc::Rc::clone),
+    );
     #[cfg(all(feature = "metadata", not(feature = "visitor")))]
-    let ctx = Context::new(options, inline_collector, metadata_collector, _visitor);
+    let ctx = Context::new(
+        options,
+        inline_collector,
+        metadata_collector,
+        _visitor,
+        structure_collector.as_ref().map(std::rc::Rc::clone),
+    );
     #[cfg(all(not(feature = "metadata"), feature = "visitor"))]
-    let ctx = Context::new(options, inline_collector, _metadata_collector, visitor);
+    let ctx = Context::new(
+        options,
+        inline_collector,
+        _metadata_collector,
+        visitor,
+        structure_collector.as_ref().map(std::rc::Rc::clone),
+    );
     #[cfg(all(not(feature = "metadata"), not(feature = "visitor")))]
-    let ctx = Context::new(options, inline_collector, _metadata_collector, _visitor);
+    let ctx = Context::new(
+        options,
+        inline_collector,
+        _metadata_collector,
+        _visitor,
+        structure_collector.as_ref().map(std::rc::Rc::clone),
+    );
 
     for child_handle in dom.children() {
         walk_node(child_handle, parser, &mut output, options, &ctx, 0, &dom_ctx);
@@ -228,20 +238,32 @@ pub(crate) fn convert_html_impl(
         return Err(crate::error::ConversionError::Visitor(err.clone()));
     }
 
+    // Drop ctx before unwrapping the structure collector Rc — ctx holds a cloned Rc
+    // reference to the same collector, and Rc::try_unwrap requires exactly one reference.
+    drop(ctx);
+
     // If plain text was requested, discard the markdown output and return plain text.
     // The full pipeline was still run above so that metadata + visitor callbacks fire.
     if is_plain_text {
         let plain = extract_plain_text(&dom, parser, options);
-        return Ok(plain);
+        let document =
+            structure_collector.and_then(|sc| std::rc::Rc::try_unwrap(sc).ok().map(|cell| cell.into_inner().finish()));
+        return Ok((plain, document));
     }
 
     trim_line_end_whitespace(&mut output);
     let trimmed = output.trim_end_matches('\n');
-    if trimmed.is_empty() {
-        Ok(String::new())
+    let markdown = if trimmed.is_empty() {
+        String::new()
     } else {
-        Ok(format!("{trimmed}\n"))
-    }
+        format!("{trimmed}\n")
+    };
+
+    // Finish the structure collector if present.
+    let document =
+        structure_collector.and_then(|sc| std::rc::Rc::try_unwrap(sc).ok().map(|cell| cell.into_inner().finish()));
+
+    Ok((markdown, document))
 }
 // has_more_than_one_char moved to main_helpers
 // is_inline_element available from utility::content
@@ -473,6 +495,34 @@ pub(crate) fn walk_node(
                     );
                 }
 
+                // Quote element routed to semantic dispatcher
+                "q" => {
+                    crate::converter::semantic::dispatch_semantic_handler(
+                        &tag_name,
+                        node_handle,
+                        parser,
+                        output,
+                        options,
+                        ctx,
+                        depth,
+                        dom_ctx,
+                    );
+                }
+
+                // Figure elements routed to semantic dispatcher
+                "figure" | "figcaption" => {
+                    crate::converter::semantic::dispatch_semantic_handler(
+                        &tag_name,
+                        node_handle,
+                        parser,
+                        output,
+                        options,
+                        ctx,
+                        depth,
+                        dom_ctx,
+                    );
+                }
+
                 // Semantic interactive elements routed to semantic dispatcher
                 "details" | "summary" | "dialog" | "menu" => {
                     crate::converter::semantic::dispatch_semantic_handler(
@@ -569,24 +619,3 @@ pub(crate) fn walk_node(
         tl::Node::Comment(_) => {}
     }
 }
-/// Async equivalent of `convert_html_impl` for Promise-based visitor callbacks.
-#[cfg(feature = "async-visitor")]
-#[allow(clippy::future_not_send)]
-pub(crate) async fn convert_html_impl_async(
-    html: &str,
-    options: &ConversionOptions,
-    _inline_collector: Option<InlineCollectorHandle>,
-    #[cfg(feature = "metadata")] _metadata_collector: Option<crate::metadata::MetadataCollectorHandle>,
-    #[cfg(not(feature = "metadata"))] _metadata_collector: Option<()>,
-    visitor: Option<crate::visitor_helpers::AsyncVisitorHandle>,
-) -> Result<String> {
-    if visitor.is_some() {
-        return Err(crate::error::ConversionError::ParseError(
-            "Async visitor not yet implemented. Use AsyncToSyncVisitorBridge.".to_string(),
-        ));
-    }
-    #[cfg(feature = "visitor")]
-    return convert_html_impl(html, options, _inline_collector, _metadata_collector, None);
-    #[cfg(not(feature = "visitor"))]
-    return convert_html_impl(html, options, _inline_collector, _metadata_collector, ());
-}

data/vendor/html-to-markdown-rs/src/converter/main_helpers.rs

@@ -145,8 +145,8 @@ pub fn extract_head_metadata(
                 if let Some(tl::Node::Tag(child_tag)) = child_handle.get(parser) {
                     // Look for meta tags
                     if child_tag.name().as_utf8_str().eq_ignore_ascii_case("meta")
-                        && !options.strip_tags.contains(&"meta".to_string())
-                        && !options.preserve_tags.contains(&"meta".to_string())
+                        && !options.strip_tags.iter().any(|t| t == "meta")
+                        && !options.preserve_tags.iter().any(|t| t == "meta")
                     {
                         if let (Some(name), Some(content)) = (
                             child_tag.attributes().get("name").flatten(),
@@ -168,8 +168,8 @@ pub fn extract_head_metadata(
                     }
                     // Look for title tag
                     if child_tag.name().as_utf8_str().eq_ignore_ascii_case("title")
-                        && !options.strip_tags.contains(&"title".to_string())
-                        && !options.preserve_tags.contains(&"title".to_string())
+                        && !options.strip_tags.iter().any(|t| t == "title")
+                        && !options.preserve_tags.iter().any(|t| t == "title")
                     {
                         // Extract text content from title tag
                         let mut title_content = String::new();
@@ -284,66 +284,3 @@ pub fn is_inline_element(tag_name: &str) -> bool {
             | "meter"
     )
 }
-
-/// Handle hOCR document conversion, returning true if handled, false if not hOCR.
-pub fn handle_hocr_document(
-    dom: &tl::VDom<'_>,
-    parser: &tl::Parser<'_>,
-    options: &ConversionOptions,
-    output: &mut String,
-) -> bool {
-    use crate::converter::utility::attributes::{is_hocr_document, may_be_hocr};
-    use crate::hocr::{convert_to_markdown_with_options as convert_hocr_to_markdown, extract_hocr_document};
-
-    let preprocessed = dom.outer_html();
-    if !may_be_hocr(preprocessed.as_ref()) {
-        return false;
-    }
-
-    let mut is_hocr = false;
-    for child_handle in dom.children() {
-        if is_hocr_document(*child_handle, parser) {
-            is_hocr = true;
-            break;
-        }
-    }
-
-    if !is_hocr {
-        return false;
-    }
-
-    let (elements, metadata) = extract_hocr_document(dom);
-
-    if options.extract_metadata && !options.convert_as_inline {
-        let mut metadata_map = BTreeMap::new();
-        if let Some(system) = metadata.ocr_system {
-            metadata_map.insert("ocr-system".to_string(), system);
-        }
-        if !metadata.ocr_capabilities.is_empty() {
-            metadata_map.insert("ocr-capabilities".to_string(), metadata.ocr_capabilities.join(", "));
-        }
-        if let Some(pages) = metadata.ocr_number_of_pages {
-            metadata_map.insert("ocr-number-of-pages".to_string(), pages.to_string());
-        }
-        if !metadata.ocr_langs.is_empty() {
-            metadata_map.insert("ocr-langs".to_string(), metadata.ocr_langs.join(", "));
-        }
-        if !metadata.ocr_scripts.is_empty() {
-            metadata_map.insert("ocr-scripts".to_string(), metadata.ocr_scripts.join(", "));
-        }
-
-        if !metadata_map.is_empty() {
-            output.push_str(&format_metadata_frontmatter(&metadata_map));
-        }
-    }
-
-    let mut markdown = convert_hocr_to_markdown(&elements, true, options.hocr_spatial_tables);
-
-    if !markdown.trim().is_empty() {
-        markdown.truncate(markdown.trim_end().len());
-        output.push_str(&markdown);
-        output.push('\n');
-    }
-
-    true
-}

data/vendor/html-to-markdown-rs/src/converter/media/embedded.rs

@@ -12,6 +12,7 @@ use tl::{HTMLTag, NodeHandle, Parser};
 
 use crate::converter::Context;
 use crate::converter::dom_context::DomContext;
+use crate::converter::main_helpers::tag_name_eq;
 use crate::options::ConversionOptions;
 
 /// Extract src attribute from media element (audio, video, iframe).
@@ -46,11 +47,6 @@ pub(crate) fn is_source_element(tag: &HTMLTag) -> bool {
     tag_name_eq(tag.name().as_utf8_str(), "source")
 }
 
-/// Compare tag name with needle (case-insensitive).
-fn tag_name_eq<'a>(name: impl AsRef<str>, needle: &str) -> bool {
-    name.as_ref().eq_ignore_ascii_case(needle)
-}
-
 /// Determine if media should output source link in markdown.
 ///
 /// Returns true if src is non-empty.

data/vendor/html-to-markdown-rs/src/converter/media/graphic.rs

@@ -1,41 +1,4 @@
 //! Graphic element handling (custom graphic elements with alternative source attributes).
-
-use std::borrow::Cow;
-use tl::HTMLTag;
-
-/// Handle custom graphic elements with multiple source attribute options.
-///
-/// The graphic element is a custom XML element that supports multiple source attributes:
-/// - `url` (primary)
-/// - `href` (secondary)
-/// - `xlink:href` (SVG standard)
-/// - `src` (fallback)
-///
-/// This is commonly used in publishing formats like EPUB.
-pub(crate) fn extract_graphic_src<'a>(tag: &'a HTMLTag<'a>) -> Cow<'a, str> {
-    tag.attributes()
-        .get("url")
-        .flatten()
-        .or_else(|| tag.attributes().get("href").flatten())
-        .or_else(|| tag.attributes().get("xlink:href").flatten())
-        .or_else(|| tag.attributes().get("src").flatten())
-        .map_or_else(|| Cow::Borrowed(""), |v| v.as_utf8_str())
-}
-
-/// Extract alt text from graphic element with fallback to filename.
-pub(crate) fn extract_graphic_alt<'a>(tag: &'a HTMLTag<'a>) -> Cow<'a, str> {
-    tag.attributes()
-        .get("alt")
-        .flatten()
-        .map(|v| v.as_utf8_str())
-        .or_else(|| tag.attributes().get("filename").flatten().map(|v| v.as_utf8_str()))
-        .unwrap_or_else(|| Cow::Borrowed(""))
-}
-
-/// Get source attributes to skip during metadata collection.
-///
-/// These attributes are handled specially and should not be included
-/// in the generic attributes map.
-pub(crate) fn should_skip_graphic_attr(key_str: &str) -> bool {
-    matches!(key_str, "url" | "href" | "xlink:href" | "src")
-}
+//!
+//! The `<graphic>` element is a custom XML element used in publishing formats like EPUB.
+//! Conversion logic lives in `crate::converter::handlers::graphic`.

data/vendor/html-to-markdown-rs/src/converter/media/image.rs

@@ -171,14 +171,6 @@ pub(crate) fn handle_inline_data_image(
     collector.push_image(index, image);
 }
 
-/// Check if heading tag allows inline images based on configuration.
-pub(crate) fn heading_allows_inline_images(
-    tag_name: &str,
-    keep_inline_images_in: &std::collections::HashSet<String>,
-) -> bool {
-    keep_inline_images_in.contains(tag_name)
-}
-
 /// Extract non-empty trimmed string or return None.
 #[cfg(feature = "inline-images")]
 fn non_empty_trimmed(value: &str) -> Option<String> {

data/vendor/html-to-markdown-rs/src/converter/media/svg.rs

@@ -1,5 +1,7 @@
 //! SVG and MathML element handling with serialization and base64 encoding.
 
+use crate::converter::main_helpers::tag_name_eq;
+use crate::converter::utility::content::normalized_tag_name;
 #[allow(unused_imports)]
 use std::collections::BTreeMap;
 use tl::{NodeHandle, Parser};
@@ -93,7 +95,7 @@ pub(crate) fn handle_inline_svg(
 #[allow(clippy::trivially_copy_pass_by_ref)]
 pub(crate) fn serialize_element(node_handle: &NodeHandle, parser: &Parser) -> String {
     if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        let tag_name = normalized_tag_name(tag.name().as_utf8_str().as_ref());
+        let tag_name = normalized_tag_name(tag.name().as_utf8_str());
         let mut html = String::with_capacity(256);
         html.push('<');
         html.push_str(&tag_name);
@@ -142,11 +144,6 @@ pub(crate) fn serialize_node(node_handle: &NodeHandle, parser: &Parser) -> Strin
     }
 }
 
-/// Normalize tag name to lowercase.
-fn normalized_tag_name(name: &str) -> String {
-    name.to_ascii_lowercase()
-}
-
 /// Extract non-empty trimmed string or return None.
 #[cfg(feature = "inline-images")]
 fn non_empty_trimmed(value: &str) -> Option<String> {
@@ -158,12 +155,6 @@ fn non_empty_trimmed(value: &str) -> Option<String> {
     }
 }
 
-/// Encode SVG to base64 data URI.
-pub(crate) fn encode_svg_to_data_uri(svg_html: &str) -> String {
-    use base64::{Engine as _, engine::general_purpose::STANDARD};
-    STANDARD.encode(svg_html.as_bytes())
-}
-
 /// Handle SVG element conversion to Markdown.
 ///
 /// Extracts title from child elements, handles inline image collection,
@@ -179,7 +170,6 @@ pub(crate) fn handle_svg(
     _depth: usize,
     dom_ctx: &super::DomContext,
 ) {
-    use crate::converter::main_helpers::tag_name_eq;
     use crate::converter::utility::content::get_text_content;
 
     let mut title = String::from("SVG Image");

data/vendor/html-to-markdown-rs/src/converter/metadata.rs

@@ -100,7 +100,7 @@ fn handle_head(
                                 let json = child_tag.inner_text(parser);
                                 let json = json.trim();
                                 if !json.is_empty() {
-                                    let json = decode_html_entities(json).clone();
+                                    let json = decode_html_entities(json);
                                     if !json.is_empty() {
                                         collector.borrow_mut().add_json_ld(json);
                                     }

data/vendor/html-to-markdown-rs/src/converter/mod.rs

@@ -68,7 +68,6 @@
 //! - Inline image extraction (`inline-images` feature)
 //! - Metadata collection (`metadata` feature)
 //! - Custom visitor callbacks (`visitor` feature)
-//! - Async visitor support (`async-visitor` feature)
 //!
 //! # Example Integration
 //!
@@ -120,17 +119,10 @@ pub use self::main::convert_html;
 #[cfg(feature = "visitor")]
 pub use self::main::convert_html_with_visitor;
 
-#[cfg(feature = "async-visitor")]
-pub use self::main::convert_html_with_visitor_async;
-
 // Import the tree walker and utility functions from main and main_helpers
 pub(crate) use self::main::{convert_html_impl, walk_node};
 pub(crate) use self::main_helpers::trim_trailing_whitespace;
 
-#[cfg(feature = "async-visitor")]
-#[allow(unused_imports)]
-pub(crate) use self::main::convert_html_impl_async;
-
 // Re-export helper functions from utility modules (migrated from converter_legacy)
 pub(crate) use crate::converter::utility::content::{chomp_inline, get_text_content, normalized_tag_name};
 #[allow(unused_imports)]

data/vendor/html-to-markdown-rs/src/converter/plain_text.rs

@@ -292,22 +292,47 @@ fn ensure_newline(buf: &mut String) {
     }
 }
 
-/// Post-process: collapse 3+ newlines to 2, trim line-end whitespace, ensure single trailing newline.
-fn post_process(buf: &mut String) {
-    // Collapse runs of 3+ newlines to exactly 2
-    while buf.contains("\n\n\n") {
-        *buf = buf.replace("\n\n\n", "\n\n");
+/// Collapse runs of 3 or more consecutive newlines to exactly 2 in a single pass.
+fn collapse_triple_newlines(buf: &mut String) {
+    let bytes = buf.as_bytes();
+    let mut result = String::with_capacity(buf.len());
+    let mut newline_count = 0usize;
+    for &b in bytes {
+        if b == b'\n' {
+            newline_count += 1;
+            if newline_count <= 2 {
+                result.push('\n');
+            }
+        } else {
+            newline_count = 0;
+            result.push(b as char);
+        }
     }
+    *buf = result;
+}
 
-    // Trim trailing whitespace from each line — collect owned strings to avoid borrow conflict
-    let lines: Vec<String> = buf.lines().map(|line| line.trim_end().to_string()).collect();
-    buf.clear();
-    for (i, line) in lines.iter().enumerate() {
-        buf.push_str(line);
-        if i < lines.len() - 1 {
-            buf.push('\n');
+/// Trim trailing whitespace from every line in a buffer without allocating per-line strings.
+///
+/// Uses a single allocation of the same capacity, writing each line's trimmed content
+/// and inserting newline separators directly.
+fn trim_line_ends(buf: &mut String) {
+    let mut result = String::with_capacity(buf.len());
+    for line in buf.lines() {
+        if !result.is_empty() {
+            result.push('\n');
         }
+        result.push_str(line.trim_end());
     }
+    *buf = result;
+}
+
+/// Post-process: collapse 3+ newlines to 2, trim line-end whitespace, ensure single trailing newline.
+fn post_process(buf: &mut String) {
+    // Collapse runs of 3+ newlines to exactly 2
+    collapse_triple_newlines(buf);
+
+    // Trim trailing whitespace from each line in-place
+    trim_line_ends(buf);
 
     // Trim to single trailing newline
     let keep = buf.trim_end_matches('\n').len();

data/vendor/html-to-markdown-rs/src/converter/semantic/attributes.rs

@@ -15,6 +15,8 @@
 // Note: Context and DomContext are defined in converter.rs
 // walk_node is also defined there and must be called via the parent module
 
+use crate::converter::utility::content::chomp_inline;
+
 /// Handles the `<dfn>` element.
 ///
 /// A dfn element marks a term that is being defined. The content represents
@@ -220,14 +222,9 @@ pub fn handle_q(
 
         let trimmed = content.trim();
         if !trimmed.is_empty() {
-            if ctx.convert_as_inline {
-                output.push_str(trimmed);
-            } else {
-                output.push('"');
-                let escaped = trimmed.replace('\\', r"\\").replace('"', r#"\""#);
-                output.push_str(&escaped);
-                output.push('"');
-            }
+            output.push('"');
+            output.push_str(trimmed);
+            output.push('"');
         }
     }
 }
@@ -256,28 +253,6 @@ pub fn handle(
     }
 }
 
-/// Extracts prefix, suffix, and trimmed content from inline element text.
-///
-/// This helper function splits leading and trailing whitespace from content,
-/// allowing inline elements to preserve surrounding whitespace context.
-///
-/// # Returns
-///
-/// A tuple of `(prefix, suffix, trimmed_content)` where:
-/// - `prefix`: Leading whitespace (spaces, tabs, newlines)
-/// - `suffix`: Trailing whitespace (spaces, tabs, newlines)
-/// - `trimmed_content`: The content without leading/trailing whitespace
-fn chomp_inline(content: &str) -> (&str, &str, &str) {
-    let trimmed = content.trim();
-    let prefix_len = content.len() - content.trim_start().len();
-    let suffix_len = content.len() - content.trim_end().len();
-
-    let prefix = &content[..prefix_len];
-    let suffix = &content[content.len() - suffix_len..];
-
-    (prefix, suffix, trimmed)
-}
-
 /// Appends inline suffix to the output.
 ///
 /// This is a placeholder for integrating with other inline formatting systems

data/vendor/html-to-markdown-rs/src/converter/semantic/figure.rs

@@ -164,3 +164,32 @@ pub fn handle(
         _ => {}
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn figure_caption_separated_from_image() {
+        let html = r#"<figure><img src="photo.jpg" alt="Photo"><figcaption>A nice photo</figcaption></figure>"#;
+        let result = crate::convert(html, None).unwrap();
+        let content = result.content.unwrap_or_default();
+        assert!(
+            content.contains("![Photo](photo.jpg)"),
+            "image should be present: {}",
+            content
+        );
+        assert!(
+            content.contains("A nice photo"),
+            "caption should be present: {}",
+            content
+        );
+        // Image and caption should not be on the same line
+        let lines: Vec<&str> = content.lines().filter(|l| !l.trim().is_empty()).collect();
+        let img_line = lines.iter().position(|l| l.contains("![")).unwrap_or(999);
+        let cap_line = lines.iter().position(|l| l.contains("A nice photo")).unwrap_or(999);
+        assert!(
+            cap_line > img_line,
+            "caption should be on a separate line after image, lines: {:?}",
+            lines
+        );
+    }
+}