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

data/vendor/html-to-markdown-rs/src/converter/utility/serialization.rs

@@ -1,126 +0,0 @@
-//! Output serialization and formatting.
-//!
-//! Utilities for serializing HTML elements back to string format, used for preserving
-//! original HTML for elements like SVG, math, and custom elements.
-
-use crate::converter::utility::content::normalized_tag_name;
-
-/// Serialize an element to HTML string (for SVG and Math elements).
-#[allow(clippy::trivially_copy_pass_by_ref)]
-#[allow(dead_code)] // used with visitor feature
-pub fn serialize_element(node_handle: &tl::NodeHandle, parser: &tl::Parser) -> String {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        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);
-
-        for (key, value_opt) in tag.attributes().iter() {
-            html.push(' ');
-            html.push_str(&key);
-            if let Some(value) = value_opt {
-                html.push_str("=\"");
-                html.push_str(&value);
-                html.push('"');
-            }
-        }
-
-        let has_children = !tag.children().top().is_empty();
-        if has_children {
-            html.push('>');
-            let children = tag.children();
-            {
-                for child_handle in children.top().iter() {
-                    html.push_str(&serialize_node(child_handle, parser));
-                }
-            }
-            html.push_str("</");
-            html.push_str(&tag_name);
-            html.push('>');
-        } else {
-            html.push_str(" />");
-        }
-        return html;
-    }
-    String::new()
-}
-
-/// Serialize a node to HTML string.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-#[allow(dead_code)] // used with visitor feature
-pub fn serialize_node(node_handle: &tl::NodeHandle, parser: &tl::Parser) -> String {
-    if let Some(node) = node_handle.get(parser) {
-        match node {
-            tl::Node::Raw(bytes) => bytes.as_utf8_str().to_string(),
-            tl::Node::Tag(_) => serialize_element(node_handle, parser),
-            _ => String::new(),
-        }
-    } else {
-        String::new()
-    }
-}
-
-/// Serialize a tag to HTML, wrapping serialize_node_to_html.
-pub fn serialize_tag_to_html(handle: &tl::NodeHandle, parser: &tl::Parser) -> String {
-    let mut html = String::new();
-    serialize_node_to_html(handle, parser, &mut html);
-    html
-}
-
-/// Recursively serialize a node to HTML.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-#[allow(dead_code)] // used with visitor feature
-pub fn serialize_node_to_html(handle: &tl::NodeHandle, parser: &tl::Parser, output: &mut String) {
-    match handle.get(parser) {
-        Some(tl::Node::Tag(tag)) => {
-            let tag_name = normalized_tag_name(tag.name().as_utf8_str());
-
-            output.push('<');
-            output.push_str(&tag_name);
-
-            for (key, value) in tag.attributes().iter() {
-                output.push(' ');
-                output.push_str(&key);
-                if let Some(val) = value {
-                    output.push_str("=\"");
-                    output.push_str(&val);
-                    output.push('"');
-                }
-            }
-
-            output.push('>');
-
-            let children = tag.children();
-            for child_handle in children.top().iter() {
-                serialize_node_to_html(child_handle, parser, output);
-            }
-
-            if !matches!(
-                tag_name.as_ref(),
-                "br" | "hr"
-                    | "img"
-                    | "input"
-                    | "meta"
-                    | "link"
-                    | "area"
-                    | "base"
-                    | "col"
-                    | "embed"
-                    | "param"
-                    | "source"
-                    | "track"
-                    | "wbr"
-            ) {
-                output.push_str("</");
-                output.push_str(&tag_name);
-                output.push('>');
-            }
-        }
-        Some(tl::Node::Raw(bytes)) => {
-            if let Ok(text) = std::str::from_utf8(bytes.as_bytes()) {
-                output.push_str(text);
-            }
-        }
-        _ => {}
-    }
-}

data/vendor/html-to-markdown-rs/src/converter/utility/siblings.rs

@@ -1,97 +0,0 @@
-//! Sibling node navigation and handling.
-//!
-//! Utilities for working with sibling nodes in the DOM tree, including navigation functions
-//! and inline/block element detection for whitespace handling.
-
-use crate::converter::DomContext;
-
-/// Get the tag name of the next sibling element.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn get_next_sibling_tag<'a>(
-    node_handle: &tl::NodeHandle,
-    parser: &'a tl::Parser,
-    dom_ctx: &'a DomContext,
-) -> Option<&'a str> {
-    dom_ctx.next_tag_name(*node_handle, parser)
-}
-
-/// Get the tag name of the previous sibling element.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn get_previous_sibling_tag<'a>(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &'a DomContext,
-) -> Option<&'a str> {
-    let id = node_handle.get_inner();
-    let parent = dom_ctx.parent_of(id);
-
-    let siblings = if let Some(parent_id) = parent {
-        dom_ctx.children_of(parent_id)?
-    } else {
-        &dom_ctx.root_children
-    };
-
-    let position = dom_ctx.sibling_index(id).or_else(|| {
-        siblings
-            .iter()
-            .position(|handle: &tl::NodeHandle| handle.get_inner() == id)
-    })?;
-
-    for sibling in siblings.iter().take(position).rev() {
-        if let Some(info) = dom_ctx.tag_info(sibling.get_inner(), parser) {
-            return Some(info.name.as_str());
-        }
-        if let Some(tl::Node::Raw(raw)) = sibling.get(parser) {
-            if !raw.as_utf8_str().trim().is_empty() {
-                return None;
-            }
-        }
-    }
-
-    None
-}
-
-/// Check if the previous sibling is an inline tag.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn previous_sibling_is_inline_tag(node_handle: &tl::NodeHandle, parser: &tl::Parser, dom_ctx: &DomContext) -> bool {
-    dom_ctx.previous_inline_like(*node_handle, parser)
-}
-
-/// Check if the next sibling is whitespace-only text.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn next_sibling_is_whitespace_text(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &DomContext,
-) -> bool {
-    dom_ctx.next_whitespace_text(*node_handle, parser)
-}
-
-/// Check if the next sibling is an inline tag.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn next_sibling_is_inline_tag(node_handle: &tl::NodeHandle, parser: &tl::Parser, dom_ctx: &DomContext) -> bool {
-    dom_ctx.next_inline_like(*node_handle, parser)
-}
-
-/// Append an inline suffix to output, with smart whitespace handling.
-///
-/// Avoids adding spaces before siblings that are already whitespace.
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn append_inline_suffix(
-    output: &mut String,
-    suffix: &str,
-    has_core_content: bool,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &DomContext,
-) {
-    if suffix.is_empty() {
-        return;
-    }
-
-    if suffix == " " && has_core_content && next_sibling_is_whitespace_text(node_handle, parser, dom_ctx) {
-        return;
-    }
-
-    output.push_str(suffix);
-}

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

@@ -1,189 +0,0 @@
-//! Visitor callback hooks for custom HTML traversal during conversion.
-//!
-//! This module contains the visitor pattern implementation hooks that are called
-//! before and after element processing during the HTML to Markdown conversion tree walk.
-//! These hooks enable custom processing, analysis, or modification of elements during conversion.
-
-use std::collections::BTreeMap;
-
-#[cfg(feature = "visitor")]
-use crate::converter::utility::content::collect_tag_attributes;
-use crate::converter::utility::content::is_block_level_element;
-use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-/// Handles visitor callback for element start (before processing).
-///
-/// This function is called when entering an element during tree traversal,
-/// before the element's content is processed. The visitor can:
-/// - Continue with normal processing (Continue)
-/// - Skip the element entirely (Skip)
-/// - Provide custom output to replace the element (Custom)
-/// - Signal an error (Error)
-///
-/// # Arguments
-///
-/// * `visitor_handle` - Reference to the visitor for callbacks
-/// * `tag_name` - The normalized tag name being processed
-/// * `node_handle` - Handle to the DOM node
-/// * `tag` - Reference to the tag object
-/// * `parser` - Reference to the tl parser
-/// * `output` - Mutable reference to output string
-/// * `ctx` - Reference to the conversion context
-/// * `depth` - Current tree depth
-/// * `dom_ctx` - Reference to DOM context for tree navigation
-///
-/// # Returns
-///
-/// `VisitAction` enum indicating what should happen next:
-/// - `VisitAction::Continue` - Process element normally
-/// - `VisitAction::Skip` - Skip element, don't process or call visit_element_end
-/// - `VisitAction::Custom(output)` - Use custom output, skip normal processing
-/// - `VisitAction::Error` - Stop processing with error
-pub fn handle_visitor_element_start(
-    visitor_handle: &crate::visitor::VisitorHandle,
-    tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    tag: &tl::HTMLTag,
-    parser: &tl::Parser<'_>,
-    output: &mut String,
-    _ctx: &crate::converter::Context,
-    depth: usize,
-    dom_ctx: &crate::converter::DomContext,
-) -> VisitAction {
-    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);
-    let index_in_parent = dom_ctx.get_sibling_index(node_id).unwrap_or(0);
-
-    let node_ctx = NodeContext {
-        node_type: NodeType::Element,
-        tag_name: tag_name.to_string(),
-        attributes,
-        depth,
-        index_in_parent,
-        parent_tag,
-        is_inline: !is_block_level_element(tag_name),
-    };
-
-    let visitor_start_result = {
-        let mut visitor = visitor_handle.borrow_mut();
-        visitor.visit_element_start(&node_ctx)
-    };
-
-    match visitor_start_result {
-        crate::visitor::VisitResult::Continue => VisitAction::Continue,
-        crate::visitor::VisitResult::Skip => VisitAction::Skip,
-        crate::visitor::VisitResult::Custom(custom_output) => {
-            output.push_str(&custom_output);
-
-            // For custom output, still call visit_element_end (except for tables)
-            if !matches!(tag_name, "table") {
-                let element_content = &custom_output;
-                let mut visitor = visitor_handle.borrow_mut();
-                let _ = visitor.visit_element_end(&node_ctx, element_content);
-            }
-
-            VisitAction::Custom
-        }
-        crate::visitor::VisitResult::Error(_msg) => VisitAction::Error,
-        _ => VisitAction::Continue,
-    }
-}
-
-/// Handles visitor callback for element end (after processing).
-///
-/// This function is called when exiting an element after its content has been processed.
-/// The visitor can:
-/// - Accept the output normally (Continue)
-/// - Replace the output with custom content (Custom)
-/// - Remove the output entirely (Skip)
-/// - Signal an error (Error)
-///
-/// # Arguments
-///
-/// * `visitor_handle` - Reference to the visitor for callbacks
-/// * `tag_name` - The normalized tag name that was processed
-/// * `node_handle` - Handle to the DOM node
-/// * `tag` - Reference to the tag object
-/// * `parser` - Reference to the tl parser
-/// * `output` - Mutable reference to output string
-/// * `element_output_start` - Byte position where this element's output started
-/// * `ctx` - Reference to the conversion context
-/// * `depth` - Current tree depth
-/// * `dom_ctx` - Reference to DOM context for tree navigation
-pub fn handle_visitor_element_end(
-    visitor_handle: &crate::visitor::VisitorHandle,
-    tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    tag: &tl::HTMLTag,
-    parser: &tl::Parser<'_>,
-    output: &mut String,
-    element_output_start: usize,
-    ctx: &crate::converter::Context,
-    depth: usize,
-    dom_ctx: &crate::converter::DomContext,
-) {
-    // Skip visitor callback for table elements
-    if matches!(tag_name, "table") {
-        return;
-    }
-
-    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);
-    let index_in_parent = dom_ctx.get_sibling_index(node_id).unwrap_or(0);
-
-    let node_ctx = NodeContext {
-        node_type: NodeType::Element,
-        tag_name: tag_name.to_string(),
-        attributes,
-        depth,
-        index_in_parent,
-        parent_tag,
-        is_inline: !is_block_level_element(tag_name),
-    };
-
-    // The saved `element_output_start` can become stale in two ways:
-    // 1. A child visitor returning Custom/Skip truncates `output`, making the
-    //    saved position point past the end of the now-shorter string.
-    // 2. Element handlers (e.g. div) trim trailing whitespace that was present
-    //    when the position was captured, then append new multi-byte content.
-    //    The old position can land inside a multi-byte character.
-    // Clamp to output length, then retreat to a valid char boundary.
-    let safe_start = element_output_start.min(output.len());
-    let safe_start = crate::converter::utility::content::floor_char_boundary(output, safe_start);
-    let element_content = &output[safe_start..];
-
-    let mut visitor = visitor_handle.borrow_mut();
-    match visitor.visit_element_end(&node_ctx, element_content) {
-        VisitResult::Continue => {}
-        VisitResult::Custom(custom) => {
-            output.truncate(safe_start);
-            output.push_str(&custom);
-        }
-        VisitResult::Skip => {
-            output.truncate(safe_start);
-        }
-        VisitResult::Error(err) => {
-            if ctx.visitor_error.borrow().is_none() {
-                *ctx.visitor_error.borrow_mut() = Some(err);
-            }
-        }
-        VisitResult::PreserveHtml => {}
-    }
-}
-
-/// Result of visitor element start callback indicating what should happen next.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum VisitAction {
-    /// Continue with normal element processing
-    Continue,
-    /// Skip the element entirely (don't process children or call visit_element_end)
-    Skip,
-    /// Custom output was provided, skip normal processing
-    Custom,
-    /// Error occurred during visitor callback
-    Error,
-}

data/vendor/html-to-markdown-rs/src/error.rs

@@ -1,43 +0,0 @@
-//! Error types for HTML to Markdown conversion.
-
-use thiserror::Error;
-
-/// Result type for conversion operations.
-pub type Result<T> = std::result::Result<T, ConversionError>;
-
-/// Errors that can occur during HTML to Markdown conversion.
-#[derive(Error, Debug)]
-pub enum ConversionError {
-    /// HTML parsing error
-    #[error("HTML parsing error: {0}")]
-    ParseError(String),
-
-    /// HTML sanitization error
-    #[error("Sanitization error: {0}")]
-    SanitizationError(String),
-
-    /// Invalid configuration
-    #[error("Invalid configuration: {0}")]
-    ConfigError(String),
-
-    /// I/O error
-    #[error("I/O error: {0}")]
-    IoError(#[from] std::io::Error),
-
-    /// Panic caught during conversion to prevent unwinding across FFI boundaries
-    #[error("Internal panic: {0}")]
-    Panic(String),
-
-    /// Invalid input data
-    #[error("Invalid input: {0}")]
-    InvalidInput(String),
-
-    /// Visitor callback error
-    #[cfg(feature = "visitor")]
-    #[error("Visitor error: {0}")]
-    Visitor(String),
-
-    /// Generic conversion error
-    #[error("Conversion error: {0}")]
-    Other(String),
-}

data/vendor/html-to-markdown-rs/src/exports.rs

@@ -1,24 +0,0 @@
-//! Public API re-exports from submodules.
-//!
-//! This module centralizes all public type and function exports,
-//! making the crate's public interface clear and organized.
-
-pub use crate::error::{ConversionError, Result};
-
-#[cfg(feature = "inline-images")]
-pub use crate::inline_images::{
-    DEFAULT_INLINE_IMAGE_LIMIT, HtmlExtraction, InlineImage, InlineImageConfig, InlineImageConfigUpdate,
-    InlineImageFormat, InlineImageSource, InlineImageWarning,
-};
-
-#[cfg(feature = "metadata")]
-pub use crate::metadata::{
-    DEFAULT_MAX_STRUCTURED_DATA_SIZE, DocumentMetadata, HeaderMetadata, HtmlMetadata, ImageMetadata, ImageType,
-    LinkMetadata, LinkType, MetadataConfig, MetadataConfigUpdate, StructuredData, StructuredDataType, TextDirection,
-};
-
-pub use crate::options::{
-    CodeBlockStyle, ConversionOptions, ConversionOptionsBuilder, ConversionOptionsUpdate, HeadingStyle, HighlightStyle,
-    LinkStyle, ListIndentType, NewlineStyle, OutputFormat, PreprocessingOptions, PreprocessingOptionsUpdate,
-    PreprocessingPreset, WhitespaceMode,
-};