html-to-markdown 2.30.0 → 3.0.1

data/vendor/html-to-markdown-rs/src/converter/block/blockquote.rs

@@ -7,6 +7,8 @@
 //! - Spacing management for various contexts
 //! - Visitor callbacks for custom blockquote processing
 
+#[cfg(feature = "visitor")]
+use crate::converter::utility::content::collect_tag_attributes;
 use crate::options::ConversionOptions;
 #[allow(unused_imports)]
 use std::collections::BTreeMap;
@@ -88,11 +90,7 @@ pub(crate) fn handle(
 
             if let Some(node) = node_handle.get(parser) {
                 if let tl::Node::Tag(tag) = node {
-                    let attributes: BTreeMap<String, String> = tag
-                        .attributes()
-                        .iter()
-                        .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                        .collect();
+                    let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
                     let node_id = node_handle.get_inner();
                     let parent_tag = dom_ctx.parent_tag_name(node_id, parser);

data/vendor/html-to-markdown-rs/src/converter/block/div.rs

@@ -6,6 +6,7 @@
 //! - List continuations: Uses list indentation
 //! - Block context: Adds surrounding newlines for proper block separation
 
+use crate::converter::main_helpers::trim_trailing_whitespace;
 use crate::options::ConversionOptions;
 use tl::{NodeHandle, Parser};
 
@@ -131,13 +132,6 @@ pub(crate) fn handle(
     }
 }
 
-/// Helper function to trim trailing whitespace
-fn trim_trailing_whitespace(output: &mut String) {
-    while output.ends_with(' ') || output.ends_with('\t') {
-        output.pop();
-    }
-}
-
 /// Helper function to add list continuation indentation
 fn add_list_continuation_indent(
     output: &mut String,

data/vendor/html-to-markdown-rs/src/converter/block/heading.rs

@@ -6,6 +6,8 @@
 //! - Metadata collection (headers, IDs)
 //! - Visitor callbacks for custom heading processing
 
+#[cfg(feature = "visitor")]
+use crate::converter::utility::content::collect_tag_attributes;
 use crate::options::{ConversionOptions, HeadingStyle};
 use std::borrow::Cow;
 #[allow(unused_imports)]
@@ -124,6 +126,21 @@ pub(crate) fn handle(
                 }
             }
         }
+
+        // Notify the structure collector if present.
+        if let Some(ref sc) = ctx.structure_collector {
+            if let Some(node) = node_handle.get(parser) {
+                if let tl::Node::Tag(tag) = node {
+                    let id = tag
+                        .attributes()
+                        .get("id")
+                        .flatten()
+                        .map(|v| v.as_utf8_str().to_string());
+                    sc.borrow_mut()
+                        .push_heading(level as u8, normalized.as_ref(), id.as_deref());
+                }
+            }
+        }
     }
 }
 
@@ -292,11 +309,7 @@ fn visitor_heading_output(
                     .flatten()
                     .map(|v| v.as_utf8_str().to_string());
 
-                let attributes: BTreeMap<String, String> = tag
-                    .attributes()
-                    .iter()
-                    .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                    .collect();
+                let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
                 let node_id = node_handle.get_inner();
                 let parent_tag = dom_ctx.parent_tag_name(node_id, parser);

data/vendor/html-to-markdown-rs/src/converter/block/paragraph.rs

@@ -96,6 +96,16 @@ pub(crate) fn handle(
     if has_content && !ctx.convert_as_inline && !ctx.in_table_cell {
         output.push_str("\n\n");
     }
+
+    // Notify the structure collector if present and we produced non-empty top-level paragraph content.
+    if has_content && !ctx.in_table_cell && !ctx.in_list_item && !ctx.convert_as_inline {
+        if let Some(ref sc) = ctx.structure_collector {
+            let text = output[content_start_pos..].trim().to_string();
+            if !text.is_empty() {
+                sc.borrow_mut().push_paragraph(&text);
+            }
+        }
+    }
 }
 
 /// Add continuation indentation for list items.

data/vendor/html-to-markdown-rs/src/converter/block/preformatted.rs

@@ -7,6 +7,8 @@
 //! - Inline code formatting with backtick management
 //! - Visitor callbacks for custom code processing
 
+#[cfg(feature = "visitor")]
+use crate::converter::utility::content::collect_tag_attributes;
 use crate::options::{CodeBlockStyle, ConversionOptions, WhitespaceMode};
 #[allow(unused_imports)]
 use std::collections::BTreeMap;
@@ -93,11 +95,7 @@ pub(crate) fn handle_pre(
 
                 if let Some(node) = node_handle.get(parser) {
                     if let tl::Node::Tag(tag) = node {
-                        let attributes: BTreeMap<String, String> = tag
-                            .attributes()
-                            .iter()
-                            .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                            .collect();
+                        let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
                         let node_id = node_handle.get_inner();
                         let parent_tag = dom_ctx.parent_tag_name(node_id, parser);

data/vendor/html-to-markdown-rs/src/converter/block/table/builder.rs

@@ -9,6 +9,8 @@ use super::cell::{collect_table_cells, get_colspan};
 use super::cells::{append_layout_row, convert_table_row};
 use super::scanner::scan_table;
 use super::utils::{is_tag_name, normalized_tag_name};
+#[cfg(feature = "visitor")]
+use crate::converter::utility::content::collect_tag_attributes;
 
 /// Maximum allowed table columns to prevent unbounded memory usage.
 const MAX_TABLE_COLS: usize = 1000;
@@ -106,11 +108,7 @@ pub fn handle_table(
             use crate::visitor::{NodeContext, NodeType, VisitResult};
             use std::collections::BTreeMap;
 
-            let attributes: BTreeMap<String, String> = tag
-                .attributes()
-                .iter()
-                .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                .collect();
+            let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
             let node_id = node_handle.get_inner();
             let parent_tag = dom_ctx.parent_tag_name(node_id, parser);
@@ -160,7 +158,7 @@ pub fn handle_table(
             .get("border")
             .is_some_and(|v| v.as_ref().is_some_and(|b| b.as_utf8_str() == "0"));
         let looks_like_layout =
-            table_scan.has_nested_table || distinct_counts.len() > 1 || (table_scan.has_span && has_border_zero);
+            table_scan.nested_table_count > 1 || distinct_counts.len() > 1 || (table_scan.has_span && has_border_zero);
         let link_count = table_scan.link_count;
         let is_blank_table = !table_scan.has_text;
 
@@ -343,11 +341,7 @@ pub fn handle_table(
             use crate::visitor::{NodeContext, NodeType, VisitResult};
             use std::collections::BTreeMap;
 
-            let attributes: BTreeMap<String, String> = tag
-                .attributes()
-                .iter()
-                .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                .collect();
+            let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
             let node_id = node_handle.get_inner();
             let parent_tag = dom_ctx.parent_tag_name(node_id, parser);
@@ -400,3 +394,14 @@ pub fn handle_table(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn single_nested_table_stays_as_table() {
+        let html = r"<table><tr><td>Label</td><td><table><tr><td>A</td><td>B</td></tr></table></td></tr></table>";
+        let result = crate::convert(html, None).unwrap();
+        let content = result.content.unwrap_or_default();
+        assert!(content.contains('|'), "should produce pipe table, not list");
+    }
+}

data/vendor/html-to-markdown-rs/src/converter/block/table/cell.rs

@@ -179,3 +179,23 @@ pub fn convert_table_cell(
         output.push_str(" |");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn rich_formatting_preserved_in_cells() {
+        let html = "<table><tr><th>H</th></tr><tr><td><strong>Bold</strong> and <em>italic</em></td></tr></table>";
+        let result = crate::convert(html, None).unwrap();
+        let content = result.content.unwrap_or_default();
+        assert!(
+            content.contains("**Bold**") || content.contains("__Bold__"),
+            "bold should be preserved: {}",
+            content
+        );
+        assert!(
+            content.contains("*italic*") || content.contains("_italic_"),
+            "italic should be preserved: {}",
+            content
+        );
+    }
+}

data/vendor/html-to-markdown-rs/src/converter/block/table/cells.rs

@@ -5,6 +5,9 @@
 //! - Cell layout handling with colspan/rowspan support
 //! - Layout table row conversion to list items
 
+#[cfg(feature = "visitor")]
+use crate::converter::utility::content::collect_tag_attributes;
+use crate::converter::utility::content::normalized_tag_name;
 use std::borrow::Cow;
 
 use super::cell::{collect_table_cells, convert_table_cell, get_colspan_rowspan};
@@ -84,18 +87,6 @@ pub fn append_layout_row(
     }
 }
 
-/// Normalize HTML tag names to lowercase.
-///
-/// Converts tag names to a consistent lowercase form for comparison.
-fn normalized_tag_name(raw: Cow<'_, str>) -> Cow<'_, str> {
-    let lowercased = raw.to_lowercase();
-    if lowercased.as_str() == raw.as_ref() {
-        raw
-    } else {
-        Cow::Owned(lowercased)
-    }
-}
-
 /// Convert a table row (tr) to Markdown format.
 ///
 /// Processes all cells in a row, handling colspan and rowspan for proper
@@ -167,11 +158,7 @@ pub fn convert_table_row(
         use std::collections::BTreeMap;
 
         if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-            let attributes: BTreeMap<String, String> = tag
-                .attributes()
-                .iter()
-                .filter_map(|(k, v)| v.as_ref().map(|val| (k.to_string(), val.to_string())))
-                .collect();
+            let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
 
             let node_ctx = NodeContext {
                 node_type: NodeType::TableRow,

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

@@ -96,6 +96,13 @@ pub(crate) fn handle_table_with_context(
     let mut table_output = String::new();
     builder::handle_table(node_handle, parser, &mut table_output, options, ctx, dom_ctx, depth);
 
+    // Feed the table into the structure collector when document structure extraction is enabled.
+    if let Some(ref sc) = ctx.structure_collector {
+        if let Some(grid) = collect_table_grid(node_handle, parser, options, ctx, dom_ctx) {
+            sc.borrow_mut().push_table(grid);
+        }
+    }
+
     if ctx.in_list_item {
         let has_caption = table_output.starts_with('*');
 
@@ -124,3 +131,136 @@ pub(crate) fn handle_table_with_context(
         output.push('\n');
     }
 }
+
+/// Collect a [`crate::types::TableGrid`] from the DOM for the structure collector.
+///
+/// Walks the table's rows and cells, extracting text content and span attributes
+/// to build a structured grid representation.
+fn collect_table_grid(
+    node_handle: &tl::NodeHandle,
+    parser: &tl::Parser,
+    options: &crate::options::ConversionOptions,
+    ctx: &super::super::Context,
+    dom_ctx: &super::super::DomContext,
+) -> Option<crate::types::TableGrid> {
+    use utils::{is_tag_name, normalized_tag_name};
+
+    let tl::Node::Tag(tag) = node_handle.get(parser)? else {
+        return None;
+    };
+
+    let mut grid_cells = Vec::new();
+    let mut row_index: u32 = 0;
+    let mut max_cols: u32 = 0;
+    let mut cell_handles = Vec::new();
+
+    let children = tag.children();
+    for child_handle in children.top().iter() {
+        if let Some(tl::Node::Tag(child_tag)) = child_handle.get(parser) {
+            let tag_name = normalized_tag_name(child_tag.name().as_utf8_str());
+            match tag_name.as_ref() {
+                "thead" | "tbody" | "tfoot" => {
+                    let is_header_section = tag_name.as_ref() == "thead";
+                    for row_handle in child_tag.children().top().iter() {
+                        if is_tag_name(row_handle, parser, dom_ctx, "tr") {
+                            collect_grid_row(
+                                row_handle,
+                                parser,
+                                options,
+                                ctx,
+                                dom_ctx,
+                                &mut cell_handles,
+                                &mut grid_cells,
+                                &mut row_index,
+                                &mut max_cols,
+                                is_header_section,
+                            );
+                        }
+                    }
+                }
+                "tr" | "row" => {
+                    let is_first = row_index == 0;
+                    collect_grid_row(
+                        child_handle,
+                        parser,
+                        options,
+                        ctx,
+                        dom_ctx,
+                        &mut cell_handles,
+                        &mut grid_cells,
+                        &mut row_index,
+                        &mut max_cols,
+                        is_first,
+                    );
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if row_index == 0 {
+        return None;
+    }
+
+    Some(crate::types::TableGrid {
+        rows: row_index,
+        cols: max_cols,
+        cells: grid_cells,
+    })
+}
+
+/// Process a single table row for grid collection.
+#[allow(clippy::too_many_arguments)]
+fn collect_grid_row(
+    row_handle: &tl::NodeHandle,
+    parser: &tl::Parser,
+    options: &crate::options::ConversionOptions,
+    ctx: &super::super::Context,
+    dom_ctx: &super::super::DomContext,
+    cell_handles: &mut Vec<tl::NodeHandle>,
+    grid_cells: &mut Vec<crate::types::GridCell>,
+    row_index: &mut u32,
+    max_cols: &mut u32,
+    is_header_section: bool,
+) {
+    use cell::{collect_table_cells, get_colspan_rowspan};
+
+    collect_table_cells(row_handle, parser, dom_ctx, cell_handles);
+
+    let mut col_index: u32 = 0;
+    for cell_handle in cell_handles.iter() {
+        let is_header = is_header_section
+            || dom_ctx
+                .tag_name_for(*cell_handle, parser)
+                .is_some_and(|name| name.as_ref() == "th");
+
+        let mut text = String::new();
+        let cell_ctx = super::super::Context {
+            in_table_cell: true,
+            ..ctx.clone()
+        };
+        if let Some(tl::Node::Tag(cell_tag)) = cell_handle.get(parser) {
+            for child_handle in cell_tag.children().top().iter() {
+                super::super::walk_node(child_handle, parser, &mut text, options, &cell_ctx, 0, dom_ctx);
+            }
+        }
+        let content = crate::text::normalize_whitespace_cow(&text).trim().to_string();
+
+        let (colspan, rowspan) = get_colspan_rowspan(cell_handle, parser);
+
+        grid_cells.push(crate::types::GridCell {
+            content,
+            row: *row_index,
+            col: col_index,
+            row_span: rowspan as u32,
+            col_span: colspan as u32,
+            is_header,
+        });
+
+        col_index += colspan as u32;
+    }
+    if col_index > *max_cols {
+        *max_cols = col_index;
+    }
+    *row_index += 1;
+}

data/vendor/html-to-markdown-rs/src/converter/block/table/scanner.rs

@@ -3,11 +3,9 @@
 //! Provides the TableScan struct and scanning functions for analyzing table structure
 //! to determine if it should be rendered as a Markdown table or converted to list format.
 
+use crate::converter::utility::content::normalized_tag_name;
 use std::borrow::Cow;
 
-/// Maximum allowed table columns to prevent unbounded memory usage.
-const MAX_TABLE_COLS: usize = 1000;
-
 /// Scan results for a table element.
 ///
 /// Contains metadata about table structure to determine optimal rendering:
@@ -25,8 +23,8 @@ pub struct TableScan {
     pub has_header: bool,
     /// Whether the table has a caption element
     pub has_caption: bool,
-    /// Whether the table contains nested tables
-    pub has_nested_table: bool,
+    /// Number of nested tables found inside this table
+    pub nested_table_count: usize,
     /// Count of anchor elements in the table
     pub link_count: usize,
     /// Whether the table contains text content (not empty)
@@ -111,7 +109,7 @@ fn scan_table_node(
                             }
                         }
                     }
-                    "table" if !is_root => scan.has_nested_table = true,
+                    "table" if !is_root => scan.nested_table_count += 1,
                     "tr" | "row" => {
                         let mut cell_count = 0;
                         for child in tag.children().top().iter() {
@@ -146,15 +144,3 @@ fn scan_table_node(
         }
     }
 }
-
-/// Normalize HTML tag names to lowercase.
-///
-/// Converts tag names to a consistent lowercase form for comparison.
-fn normalized_tag_name(raw: Cow<'_, str>) -> Cow<'_, str> {
-    let lowercased = raw.to_lowercase();
-    if lowercased.as_str() == raw.as_ref() {
-        raw
-    } else {
-        Cow::Owned(lowercased)
-    }
-}

data/vendor/html-to-markdown-rs/src/converter/block/table/utils.rs

@@ -2,24 +2,8 @@
 //!
 //! Provides helper functions for tag name normalization and comparison.
 
-use std::borrow::Cow;
-
-/// Normalize HTML tag names to lowercase.
-///
-/// Converts tag names to a consistent lowercase form for comparison.
-pub(super) fn normalized_tag_name(raw: Cow<'_, str>) -> Cow<'_, str> {
-    let lowercased = raw.to_lowercase();
-    if lowercased.as_str() == raw.as_ref() {
-        raw
-    } else {
-        Cow::Owned(lowercased)
-    }
-}
-
-/// Check tag name equality with case-insensitive comparison.
-pub(super) fn tag_name_eq(name: Cow<'_, str>, needle: &str) -> bool {
-    name.eq_ignore_ascii_case(needle)
-}
+pub(super) use crate::converter::main_helpers::tag_name_eq;
+pub(super) use crate::converter::utility::content::normalized_tag_name;
 
 /// Check if a node has a specific tag name.
 ///

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

@@ -12,6 +12,8 @@ use std::rc::Rc;
 #[cfg(feature = "inline-images")]
 use crate::inline_images::InlineImageCollector;
 
+use crate::types::structure_collector::StructureCollectorHandle;
+
 /// Handle type for inline image collector when feature is enabled.
 #[cfg(feature = "inline-images")]
 pub type InlineCollectorHandle = Rc<RefCell<InlineImageCollector>>;
@@ -99,6 +101,10 @@ pub struct Context {
     #[cfg(feature = "visitor")]
     /// Stores the first visitor error encountered during traversal.
     pub(crate) visitor_error: Rc<RefCell<Option<String>>>,
+    /// Optional structure collector for building a [`crate::types::DocumentStructure`].
+    ///
+    /// Populated when `options.include_document_structure == true`.
+    pub(crate) structure_collector: Option<StructureCollectorHandle>,
 }
 
 impl Context {
@@ -115,6 +121,7 @@ impl Context {
         #[cfg(not(feature = "metadata"))] _metadata_collector: Option<()>,
         #[cfg(feature = "visitor")] visitor: Option<crate::visitor::VisitorHandle>,
         #[cfg(not(feature = "visitor"))] _visitor: Option<()>,
+        structure_collector: Option<StructureCollectorHandle>,
     ) -> Self {
         #[cfg(feature = "metadata")]
         let (
@@ -178,6 +185,7 @@ impl Context {
             visitor: visitor.clone(),
             #[cfg(feature = "visitor")]
             visitor_error: Rc::new(RefCell::new(None)),
+            structure_collector,
         }
     }
 }

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

@@ -11,8 +11,6 @@ use crate::converter::main_helpers::is_inline_element;
 use crate::converter::utility::content::{is_block_level_name, normalized_tag_name};
 use crate::text;
 
-const TEXT_CACHE_CAPACITY: usize = 4096;
-
 /// Cached information about an HTML tag element.
 ///
 /// This struct stores pre-computed information about tag elements to avoid
@@ -236,11 +234,8 @@ impl DomContext {
                         .or_else(|| siblings.iter().position(|handle| handle.get_inner() == id))?;
 
                     for sibling in siblings.iter().skip(position + 1) {
-                        if let Some(info) = self.tag_info(sibling.get_inner(), parser) {
+                        if self.tag_info(sibling.get_inner(), parser).is_some() {
                             let sibling_id = sibling.get_inner();
-                            if info.name == "script" || info.name == "style" {
-                                return Some(sibling_id);
-                            }
                             return Some(sibling_id);
                         }
                         if let Some(tl::Node::Raw(raw)) = sibling.get(parser) {

data/vendor/html-to-markdown-rs/src/converter/form/elements.rs

@@ -27,7 +27,7 @@ use std::borrow::Cow;
 /// - **Inline mode**: Children are processed inline without block spacing
 /// - **Block mode**: Content is collected, trimmed, and wrapped with blank lines
 /// - **Empty content**: Skipped entirely
-pub fn handle_form(
+pub(crate) fn handle_form(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -82,7 +82,7 @@ pub fn handle_form(
 /// - **Inline mode**: Children are processed inline without block spacing
 /// - **Block mode**: Content is collected, trimmed, and wrapped with blank lines
 /// - **Empty content**: Skipped entirely
-pub fn handle_fieldset(
+pub(crate) fn handle_fieldset(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -137,7 +137,7 @@ pub fn handle_fieldset(
 /// - **Block mode**: Content is wrapped in strong markers (e.g., `**text**`)
 /// - **Inline mode**: Content is rendered without emphasis
 /// - Uses the configured strong/emphasis symbol from ConversionOptions
-pub fn handle_legend(
+pub(crate) fn handle_legend(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -198,7 +198,7 @@ pub fn handle_legend(
 /// - Content is collected from children
 /// - Non-empty content is output followed by blank lines (in block mode)
 /// - Blank lines are suppressed in inline mode
-pub fn handle_label(
+pub(crate) fn handle_label(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -231,7 +231,7 @@ pub fn handle_label(
 ///
 /// An input element represents a form control for user input. Since input
 /// elements typically have no text content, this handler produces no output.
-pub fn handle_input(
+pub(crate) fn handle_input(
     _tag_name: &str,
     _node_handle: &tl::NodeHandle,
     _parser: &tl::Parser,
@@ -253,7 +253,7 @@ pub fn handle_input(
 ///
 /// - Content is collected from children
 /// - Blank lines are added after content in block mode only
-pub fn handle_textarea(
+pub(crate) fn handle_textarea(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -287,7 +287,7 @@ pub fn handle_textarea(
 ///
 /// - Content (options) is collected from children
 /// - A single newline is added after the select in block mode
-pub fn handle_select(
+pub(crate) fn handle_select(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -322,7 +322,7 @@ pub fn handle_select(
 /// - Content is collected from children
 /// - If the option has the `selected` attribute, it's prefixed with `* ` in block mode
 /// - A newline is added after each option in block mode
-pub fn handle_option(
+pub(crate) fn handle_option(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -365,7 +365,7 @@ pub fn handle_option(
 ///
 /// - The `label` attribute is output as strong text (if present)
 /// - Options within the group are rendered normally
-pub fn handle_optgroup(
+pub(crate) fn handle_optgroup(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -410,7 +410,7 @@ pub fn handle_optgroup(
 ///
 /// - Content is collected from children
 /// - Blank lines are added after content in block mode only
-pub fn handle_button(
+pub(crate) fn handle_button(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -444,7 +444,7 @@ pub fn handle_button(
 ///
 /// - Content is collected from children (usually empty)
 /// - Blank lines are added after content in block mode only
-pub fn handle_progress(
+pub(crate) fn handle_progress(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -478,7 +478,7 @@ pub fn handle_progress(
 ///
 /// - Content is collected from children (usually empty)
 /// - Blank lines are added after content in block mode only
-pub fn handle_meter(
+pub(crate) fn handle_meter(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -512,7 +512,7 @@ pub fn handle_meter(
 ///
 /// - Content is collected from children
 /// - Blank lines are added after content in block mode only
-pub fn handle_output(
+pub(crate) fn handle_output(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,
@@ -546,7 +546,7 @@ pub fn handle_output(
 ///
 /// - Content (options) is collected from children
 /// - A single newline is added after the datalist in block mode
-pub fn handle_datalist(
+pub(crate) fn handle_datalist(
     _tag_name: &str,
     node_handle: &tl::NodeHandle,
     parser: &tl::Parser,