html-to-markdown 3.2.4 → 3.4.0.pre.rc.13

data/sig/html_to_markdown.rbs

@@ -1,149 +0,0 @@
-# Native extension module (Magnus/rb-sys)
-module HtmlToMarkdownRs
-  class ConversionOptions
-    def initialize: (Hash[Symbol, untyped]) -> void
-  end
-
-  class ConversionResult
-    def content: () -> String?
-  end
-
-  def self.convert: (String html, ConversionOptions? options) -> ConversionResult
-end
-
-# Type definitions for HtmlToMarkdown Ruby gem
-module HtmlToMarkdown
-  VERSION: String
-
-  type heading_style = :underlined | :atx | :atx_closed
-  type list_indent_type = :spaces | :tabs
-  type highlight_style = :double_equal | :html | :bold | :none
-  type whitespace_mode = :normalized | :strict
-  type newline_style = :spaces | :backslash
-  type code_block_style = :indented | :backticks | :tildes
-  type link_style = :inline | :reference
-  type output_format = :markdown | :djot
-  type preprocessing_preset = :minimal | :standard | :aggressive
-
-  type preprocessing_options = {
-    enabled?: bool,
-    preset?: preprocessing_preset,
-    remove_navigation?: bool,
-    remove_forms?: bool
-  }
-
-  type conversion_options = {
-    heading_style?: heading_style,
-    list_indent_type?: list_indent_type,
-    list_indent_width?: Integer,
-    bullets?: String,
-    strong_em_symbol?: String,
-    escape_asterisks?: bool,
-    escape_underscores?: bool,
-    escape_misc?: bool,
-    escape_ascii?: bool,
-    code_language?: String,
-    autolinks?: bool,
-    default_title?: bool,
-    br_in_tables?: bool,
-    highlight_style?: highlight_style,
-    extract_metadata?: bool,
-    whitespace_mode?: whitespace_mode,
-    strip_newlines?: bool,
-    wrap?: bool,
-    wrap_width?: Integer,
-    convert_as_inline?: bool,
-    sub_symbol?: String,
-    sup_symbol?: String,
-    newline_style?: newline_style,
-    code_block_style?: code_block_style,
-    keep_inline_images_in?: Array[String],
-    preprocessing?: preprocessing_options,
-    encoding?: String,
-    debug?: bool,
-    strip_tags?: Array[String],
-    preserve_tags?: Array[String],
-    link_style?: link_style,
-    output_format?: output_format,
-    skip_images?: bool,
-    include_document_structure?: bool,
-    extract_images?: bool,
-    max_image_size?: Integer,
-    capture_svg?: bool,
-    infer_dimensions?: bool
-  }
-
-  type text_direction = "ltr" | "rtl" | "auto" | nil
-
-  type document_metadata = {
-    title: String?,
-    description: String?,
-    keywords: Array[String],
-    author: String?,
-    canonical_url: String?,
-    base_href: String?,
-    language: String?,
-    text_direction: text_direction,
-    open_graph: Hash[String, String],
-    twitter_card: Hash[String, String],
-    meta_tags: Hash[String, String]
-  }
-
-  type header_metadata = {
-    level: Integer,
-    text: String,
-    id: String?,
-    depth: Integer,
-    html_offset: Integer
-  }
-
-  type link_type = "anchor" | "internal" | "external" | "email" | "phone" | "other"
-
-  type link_metadata = {
-    href: String,
-    text: String,
-    title: String?,
-    link_type: link_type,
-    rel: Array[String],
-    attributes: Hash[String, String]
-  }
-
-  type image_type = "data_uri" | "inline_svg" | "external" | "relative"
-
-  type image_metadata = {
-    src: String,
-    alt: String?,
-    title: String?,
-    dimensions: [Integer, Integer]?,
-    image_type: image_type,
-    attributes: Hash[String, String]
-  }
-
-  type structured_data = {
-    data_type: "json_ld" | "microdata" | "rdfa",
-    raw_json: String,
-    schema_type: String?
-  }
-
-  type extended_metadata = {
-    document: document_metadata,
-    headers: Array[header_metadata],
-    links: Array[link_metadata],
-    images: Array[image_metadata],
-    structured_data: Array[structured_data]
-  }
-
-  # Native method (implemented in Rust via Magnus/rb-sys)
-  private
-
-  def self.native_convert: (String html, conversion_options? options) -> Hash[String, untyped]
-  def native_convert: (String html, conversion_options? options) -> Hash[String, untyped]
-
-  public
-
-  # Convert HTML to Markdown, returning the markdown content string.
-  #
-  # Example:
-  #   result = HtmlToMarkdown.convert(html)
-  def self.convert: (String html, ?conversion_options options) -> String
-end

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

@@ -1,94 +0,0 @@
-//! Escaping utilities for Markdown special characters.
-//!
-//! This module provides functions for escaping characters that have special meaning
-//! in Markdown, including brackets in link labels and angle brackets.
-
-use std::borrow::Cow;
-
-/// Escape special characters in link labels.
-///
-/// Markdown link labels can contain brackets, which need careful escaping to avoid
-/// being interpreted as nested links. This function escapes unescaped closing brackets
-/// that would break the link syntax.
-///
-/// # Examples
-///
-/// ```text
-/// "Simple text" → "Simple text"
-/// "Text [with brackets]" → "Text [with brackets\]"
-/// "Text \\[escaped\\]" → "Text \\[escaped\\]"
-/// ```
-pub fn escape_link_label(text: &str) -> String {
-    crate::converter::utility::content::escape_link_label(text)
-}
-
-/// Escape malformed angle brackets in markdown output.
-///
-/// Markdown uses `<...>` for automatic links. Angle brackets that don't form valid
-/// link syntax should be escaped as `&lt;` to prevent parser confusion.
-///
-/// A valid tag must have:
-/// - `<!` followed by `-` or alphabetic character (for comments/declarations)
-/// - `</` followed by alphabetic character (for closing tags)
-/// - `<?` (for processing instructions)
-/// - `<` followed by alphabetic character (for opening tags)
-///
-/// # Examples
-///
-/// ```text
-/// "<valid@example.com>" → "<valid@example.com>" (unchanged, valid link)
-/// "< invalid" → "&lt; invalid" (escaped, invalid)
-/// "Text <2 more" → "Text &lt;2 more" (escaped, invalid)
-/// ```
-pub fn escape_malformed_angle_brackets(input: &str) -> Cow<'_, str> {
-    let bytes = input.as_bytes();
-    let len = bytes.len();
-    let mut idx = 0;
-    let mut last = 0;
-    let mut output: Option<String> = None;
-
-    while idx < len {
-        if bytes[idx] == b'<' {
-            if idx + 1 < len {
-                let next = bytes[idx + 1];
-
-                let is_valid_tag = match next {
-                    b'!' => {
-                        idx + 2 < len
-                            && (bytes[idx + 2] == b'-'
-                                || bytes[idx + 2].is_ascii_alphabetic()
-                                || bytes[idx + 2].is_ascii_uppercase())
-                    }
-                    b'/' => {
-                        idx + 2 < len && (bytes[idx + 2].is_ascii_alphabetic() || bytes[idx + 2].is_ascii_uppercase())
-                    }
-                    b'?' => true,
-                    c if c.is_ascii_alphabetic() || c.is_ascii_uppercase() => true,
-                    _ => false,
-                };
-
-                if !is_valid_tag {
-                    let out = output.get_or_insert_with(|| String::with_capacity(input.len() + 4));
-                    out.push_str(&input[last..idx]);
-                    out.push_str("&lt;");
-                    last = idx + 1;
-                }
-            } else {
-                let out = output.get_or_insert_with(|| String::with_capacity(input.len() + 4));
-                out.push_str(&input[last..idx]);
-                out.push_str("&lt;");
-                last = idx + 1;
-            }
-        }
-        idx += 1;
-    }
-
-    if let Some(mut out) = output {
-        if last < input.len() {
-            out.push_str(&input[last..]);
-        }
-        Cow::Owned(out)
-    } else {
-        Cow::Borrowed(input)
-    }
-}

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

@@ -1,86 +0,0 @@
-//! Text normalization utilities for HTML to Markdown conversion.
-//!
-//! This module provides functions for normalizing text content extracted from HTML,
-//! including chomping whitespace, normalizing heading text, and handling trailing whitespace.
-
-use std::borrow::Cow;
-
-/// Remove trailing spaces/tabs from every line while preserving newlines.
-pub fn trim_line_end_whitespace(output: &mut String) {
-    if output.is_empty() {
-        return;
-    }
-
-    let mut cleaned = String::with_capacity(output.len());
-    for (idx, line) in output.split('\n').enumerate() {
-        if idx > 0 {
-            cleaned.push('\n');
-        }
-
-        let has_soft_break = line.ends_with("  ");
-        let trimmed = line.trim_end_matches([' ', '\t']);
-
-        cleaned.push_str(trimmed);
-        if has_soft_break {
-            cleaned.push_str("  ");
-        }
-    }
-
-    cleaned.push('\n');
-    *output = cleaned;
-}
-
-/// Truncate a string at a valid UTF-8 boundary.
-pub fn truncate_at_char_boundary(value: &mut String, max_len: usize) {
-    if value.len() <= max_len {
-        return;
-    }
-
-    let mut new_len = max_len.min(value.len());
-    while new_len > 0 && !value.is_char_boundary(new_len) {
-        new_len -= 1;
-    }
-    value.truncate(new_len);
-}
-
-/// Normalize heading text by replacing newlines and extra whitespace.
-///
-/// Heading text should be on a single line in Markdown. This function collapses
-/// any newlines and multiple spaces into single spaces.
-///
-/// # Examples
-///
-/// ```text
-/// "Hello\nWorld" → "Hello World"
-/// "Text  with   spaces" → "Text  with   spaces" (unchanged if no newlines)
-/// ```
-pub fn normalize_heading_text(text: &str) -> Cow<'_, str> {
-    if !text.contains('\n') && !text.contains('\r') {
-        return Cow::Borrowed(text);
-    }
-
-    let mut normalized = String::with_capacity(text.len());
-    let mut pending_space = false;
-
-    for ch in text.chars() {
-        match ch {
-            '\n' | '\r' => {
-                if !normalized.is_empty() {
-                    pending_space = true;
-                }
-            }
-            ' ' | '\t' if pending_space => {}
-            _ => {
-                if pending_space {
-                    if !normalized.ends_with(' ') {
-                        normalized.push(' ');
-                    }
-                    pending_space = false;
-                }
-                normalized.push(ch);
-            }
-        }
-    }
-
-    Cow::Owned(normalized)
-}

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

@@ -1,70 +0,0 @@
-#![allow(clippy::option_if_let_else)]
-//! Helpers to keep binding entrypoints panic-safe.
-//!
-//! Binding layers (`PyO3`, NAPI-RS, ext-php-rs, WASM, FFI) must not allow Rust
-//! panics to unwind into foreign runtimes. `guard_panic` wraps conversion calls,
-//! converts panics into `ConversionError::Panic`, and preserves the original
-//! error handling path for the caller.
-
-use std::any::Any;
-use std::panic::{self, AssertUnwindSafe, UnwindSafe};
-
-use crate::error::{ConversionError, Result};
-
-/// Run a fallible operation while preventing panics from unwinding across FFI.
-///
-/// Panics are captured and surfaced as `ConversionError::Panic` so bindings can
-/// translate them into language-native errors instead of aborting.
-#[allow(clippy::missing_errors_doc)]
-pub fn guard_panic<F, T>(f: F) -> Result<T>
-where
-    F: FnOnce() -> Result<T> + UnwindSafe,
-{
-    if std::env::var("HTML_TO_MARKDOWN_FAST_FFI")
-        .ok()
-        .is_some_and(|value| matches!(value.as_str(), "1" | "true" | "yes"))
-    {
-        return f();
-    }
-
-    match panic::catch_unwind(AssertUnwindSafe(f)) {
-        Ok(result) => result,
-        Err(payload) => Err(ConversionError::Panic(panic_message(payload))),
-    }
-}
-
-#[allow(clippy::trivially_copy_pass_by_ref)]
-#[allow(clippy::needless_pass_by_value)]
-fn panic_message(payload: Box<dyn Any + Send>) -> String {
-    if let Some(msg) = payload.downcast_ref::<&str>() {
-        (*msg).to_string()
-    } else if let Some(msg) = payload.downcast_ref::<String>() {
-        msg.clone()
-    } else {
-        "unexpected panic without message".to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn guard_panic_converts_panic_to_error() {
-        let err = guard_panic::<_, ()>(|| -> Result<()> {
-            panic!("boom");
-        })
-        .unwrap_err();
-
-        match err {
-            ConversionError::Panic(message) => assert_eq!(message, "boom"),
-            other => panic!("expected panic error, got {:?}", other),
-        }
-    }
-
-    #[test]
-    fn guard_panic_forwards_ok() {
-        let value = guard_panic(|| Ok::<_, ConversionError>(42)).unwrap();
-        assert_eq!(value, 42);
-    }
-}