html-to-markdown 3.4.0 → 3.6.0.pre.rc.24

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

@@ -1,112 +0,0 @@
-//! Semantic HTML5 element handlers for HTML to Markdown conversion.
-//!
-//! This module provides specialized handlers for semantic HTML5 elements:
-//! - Sectioning elements (article, section, nav, aside, header, footer, main)
-//! - Figure elements (figure, figcaption)
-//! - Interactive elements (details, summary, dialog)
-//! - Semantic inline attributes (cite, q, abbr, dfn, time, data)
-//!
-//! These handlers are designed to be extracted from the main `converter.rs`
-//! file and integrated through the dispatcher function.
-//!
-//! **Integration Pattern:**
-//! Each handler function takes the same signature:
-//! - `tag_name: &str` - The HTML tag being processed
-//! - `node_handle: &NodeHandle` - The DOM node handle
-//! - `parser: &Parser` - The HTML parser reference
-//! - `output: &mut String` - The output buffer to write to
-//! - `options: &ConversionOptions` - Conversion configuration
-//! - `ctx: &Context` - Processing context (state tracking)
-//! - `depth: usize` - Current DOM tree depth
-//! - `dom_ctx: &DomContext` - DOM context for tree relationships
-//!
-//! The main dispatcher function `dispatch_semantic_handler` routes tags to
-//! their appropriate handlers and returns a boolean indicating success.
-
-pub mod attributes;
-pub mod definition_list;
-pub mod figure;
-pub mod sectioning;
-pub mod summary;
-
-// Re-export types from parent module for submodule access
-pub use super::walk_node;
-pub use super::{Context, DomContext};
-
-// Re-export handler functions for direct use
-pub use attributes::handle as handle_attributes;
-pub use definition_list::handle as handle_definition_list;
-pub use figure::handle as handle_figure;
-pub use sectioning::handle as handle_sectioning;
-pub use summary::handle as handle_summary;
-
-// Re-exports are done via the dispatch function parameter types
-
-/// Dispatches semantic element handling to the appropriate handler.
-///
-/// This function routes semantic HTML5 elements to their specialized handlers
-/// based on tag name. It is designed to be called from the main `walk_node`
-/// function in `converter.rs`.
-///
-/// # Routing Table
-///
-/// The following tag routes are supported:
-/// - **Sectioning**: article, section, nav, aside, header, footer, main
-/// - **Figure**: figure, figcaption
-/// - **Summary**: details, summary, dialog
-/// - **Definition List**: hgroup, dl, dt, dd, menu
-/// - **Attributes**: cite, q, abbr, dfn, time, data
-///
-/// # Returns
-///
-/// Returns `true` if the tag was successfully handled by a semantic handler,
-/// `false` if the tag is not a semantic element and requires other handling.
-///
-/// # Example
-///
-/// ```text
-/// if dispatch_semantic_handler(tag_name, &node_handle, &parser, output, options, ctx, depth, dom_ctx) {
-///     // Tag was handled
-/// } else {
-///     // Continue with other handlers
-/// }
-/// ```
-pub fn dispatch_semantic_handler(
-    tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) -> bool {
-    match tag_name {
-        // Sectioning elements
-        "article" | "section" | "nav" | "aside" | "header" | "footer" | "main" => {
-            handle_sectioning(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx);
-            true
-        }
-        // Figure elements
-        "figure" | "figcaption" => {
-            handle_figure(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx);
-            true
-        }
-        // Summary and interactive elements
-        "details" | "summary" | "dialog" => {
-            handle_summary(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx);
-            true
-        }
-        // Definition list and related elements
-        "hgroup" | "dl" | "dt" | "dd" | "menu" => {
-            handle_definition_list(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx);
-            true
-        }
-        // Semantic inline attributes
-        "cite" | "q" | "abbr" | "dfn" | "time" | "data" => {
-            handle_attributes(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx);
-            true
-        }
-        _ => false,
-    }
-}

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

@@ -1,85 +0,0 @@
-//! Handlers for HTML5 sectioning elements.
-//!
-//! Processes semantic sectioning elements:
-//! - `<article>` - Independent, self-contained content
-//! - `<section>` - Generic grouping of thematic content
-//! - `<nav>` - Navigation links (typically rendered inline or in sidebars)
-//! - `<aside>` - Peripheral content (sidebars, callouts)
-//! - `<header>` - Introductory content (page headers)
-//! - `<footer>` - End content (page footers)
-//! - `<main>` - Primary content area
-//!
-//! All these elements are treated as block-level containers.
-//! Their content is extracted and formatted with proper spacing.
-
-// Note: Context and DomContext are defined in converter.rs
-// walk_node is also defined there and must be called via the parent module
-
-/// Handles sectioning elements (article, section, nav, aside, header, footer, main).
-///
-/// Sectioning elements are rendered as block-level containers. When in inline
-/// conversion mode, their content is rendered inline without block spacing.
-/// Otherwise, content is wrapped with proper blank lines to separate from other blocks.
-///
-/// # Behavior
-///
-/// - **Inline mode**: Children are processed inline; block spacing is skipped
-/// - **Block mode**: Content is collected, trimmed, and formatted with blank lines
-/// - **Empty content**: Empty sections are skipped entirely
-///
-/// # Implementation Note
-///
-/// Sectioning elements act as transparent containers—their presence doesn't
-/// add any special formatting beyond structural grouping.
-pub fn handle(
-    _tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        // In inline context, just process children inline
-        if ctx.convert_as_inline {
-            let children = tag.children();
-            {
-                for child_handle in children.top().iter() {
-                    super::walk_node(child_handle, parser, output, options, ctx, depth + 1, dom_ctx);
-                }
-            }
-            return;
-        }
-
-        // Collect content in a separate buffer
-        let mut content = String::with_capacity(256);
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                super::walk_node(child_handle, parser, &mut content, options, ctx, depth + 1, dom_ctx);
-            }
-        }
-
-        // Skip if content is empty
-        if content.trim().is_empty() {
-            return;
-        }
-
-        // Add spacing before the content
-        if !output.is_empty() && !output.ends_with("\n\n") {
-            output.push_str("\n\n");
-        }
-
-        // Append the content
-        output.push_str(&content);
-
-        // Ensure proper spacing after the content
-        if content.ends_with('\n') && !content.ends_with("\n\n") {
-            output.push('\n');
-        } else if !content.ends_with('\n') {
-            output.push_str("\n\n");
-        }
-    }
-}

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

@@ -1,324 +0,0 @@
-//! Handlers for HTML5 interactive elements.
-//!
-//! Processes interactive disclosure and dialog semantic elements:
-//! - `<details>` - Expandable/collapsible disclosure widget
-//! - `<summary>` - Summary or caption for a details element
-//! - `<dialog>` - Dialog box overlay widget
-//!
-//! These elements are treated as block-level content containers
-//! with special formatting for the summary element.
-
-// Note: Context and DomContext are defined in converter.rs
-// walk_node is also defined there and must be called via the parent module
-use super::walk_node;
-
-/// Handles the `<details>` element.
-///
-/// A details element represents a disclosure widget that can be toggled
-/// to show/hide additional content. In Markdown, it's rendered as a block
-/// with all content visible.
-///
-/// # Behavior
-///
-/// - **Inline mode**: Children are processed inline without block spacing
-/// - **Block mode**: Content is collected and wrapped with proper blank-line spacing
-/// - **Empty content**: Skipped entirely
-#[cfg_attr(not(feature = "visitor"), allow(unused_variables))]
-pub fn handle_details(
-    _tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        #[cfg(feature = "visitor")]
-        if let Some(ref visitor_handle) = ctx.visitor {
-            use crate::converter::utility::content::collect_tag_attributes;
-            use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-            let attributes = collect_tag_attributes(tag);
-            let node_id = node_handle.get_inner();
-            let parent_tag = dom_ctx.parent_tag_name(node_id, parser);
-            let index_in_parent = dom_ctx.get_sibling_index(node_id).unwrap_or(0);
-            let open = tag.attributes().get("open").is_some();
-            let node_ctx = NodeContext {
-                node_type: NodeType::Details,
-                tag_name: "details".to_string(),
-                attributes,
-                depth,
-                index_in_parent,
-                parent_tag,
-                is_inline: false,
-            };
-            let visit_result = {
-                let mut visitor = visitor_handle.borrow_mut();
-                visitor.visit_details(&node_ctx, open)
-            };
-            match visit_result {
-                VisitResult::Continue => {}
-                VisitResult::Skip => return,
-                VisitResult::Custom(custom) => {
-                    if !output.is_empty() && !output.ends_with("\n\n") {
-                        output.push_str("\n\n");
-                    }
-                    output.push_str(&custom);
-                    output.push_str("\n\n");
-                    return;
-                }
-                VisitResult::PreserveHtml => {
-                    use crate::converter::utility::serialization::serialize_node;
-                    output.push_str(&serialize_node(node_handle, parser));
-                    return;
-                }
-                VisitResult::Error(err) => {
-                    if ctx.visitor_error.borrow().is_none() {
-                        *ctx.visitor_error.borrow_mut() = Some(err);
-                    }
-                    return;
-                }
-            }
-        }
-
-        // In inline context, just process children inline
-        if ctx.convert_as_inline {
-            let children = tag.children();
-            {
-                for child_handle in children.top().iter() {
-                    super::walk_node(child_handle, parser, output, options, ctx, depth, dom_ctx);
-                }
-            }
-            return;
-        }
-
-        // Collect content
-        let mut content = String::with_capacity(256);
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                walk_node(child_handle, parser, &mut content, options, ctx, depth, dom_ctx);
-            }
-        }
-
-        let trimmed = content.trim();
-        if !trimmed.is_empty() {
-            // Add spacing before if needed
-            if !output.is_empty() && !output.ends_with("\n\n") {
-                output.push_str("\n\n");
-            }
-
-            // Output content
-            output.push_str(trimmed);
-            output.push_str("\n\n");
-        }
-    }
-}
-
-/// Handles the `<summary>` element.
-///
-/// A summary element contains a caption for a details element.
-/// It is rendered as strong (bold) text to distinguish it from regular content.
-///
-/// # Behavior
-///
-/// - **Inline mode**: Content is rendered inline without emphasis
-/// - **Block mode**: Content is wrapped in strong markers (e.g., `**text**`)
-/// - Uses the configured strong/emphasis symbol from ConversionOptions
-///
-/// # Implementation Details
-///
-/// The handler:
-/// 1. Creates a context with `in_strong: true` for nested formatting
-/// 2. Collects content from all children
-/// 3. Wraps non-empty content in strong markers (repeated twice per Markdown spec)
-#[cfg_attr(not(feature = "visitor"), allow(unused_variables))]
-pub fn handle_summary(
-    _tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        let mut content = String::with_capacity(64);
-
-        // Set strong context for nested content
-        let mut summary_ctx = ctx.clone();
-        if !ctx.convert_as_inline {
-            summary_ctx.in_strong = true;
-        }
-
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                super::walk_node(
-                    child_handle,
-                    parser,
-                    &mut content,
-                    options,
-                    &summary_ctx,
-                    depth + 1,
-                    dom_ctx,
-                );
-            }
-        }
-
-        let trimmed = content.trim().to_owned();
-        if trimmed.is_empty() {
-            return;
-        }
-
-        #[cfg(feature = "visitor")]
-        if let Some(ref visitor_handle) = ctx.visitor {
-            use crate::converter::utility::content::collect_tag_attributes;
-            use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-            let attributes = collect_tag_attributes(tag);
-            let node_id = node_handle.get_inner();
-            let parent_tag = dom_ctx.parent_tag_name(node_id, parser);
-            let index_in_parent = dom_ctx.get_sibling_index(node_id).unwrap_or(0);
-            let node_ctx = NodeContext {
-                node_type: NodeType::Summary,
-                tag_name: "summary".to_string(),
-                attributes,
-                depth,
-                index_in_parent,
-                parent_tag,
-                is_inline: false,
-            };
-            let visit_result = {
-                let mut visitor = visitor_handle.borrow_mut();
-                visitor.visit_summary(&node_ctx, &trimmed)
-            };
-            match visit_result {
-                VisitResult::Continue => {}
-                VisitResult::Skip => return,
-                VisitResult::Custom(custom) => {
-                    if ctx.convert_as_inline {
-                        output.push_str(&custom);
-                    } else {
-                        output.push_str(&custom);
-                        if !custom.ends_with('\n') {
-                            output.push_str("\n\n");
-                        }
-                    }
-                    return;
-                }
-                VisitResult::PreserveHtml => {
-                    use crate::converter::utility::serialization::serialize_node;
-                    output.push_str(&serialize_node(node_handle, parser));
-                    return;
-                }
-                VisitResult::Error(err) => {
-                    if ctx.visitor_error.borrow().is_none() {
-                        *ctx.visitor_error.borrow_mut() = Some(err);
-                    }
-                    return;
-                }
-            }
-        }
-
-        if ctx.convert_as_inline {
-            // Inline mode: output without formatting
-            output.push_str(&trimmed);
-        } else {
-            // Block mode: output with strong markers
-            let mut symbol = String::with_capacity(2);
-            symbol.push(options.strong_em_symbol);
-            symbol.push(options.strong_em_symbol);
-            output.push_str(&symbol);
-            output.push_str(&trimmed);
-            output.push_str(&symbol);
-            output.push_str("\n\n");
-        }
-    }
-}
-
-/// Handles the `<dialog>` element.
-///
-/// A dialog element represents a modal dialog box. In Markdown, it's rendered
-/// as a block container with content visible.
-///
-/// # Behavior
-///
-/// - **Inline mode**: Children are processed inline without block spacing
-/// - **Block mode**: Content is processed and wrapped with proper blank lines
-/// - Trailing whitespace is removed from collected content
-///
-/// # Implementation Details
-///
-/// The handler:
-/// 1. Marks the position in output before processing children
-/// 2. Processes all children in the normal context
-/// 3. Removes trailing spaces and tabs from the output
-/// 4. Ensures proper blank-line spacing after the dialog
-pub fn handle_dialog(
-    _tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        // In inline context, just process children inline
-        if ctx.convert_as_inline {
-            let children = tag.children();
-            {
-                for child_handle in children.top().iter() {
-                    super::walk_node(child_handle, parser, output, options, ctx, depth, dom_ctx);
-                }
-            }
-            return;
-        }
-
-        // Mark position before processing children
-        let content_start = output.len();
-
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                super::walk_node(child_handle, parser, output, options, ctx, depth, dom_ctx);
-            }
-        }
-
-        // Remove trailing whitespace from dialog content
-        while output.len() > content_start && (output.ends_with(' ') || output.ends_with('\t')) {
-            output.pop();
-        }
-
-        // Ensure proper spacing after dialog
-        if output.len() > content_start && !output.ends_with("\n\n") {
-            output.push_str("\n\n");
-        }
-    }
-}
-
-/// Dispatcher for interactive elements.
-///
-/// Routes `<details>`, `<summary>`, and `<dialog>` elements to their respective handlers.
-pub fn handle(
-    tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::Context,
-    depth: usize,
-    dom_ctx: &super::DomContext,
-) {
-    match tag_name {
-        "details" => handle_details(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx),
-        "summary" => handle_summary(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx),
-        "dialog" => handle_dialog(tag_name, node_handle, parser, output, options, ctx, depth, dom_ctx),
-        _ => {}
-    }
-}

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

@@ -1,8 +0,0 @@
-//! Text processing module for HTML to Markdown conversion.
-//!
-//! This module provides utilities for normalizing, escaping, and processing text content
-//! extracted from HTML documents during the conversion to Markdown format.
-
-mod processing;
-
-pub use processing::dedent_code_block;

data/vendor/html-to-markdown-rs/src/converter/text/processing.rs

@@ -1,56 +0,0 @@
-//! Text processing utilities for HTML to Markdown conversion.
-//!
-//! This module provides functions for processing text content, including
-//! code block dedentation and special character handling.
-
-/// Remove common leading whitespace from all lines in a code block.
-///
-/// This is useful when HTML authors indent `<pre>` content for readability,
-/// so we can strip the shared indentation without touching meaningful spacing.
-///
-/// # Examples
-///
-/// ```text
-/// "    line1\n    line2" → "line1\nline2"
-/// "  indent1\n    indent2" → "indent1\n  indent2" (removes 2 chars, minimum indent)
-/// "  \n  code" → "\ncode"
-/// ```
-pub fn dedent_code_block(content: &str) -> String {
-    let lines: Vec<&str> = content.lines().collect();
-    if lines.is_empty() {
-        return String::new();
-    }
-
-    let min_indent = lines
-        .iter()
-        .filter(|line| !line.trim().is_empty())
-        .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())
-        .min()
-        .unwrap_or(0);
-
-    lines.iter().fold(String::new(), |mut acc, line| {
-        if !acc.is_empty() {
-            acc.push('\n');
-        }
-        let processed = if line.trim().is_empty() {
-            *line
-        } else {
-            let mut remaining = min_indent;
-            let mut cut = 0;
-            for (idx, ch) in line.char_indices() {
-                if remaining == 0 {
-                    break;
-                }
-                if ch.is_whitespace() {
-                    remaining -= 1;
-                    cut = idx + ch.len_utf8();
-                } else {
-                    break;
-                }
-            }
-            &line[cut..]
-        };
-        acc.push_str(processed);
-        acc
-    })
-}