html-to-markdown 2.4.1__tar.gz → 2.5.0__tar.gz

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/Cargo.lock

@@ -157,9 +157,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.41"
+version = "1.2.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7"
+checksum = "81bbf3b3619004ad9bd139f62a9ab5cfe467f307455a0d307b0cf58bf070feaa"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -249,9 +249,9 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "clap_mangen"
-version = "0.2.30"
+version = "0.2.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "263c8214a8e0cb8129f3c62036c50e9c6e15c7bd364c42e0437c492b9293f778"
+checksum = "439ea63a92086df93893164221ad4f24142086d535b3a0957b9b9bea2dc86301"
 dependencies = [
  "clap",
  "roff",
@@ -386,9 +386,9 @@ dependencies = [
 
 [[package]]
 name = "ctor"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67773048316103656a637612c4a62477603b777d91d9c62ff2290f9cde178fdb"
+checksum = "59c9b8bdf64ee849747c1b12eb861d21aa47fa161564f48332f1afe2373bf899"
 dependencies = [
  "ctor-proc-macro",
  "dtor",
@@ -396,9 +396,9 @@ dependencies = [
 
 [[package]]
 name = "ctor-proc-macro"
-version = "0.0.6"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2931af7e13dc045d8e9d26afccc6fa115d64e115c9c84b1166288b46f6782c2"
+checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
 
 [[package]]
 name = "cty"
@@ -425,9 +425,9 @@ dependencies = [
 
 [[package]]
 name = "doc-comment"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9"
 
 [[package]]
 name = "dtoa"
@@ -507,9 +507,9 @@ checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
 
 [[package]]
 name = "flate2"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -550,11 +550,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi",
  "wasip2",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -595,7 +593,7 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-cli"
-version = "2.4.1"
+version = "2.5.0"
 dependencies = [
  "assert_cmd",
  "clap",
@@ -609,7 +607,7 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-node"
-version = "2.4.1"
+version = "2.5.0"
 dependencies = [
  "html-to-markdown-rs",
  "mimalloc-rust",
@@ -620,7 +618,7 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-py"
-version = "2.4.1"
+version = "2.5.0"
 dependencies = [
  "base64",
  "html-to-markdown-rs",
@@ -630,7 +628,7 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-rs"
-version = "2.4.1"
+version = "2.5.0"
 dependencies = [
  "ammonia",
  "base64",
@@ -647,10 +645,9 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-wasm"
-version = "2.4.1"
+version = "2.5.0"
 dependencies = [
  "console_error_panic_hook",
- "getrandom",
  "html-to-markdown-rs",
  "js-sys",
  "serde",
@@ -989,9 +986,9 @@ dependencies = [
 
 [[package]]
 name = "napi"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b74e3dce5230795bb4d2821b941706dee733c7308752507254b0497f39cad7"
+checksum = "c3a1135cfe16ca43ac82ac05858554fc39c037d8e4592f2b4a83d7ef8e822f43"
 dependencies = [
  "bitflags",
  "ctor",
@@ -1003,15 +1000,15 @@ dependencies = [
 
 [[package]]
 name = "napi-build"
-version = "2.2.3"
+version = "2.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcae8ad5609d14afb3a3b91dee88c757016261b151e9dcecabf1b2a31a6cab14"
+checksum = "3ae82775d1b06f3f07efd0666e59bbc175da8383bc372051031d7a447e94fbea"
 
 [[package]]
 name = "napi-derive"
-version = "3.2.5"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7552d5a579b834614bbd496db5109f1b9f1c758f08224b0dee1e408333adf0d0"
+checksum = "78665d6bdf10e9a4e6b38123efb0f66962e6197c1aea2f07cff3f159a374696d"
 dependencies = [
  "convert_case",
  "ctor",
@@ -1023,9 +1020,9 @@ dependencies = [
 
 [[package]]
 name = "napi-derive-backend"
-version = "2.2.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6a81ac7486b70f2532a289603340862c06eea5a1e650c1ffeda2ce1238516a"
+checksum = "42d55d01423e7264de3acc13b258fa48ca7cf38a4d25db848908ec3c1304a85a"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -1036,9 +1033,9 @@ dependencies = [
 
 [[package]]
 name = "napi-sys"
-version = "3.0.0"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4e7135a8f97aa0f1509cce21a8a1f9dcec1b50d8dee006b48a5adb69a9d64d"
+checksum = "1ed8f0e23a62a3ce0fbb6527cdc056e9282ddd9916b068c46f8923e18eed5ee6"
 dependencies = [
  "libloading",
 ]
@@ -1263,9 +1260,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.101"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
@@ -1609,9 +1606,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.107"
+version = "2.0.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a26dbd934e5451d21ef060c018dae56fc073894c5a7896f882928a76e6d081b"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
 dependencies = [
  "proc-macro2",
  "quote",

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/html-to-markdown-py"]
 
 [workspace.package]
-version = "2.4.1"
+version = "2.5.0"
 edition = "2021"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
@@ -15,7 +15,7 @@ rust-version = "1.80"
 
 [workspace.dependencies]
 # Core library
-html-to-markdown-rs = { version = "2.4.1", path = "crates/html-to-markdown" }
+html-to-markdown-rs = { version = "2.5.0", path = "crates/html-to-markdown" }
 
 # HTML parsing and sanitization
 tl = "0.7"

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: html-to-markdown
-Version: 2.4.1
+Version: 2.5.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -162,9 +162,12 @@ Key fields (see docstring for full matrix):
 
 ### `PreprocessingOptions`
 
-- `enabled`: enable HTML sanitisation
-- `preset`: `"minimal" | "standard" | "aggressive"`
-- `remove_navigation`, `remove_forms`
+- `enabled`: enable HTML sanitisation (default: `True` since v2.4.2 for robust malformed HTML handling)
+- `preset`: `"minimal" | "standard" | "aggressive"` (default: `"standard"`)
+- `remove_navigation`: remove navigation elements (default: `True`)
+- `remove_forms`: remove form elements (default: `True`)
+
+**Note:** As of v2.4.2, preprocessing is enabled by default to ensure robust handling of malformed HTML (e.g., bare angle brackets like `1<2` in content). Set `enabled=False` if you need minimal preprocessing.
 
 ### `InlineImageConfig`
 

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/README_PYPI.md

@@ -129,9 +129,12 @@ Key fields (see docstring for full matrix):
 
 ### `PreprocessingOptions`
 
-- `enabled`: enable HTML sanitisation
-- `preset`: `"minimal" | "standard" | "aggressive"`
-- `remove_navigation`, `remove_forms`
+- `enabled`: enable HTML sanitisation (default: `True` since v2.4.2 for robust malformed HTML handling)
+- `preset`: `"minimal" | "standard" | "aggressive"` (default: `"standard"`)
+- `remove_navigation`: remove navigation elements (default: `True`)
+- `remove_forms`: remove form elements (default: `True`)
+
+**Note:** As of v2.4.2, preprocessing is enabled by default to ensure robust handling of malformed HTML (e.g., bare angle brackets like `1<2` in content). Set `enabled=False` if you need minimal preprocessing.
 
 ### `InlineImageConfig`
 

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/crates/html-to-markdown/README.md

@@ -60,6 +60,41 @@ let options = ConversionOptions {
 let markdown = convert(html, Some(options))?;
 ```
 
+### Preserving HTML Tags
+
+The `preserve_tags` option allows you to keep specific HTML tags in their original form instead of converting them to Markdown. This is useful for complex elements like tables that may not convert well:
+
+```rust
+use html_to_markdown_rs::{convert, ConversionOptions};
+
+let html = r#"
+<p>Before table</p>
+<table class="data">
+    <tr><th>Name</th><th>Value</th></tr>
+    <tr><td>Item 1</td><td>100</td></tr>
+</table>
+<p>After table</p>
+"#;
+
+let options = ConversionOptions {
+    preserve_tags: vec!["table".to_string()],
+    ..Default::default()
+};
+
+let markdown = convert(html, Some(options))?;
+// Result: "Before table\n\n<table class=\"data\">...</table>\n\nAfter table\n"
+```
+
+You can preserve multiple tag types and combine with `strip_tags`:
+
+```rust
+let options = ConversionOptions {
+    preserve_tags: vec!["table".to_string(), "form".to_string()],
+    strip_tags: vec!["script".to_string(), "style".to_string()],
+    ..Default::default()
+};
+```
+
 ## Web Scraping with Preprocessing
 
 ```rust

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/crates/html-to-markdown/src/converter.rs

@@ -974,6 +974,9 @@ fn convert_html_impl(
         .replace("<hr/>", "<hr>")
         .replace("<img/>", "<img>");
 
+    // Escape malformed angle brackets in text content to prevent parser failures
+    let html = escape_malformed_angle_brackets(&html);
+
     let html = strip_script_and_style_sections(&html);
 
     let dom = tl::parse(html.as_ref(), tl::ParserOptions::default())
@@ -1080,6 +1083,151 @@ fn convert_html_impl(
     }
 }
 
+/// Escape malformed angle brackets in HTML that are not part of valid tags.
+///
+/// This function ensures robust parsing by escaping bare `<` and `>` characters
+/// that appear in text content and are not part of HTML tags. This prevents
+/// parser failures on malformed HTML like "1<2" or comparisons in text.
+///
+/// # Examples
+///
+/// - `1<2` becomes `1&lt;2`
+/// - `<div>1<2</div>` becomes `<div>1&lt;2</div>`
+/// - `<script>1 < 2</script>` remains unchanged (handled by script stripping)
+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'<' {
+            // Check if this is a valid tag start
+            if idx + 1 < len {
+                let next = bytes[idx + 1];
+
+                // Valid tag patterns: <tagname, </tagname, <!doctype, <!--
+                let is_valid_tag = match next {
+                    b'!' => {
+                        // DOCTYPE or comment
+                        idx + 2 < len
+                            && (bytes[idx + 2] == b'-'
+                                || bytes[idx + 2].is_ascii_alphabetic()
+                                || bytes[idx + 2].is_ascii_uppercase())
+                    }
+                    b'/' => {
+                        // Closing tag
+                        idx + 2 < len && (bytes[idx + 2].is_ascii_alphabetic() || bytes[idx + 2].is_ascii_uppercase())
+                    }
+                    b'?' => {
+                        // XML declaration
+                        true
+                    }
+                    c if c.is_ascii_alphabetic() || c.is_ascii_uppercase() => {
+                        // Opening tag
+                        true
+                    }
+                    _ => false,
+                };
+
+                if !is_valid_tag {
+                    // This is a bare `<` that should be escaped
+                    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 {
+                // `<` at end of string - escape it
+                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)
+    }
+}
+
+/// Serialize a tag and its children back to HTML.
+///
+/// This is used for the preserve_tags feature to output original HTML for specific elements.
+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.
+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 = tag.name().as_utf8_str();
+
+            // Opening tag
+            output.push('<');
+            output.push_str(&tag_name);
+
+            // Attributes
+            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('>');
+
+            // Children
+            let children = tag.children();
+            for child_handle in children.top().iter() {
+                serialize_node_to_html(child_handle, parser, output);
+            }
+
+            // Closing tag (skip for self-closing tags)
+            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);
+            }
+        }
+        _ => {}
+    }
+}
+
 fn strip_script_and_style_sections(input: &str) -> Cow<'_, str> {
     const TAGS: [&[u8]; 2] = [b"script", b"style"];
     const SVG: &[u8] = b"svg";
@@ -1478,6 +1626,13 @@ fn walk_node(
                 return;
             }
 
+            // Preserve tags: output original HTML
+            if options.preserve_tags.iter().any(|t| t.as_str() == tag_name) {
+                let html = serialize_tag_to_html(node_handle, parser);
+                output.push_str(&html);
+                return;
+            }
+
             match tag_name.as_ref() {
                 "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => {
                     let level = tag_name.chars().last().and_then(|c| c.to_digit(10)).unwrap_or(1) as usize;
@@ -4225,4 +4380,176 @@ mod tests {
         add_list_continuation_indent(&mut output, 1, false, &opts);
         assert_eq!(output, "* First\n  ");
     }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_bare() {
+        let input = "1<2";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "1&lt;2");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_in_text() {
+        let input = "<html>1<2 Content</html>";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "<html>1&lt;2 Content</html>");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_multiple() {
+        let input = "1 < 2 < 3";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "1 &lt; 2 &lt; 3");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_preserves_valid_tags() {
+        let input = "<div>content</div>";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "<div>content</div>");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_mixed() {
+        let input = "<div>1<2</div><p>3<4</p>";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "<div>1&lt;2</div><p>3&lt;4</p>");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_at_end() {
+        let input = "test<";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "test&lt;");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_preserves_comments() {
+        let input = "<!-- comment -->1<2";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "<!-- comment -->1&lt;2");
+    }
+
+    #[test]
+    fn test_escape_malformed_angle_brackets_preserves_doctype() {
+        let input = "<!DOCTYPE html>1<2";
+        let escaped = escape_malformed_angle_brackets(input);
+        assert_eq!(escaped, "<!DOCTYPE html>1&lt;2");
+    }
+
+    #[test]
+    fn test_convert_with_malformed_angle_brackets() {
+        // Test the full conversion pipeline (issue #94)
+        let html = "<html>1<2\nContent</html>";
+        let result = convert_html(html, &ConversionOptions::default()).unwrap();
+        assert!(
+            result.contains("Content"),
+            "Result should contain 'Content': {:?}",
+            result
+        );
+        assert!(
+            result.contains("1<2") || result.contains("1&lt;2"),
+            "Result should contain escaped or unescaped comparison"
+        );
+    }
+
+    #[test]
+    fn test_convert_with_malformed_angle_brackets_in_div() {
+        let html = "<html><div>1<2</div><div>Content</div></html>";
+        let result = convert_html(html, &ConversionOptions::default()).unwrap();
+        assert!(
+            result.contains("Content"),
+            "Result should contain 'Content': {:?}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_convert_with_multiple_malformed_angle_brackets() {
+        let html = "<html>1 < 2 < 3<p>Content</p></html>";
+        let result = convert_html(html, &ConversionOptions::default()).unwrap();
+        assert!(
+            result.contains("Content"),
+            "Result should contain 'Content': {:?}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_preserve_tags_simple_table() {
+        let html = r#"<div><table><tr><td>Cell 1</td><td>Cell 2</td></tr></table><p>Text</p></div>"#;
+        let mut options = ConversionOptions::default();
+        options.preserve_tags = vec!["table".to_string()];
+        let result = convert_html(html, &options).unwrap();
+
+        assert!(result.contains("<table>"), "Should preserve table tag");
+        assert!(result.contains("</table>"), "Should have closing table tag");
+        assert!(result.contains("<tr>"), "Should preserve tr tag");
+        assert!(result.contains("<td>"), "Should preserve td tag");
+        assert!(result.contains("Text"), "Should convert other elements");
+    }
+
+    #[test]
+    fn test_preserve_tags_with_attributes() {
+        let html = r#"<table class="data" id="mytable"><tr><td>Data</td></tr></table>"#;
+        let mut options = ConversionOptions::default();
+        options.preserve_tags = vec!["table".to_string()];
+        let result = convert_html(html, &options).unwrap();
+
+        assert!(result.contains("<table"), "Should preserve table tag");
+        assert!(result.contains("class="), "Should preserve class attribute");
+        assert!(result.contains("id="), "Should preserve id attribute");
+        assert!(result.contains("</table>"), "Should have closing tag");
+    }
+
+    #[test]
+    fn test_preserve_tags_multiple_tags() {
+        let html = r#"<div><table><tr><td>Table</td></tr></table><form><input type="text"/></form><p>Text</p></div>"#;
+        let mut options = ConversionOptions::default();
+        options.preserve_tags = vec!["table".to_string(), "form".to_string()];
+        let result = convert_html(html, &options).unwrap();
+
+        assert!(result.contains("<table>"), "Should preserve table");
+        assert!(result.contains("<form>"), "Should preserve form");
+        assert!(result.contains("Text"), "Should convert paragraph");
+    }
+
+    #[test]
+    fn test_preserve_tags_nested_content() {
+        let html = r#"<table><thead><tr><th>Header</th></tr></thead><tbody><tr><td>Data</td></tr></tbody></table>"#;
+        let mut options = ConversionOptions::default();
+        options.preserve_tags = vec!["table".to_string()];
+        let result = convert_html(html, &options).unwrap();
+
+        assert!(result.contains("<thead>"), "Should preserve nested thead");
+        assert!(result.contains("<tbody>"), "Should preserve nested tbody");
+        assert!(result.contains("<th>"), "Should preserve th tag");
+        assert!(result.contains("Header"), "Should preserve text content");
+    }
+
+    #[test]
+    fn test_preserve_tags_empty_list() {
+        let html = r#"<table><tr><td>Cell</td></tr></table>"#;
+        let options = ConversionOptions::default(); // No preserve_tags
+        let result = convert_html(html, &options).unwrap();
+
+        // Should convert to markdown table (or at least not preserve HTML)
+        assert!(
+            !result.contains("<table>"),
+            "Should not preserve table without preserve_tags"
+        );
+    }
+
+    #[test]
+    fn test_preserve_tags_vs_strip_tags() {
+        let html = r#"<table><tr><td>Table</td></tr></table><div><span>Text</span></div>"#;
+        let mut options = ConversionOptions::default();
+        options.preserve_tags = vec!["table".to_string()];
+        options.strip_tags = vec!["span".to_string()];
+        let result = convert_html(html, &options).unwrap();
+
+        assert!(result.contains("<table>"), "Should preserve table");
+        assert!(!result.contains("<span>"), "Should strip span tag");
+        assert!(result.contains("Text"), "Should keep span text content");
+    }
 }

{html_to_markdown-2.4.1 → html_to_markdown-2.5.0}/crates/html-to-markdown/src/hocr/converter.rs

@@ -237,9 +237,22 @@ fn convert_element(
 
         // Words - join with space
         HocrElementType::OcrxWord => {
+            // Ensure space before this word if output doesn't end with whitespace or markdown formatting
+            if !output.is_empty()
+                && !output.ends_with(' ')
+                && !output.ends_with('\t')
+                && !output.ends_with('\n')
+                && !output.ends_with('*')  // Don't add space after italic/bold markers
+                && !output.ends_with('`')  // Don't add space after code markers
+                && !output.ends_with('_')  // Don't add space after underline markers
+                && !output.ends_with('[')
+            // Don't add space after opening bracket (link/image alt)
+            {
+                output.push(' ');
+            }
+
             if !element.text.is_empty() {
                 output.push_str(&element.text);
-                output.push(' ');
             }
         }