html-to-markdown 2.29.0 → 3.0.0

data/ext/html-to-markdown-rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "html-to-markdown-rb"
-version = "2.29.0"
+version = "3.0.0"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
 license = "MIT"
@@ -26,8 +26,6 @@ html-to-markdown-rs = { path = "../../../vendor/html-to-markdown-rs", features =
 magnus = { git = "https://github.com/matsadler/magnus", rev = "f6db11769efb517427bf7f121f9c32e18b059b38", features = [
   "rb-sys",
 ] }
-pprof = { version = "0.15", features = ["flamegraph"], optional = true }
-
 [dev-dependencies]
 pretty_assertions = "1.4"
 
@@ -36,7 +34,6 @@ default = ["inline-images", "metadata", "visitor"]
 inline-images = ["html-to-markdown-rs/inline-images"]
 metadata = ["html-to-markdown-rs/metadata"]
 visitor = ["html-to-markdown-rs/visitor"]
-profiling = ["dep:pprof"]
 
 [lints.rust]
 unsafe_code = "forbid"

data/ext/html-to-markdown-rb/native/README.md

@@ -144,25 +144,16 @@ markdown = HtmlToMarkdown.convert(
 
 ### Inline Images
 
-Extract inline binary data (data URIs, SVG) together with the converted Markdown.
+Convert HTML with inline images (data URIs, SVG) to Markdown.
 
 ```ruby
 require 'html_to_markdown'
 
-result = HtmlToMarkdown.convert_with_inline_images(
-  '<img src="data:image/png;base64,iVBORw0..." alt="Pixel">',
-  image_config: {
-    max_decoded_size_bytes: 1 * 1024 * 1024,
-    infer_dimensions: true,
-    filename_prefix: 'img_',
-    capture_svg: true
-  }
+markdown = HtmlToMarkdown.convert(
+  '<img src="data:image/png;base64,iVBORw0..." alt="Pixel">'
 )
 
-puts result.markdown
-result.inline_images.each do |img|
-  puts "#{img.filename} -> #{img.format} (#{img.data.bytesize} bytes)"
-end
+puts markdown
 ```
 
 ## CLI

data/ext/html-to-markdown-rb/native/src/conversion/inline_images.rs

@@ -1,53 +1,8 @@
 //! Inline image configuration and conversion functions.
 
-use crate::types::{arg_error, symbol_to_string};
-use html_to_markdown_rs::{
-    DEFAULT_INLINE_IMAGE_LIMIT, HtmlExtraction, InlineImage, InlineImageConfig, InlineImageConfigUpdate,
-    InlineImageWarning,
-};
+use html_to_markdown_rs::InlineImage;
 use magnus::prelude::*;
-use magnus::r_hash::ForEach;
-use magnus::{Error, RHash, Ruby, TryConvert, Value};
-
-pub fn build_inline_image_config(_ruby: &Ruby, config: Option<Value>) -> Result<InlineImageConfig, Error> {
-    let mut update = InlineImageConfigUpdate::default();
-
-    let Some(config) = config else {
-        return Ok(InlineImageConfig::new(DEFAULT_INLINE_IMAGE_LIMIT));
-    };
-
-    if config.is_nil() {
-        return Ok(InlineImageConfig::new(DEFAULT_INLINE_IMAGE_LIMIT));
-    }
-
-    let hash = RHash::from_value(config).ok_or_else(|| arg_error("inline image config must be provided as a Hash"))?;
-
-    hash.foreach(|key: Value, val: Value| {
-        let key_name = symbol_to_string(key)?;
-        match key_name.as_str() {
-            "max_decoded_size_bytes" => {
-                update.max_decoded_size_bytes = Some(u64::try_convert(val)?);
-            }
-            "filename_prefix" => {
-                update.filename_prefix = if val.is_nil() {
-                    None
-                } else {
-                    Some(String::try_convert(val)?)
-                };
-            }
-            "capture_svg" => {
-                update.capture_svg = Some(bool::try_convert(val)?);
-            }
-            "infer_dimensions" => {
-                update.infer_dimensions = Some(bool::try_convert(val)?);
-            }
-            _ => {}
-        }
-        Ok(ForEach::Continue)
-    })?;
-
-    Ok(InlineImageConfig::from_update(update))
-}
+use magnus::{Error, Ruby, Value};
 
 pub fn inline_image_to_value(ruby: &Ruby, image: InlineImage) -> Result<Value, Error> {
     let InlineImage {
@@ -97,29 +52,3 @@ pub fn inline_image_to_value(ruby: &Ruby, image: InlineImage) -> Result<Value, E
 
     Ok(hash.as_value())
 }
-
-pub fn warning_to_value(ruby: &Ruby, warning: InlineImageWarning) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
-    hash.aset(ruby.intern("index"), warning.index as i64)?;
-    hash.aset(ruby.intern("message"), warning.message)?;
-    Ok(hash.as_value())
-}
-
-pub fn extraction_to_value(ruby: &Ruby, extraction: HtmlExtraction) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
-    hash.aset(ruby.intern("markdown"), extraction.markdown)?;
-
-    let inline_images = ruby.ary_new();
-    for image in extraction.inline_images {
-        inline_images.push(inline_image_to_value(ruby, image)?)?;
-    }
-    hash.aset(ruby.intern("inline_images"), inline_images)?;
-
-    let warnings = ruby.ary_new();
-    for warning in extraction.warnings {
-        warnings.push(warning_to_value(ruby, warning)?)?;
-    }
-    hash.aset(ruby.intern("warnings"), warnings)?;
-
-    Ok(hash.as_value())
-}

data/ext/html-to-markdown-rb/native/src/conversion/metadata.rs

@@ -1,56 +1,12 @@
 //! Metadata configuration and conversion functions.
 
-use crate::types::{arg_error, symbol_to_string};
 use html_to_markdown_rs::metadata::{
-    DocumentMetadata as RustDocumentMetadata, ExtendedMetadata as RustExtendedMetadata,
-    HeaderMetadata as RustHeaderMetadata, ImageMetadata as RustImageMetadata, LinkMetadata as RustLinkMetadata,
-    MetadataConfig as RustMetadataConfig, StructuredData as RustStructuredData, TextDirection as RustTextDirection,
+    DocumentMetadata as RustDocumentMetadata, HeaderMetadata as RustHeaderMetadata,
+    HtmlMetadata as RustHtmlMetadata, ImageMetadata as RustImageMetadata, LinkMetadata as RustLinkMetadata,
+    StructuredData as RustStructuredData, TextDirection as RustTextDirection,
 };
 use magnus::prelude::*;
-use magnus::r_hash::ForEach;
-use magnus::{Error, RHash, Ruby, TryConvert, Value};
-
-pub fn build_metadata_config(_ruby: &Ruby, config: Option<Value>) -> Result<RustMetadataConfig, Error> {
-    let mut cfg = RustMetadataConfig::default();
-
-    let Some(config) = config else {
-        return Ok(cfg);
-    };
-
-    if config.is_nil() {
-        return Ok(cfg);
-    }
-
-    let hash = RHash::from_value(config).ok_or_else(|| arg_error("metadata_config must be provided as a Hash"))?;
-
-    hash.foreach(|key: Value, val: Value| {
-        let key_name = symbol_to_string(key)?;
-        match key_name.as_str() {
-            "extract_document" => {
-                cfg.extract_document = bool::try_convert(val)?;
-            }
-            "extract_headers" => {
-                cfg.extract_headers = bool::try_convert(val)?;
-            }
-            "extract_links" => {
-                cfg.extract_links = bool::try_convert(val)?;
-            }
-            "extract_images" => {
-                cfg.extract_images = bool::try_convert(val)?;
-            }
-            "extract_structured_data" => {
-                cfg.extract_structured_data = bool::try_convert(val)?;
-            }
-            "max_structured_data_size" => {
-                cfg.max_structured_data_size = usize::try_convert(val)?;
-            }
-            _ => {}
-        }
-        Ok(ForEach::Continue)
-    })?;
-
-    Ok(cfg)
-}
+use magnus::{Error, Ruby, Value};
 
 fn opt_string_to_ruby(ruby: &Ruby, opt: Option<String>) -> Result<Value, Error> {
     match opt {
@@ -183,7 +139,7 @@ fn structured_data_to_ruby(ruby: &Ruby, data: Vec<RustStructuredData>) -> Result
     Ok(array.as_value())
 }
 
-pub fn extended_metadata_to_ruby(ruby: &Ruby, metadata: RustExtendedMetadata) -> Result<Value, Error> {
+pub fn extended_metadata_to_ruby(ruby: &Ruby, metadata: RustHtmlMetadata) -> Result<Value, Error> {
     let hash = ruby.hash_new();
 
     hash.aset(

data/ext/html-to-markdown-rb/native/src/conversion/mod.rs

@@ -5,13 +5,7 @@ pub mod inline_images;
 #[cfg(feature = "metadata")]
 pub mod metadata;
 
-#[cfg(feature = "visitor")]
-pub mod tables;
-
 pub use inline_images::*;
 
 #[cfg(feature = "metadata")]
 pub use metadata::*;
-
-#[cfg(feature = "visitor")]
-pub use tables::*;

data/ext/html-to-markdown-rb/native/src/lib.rs

@@ -1,52 +1,19 @@
 #![allow(clippy::all, clippy::pedantic, clippy::nursery, missing_docs)]
 
-use html_to_markdown_rs::{
-    ConversionOptions, convert as convert_inner, convert_with_inline_images as convert_with_inline_images_inner,
-    error::ConversionError, safety::guard_panic,
-};
-
-#[cfg(feature = "visitor")]
-use html_to_markdown_rs::convert_with_visitor as convert_with_visitor_inner;
-
-#[cfg(feature = "visitor")]
-use html_to_markdown_rs::convert_with_tables as convert_with_tables_inner;
-
-#[cfg(feature = "metadata")]
-use html_to_markdown_rs::convert_with_metadata as convert_with_metadata_inner;
+use html_to_markdown_rs::{error::ConversionError, safety::guard_panic};
 
 mod conversion;
 mod options;
-mod profiling;
 mod types;
 
-#[cfg(feature = "visitor")]
-mod visitor;
-
-use conversion::{build_inline_image_config, extraction_to_value};
 use options::build_conversion_options;
 use types::{arg_error, runtime_error};
 
 #[cfg(feature = "metadata")]
-use conversion::{build_metadata_config, extended_metadata_to_ruby};
-
-#[cfg(feature = "visitor")]
-use conversion::tables_result_to_ruby;
-
-#[cfg(feature = "visitor")]
-use visitor::RubyVisitorWrapper;
+use conversion::extended_metadata_to_ruby;
 
 use magnus::prelude::*;
-use magnus::{Error, Ruby, TryConvert, Value, function, scan_args::scan_args};
-
-#[cfg(feature = "visitor")]
-use std::panic::AssertUnwindSafe;
-
-#[cfg(feature = "profiling")]
-use std::path::PathBuf;
-
-#[derive(Clone)]
-#[magnus::wrap(class = "HtmlToMarkdown::Options", free_immediately)]
-struct OptionsHandle(ConversionOptions);
+use magnus::{Error, Ruby, Value, function, scan_args::scan_args};
 
 fn conversion_error(err: ConversionError) -> Error {
     match err {
@@ -58,208 +25,104 @@ fn conversion_error(err: ConversionError) -> Error {
     }
 }
 
-fn convert_fn(ruby: &Ruby, args: &[Value]) -> Result<String, Error> {
+fn convert_full_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     let parsed = scan_args::<(String,), (Option<Value>,), (), (), (), ()>(args)?;
     let html = parsed.required.0;
     let options = build_conversion_options(ruby, parsed.optional.0)?;
 
-    guard_panic(|| profiling::maybe_profile(|| convert_inner(&html, Some(options)))).map_err(conversion_error)
-}
-
-fn options_handle_fn(ruby: &Ruby, args: &[Value]) -> Result<OptionsHandle, Error> {
-    let parsed = scan_args::<(), (Option<Value>,), (), (), (), ()>(args)?;
-    let options = build_conversion_options(ruby, parsed.optional.0)?;
-    Ok(OptionsHandle(options))
-}
-
-fn convert_with_options_handle_fn(_ruby: &Ruby, args: &[Value]) -> Result<String, Error> {
-    let parsed = scan_args::<(String, &OptionsHandle), (), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let handle = parsed.required.1;
-    let options = handle.0.clone();
-
-    guard_panic(|| profiling::maybe_profile(|| convert_inner(&html, Some(options)))).map_err(conversion_error)
-}
-
-#[cfg(feature = "inline-images")]
-fn convert_with_inline_images_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String,), (Option<Value>, Option<Value>), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let options = build_conversion_options(ruby, parsed.optional.0)?;
-    let config = build_inline_image_config(ruby, parsed.optional.1)?;
-
-    let extraction = guard_panic(|| convert_with_inline_images_inner(&html, Some(options), config, None))
-        .map_err(conversion_error)?;
-
-    extraction_to_value(ruby, extraction)
-}
-
-#[cfg(feature = "inline-images")]
-fn convert_with_inline_images_handle_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String, &OptionsHandle), (Option<Value>,), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let handle = parsed.required.1;
-    let options = handle.0.clone();
-    let config = build_inline_image_config(ruby, parsed.optional.0)?;
-
-    let extraction = guard_panic(|| convert_with_inline_images_inner(&html, Some(options), config, None))
-        .map_err(conversion_error)?;
-
-    extraction_to_value(ruby, extraction)
-}
-
-#[cfg(feature = "metadata")]
-fn convert_with_metadata_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String,), (Option<Value>, Option<Value>, Option<Value>), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let options = build_conversion_options(ruby, parsed.optional.0)?;
-    let metadata_config = build_metadata_config(ruby, parsed.optional.1)?;
-    let _visitor = parsed.optional.2;
-
-    let (markdown, metadata) = guard_panic(|| convert_with_metadata_inner(&html, Some(options), metadata_config, None))
+    let result = guard_panic(|| html_to_markdown_rs::convert(&html, Some(options.clone())))
         .map_err(conversion_error)?;
 
-    let array = ruby.ary_new();
-    array.push(markdown)?;
-    array.push(extended_metadata_to_ruby(ruby, metadata)?)?;
-
-    Ok(array.as_value())
-}
-
-#[cfg(feature = "metadata")]
-fn convert_with_metadata_handle_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String, &OptionsHandle), (Option<Value>,), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let handle = parsed.required.1;
-    let options = handle.0.clone();
-    let metadata_config = build_metadata_config(ruby, parsed.optional.0)?;
+    let hash = ruby.hash_new();
 
-    let (markdown, metadata) = guard_panic(|| convert_with_metadata_inner(&html, Some(options), metadata_config, None))
-        .map_err(conversion_error)?;
-
-    let array = ruby.ary_new();
-    array.push(markdown)?;
-    array.push(extended_metadata_to_ruby(ruby, metadata)?)?;
-
-    Ok(array.as_value())
-}
+    // content: Option<String>
+    match result.content {
+        Some(ref s) => hash.aset(ruby.intern("content"), s.as_str())?,
+        None => hash.aset(ruby.intern("content"), ruby.qnil())?,
+    }
 
-#[cfg(feature = "visitor")]
-fn convert_with_tables_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String,), (Option<Value>, Option<Value>), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let options = build_conversion_options(ruby, parsed.optional.0)?;
+    // document: not yet exposed
+    hash.aset(ruby.intern("document"), ruby.qnil())?;
 
+    // metadata
     #[cfg(feature = "metadata")]
-    let metadata_config = Some(build_metadata_config(ruby, parsed.optional.1)?);
+    {
+        let metadata_value = extended_metadata_to_ruby(ruby, result.metadata)?;
+        hash.aset(ruby.intern("metadata"), metadata_value)?;
+    }
     #[cfg(not(feature = "metadata"))]
-    let metadata_config: Option<()> = None;
-
-    let result =
-        guard_panic(|| convert_with_tables_inner(&html, Some(options), metadata_config)).map_err(conversion_error)?;
+    hash.aset(ruby.intern("metadata"), ruby.qnil())?;
 
-    tables_result_to_ruby(ruby, result)
-}
-
-#[cfg(feature = "visitor")]
-fn convert_with_visitor_fn(ruby: &Ruby, args: &[Value]) -> Result<String, Error> {
-    let parsed = scan_args::<(String,), (Option<Value>, Option<Value>), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-
-    let options = match parsed.optional.0 {
-        Some(opt_val) => match <&OptionsHandle>::try_convert(opt_val) {
-            Ok(handle) => handle.0.clone(),
-            Err(_) => build_conversion_options(ruby, Some(opt_val))?,
-        },
-        None => ConversionOptions::default(),
-    };
-
-    let visitor_value = match parsed.optional.1 {
-        Some(val) => {
-            if val.is_nil() {
-                return guard_panic(AssertUnwindSafe(|| {
-                    profiling::maybe_profile(|| convert_inner(&html, Some(options)))
-                }))
-                .map_err(conversion_error);
+    // tables: Vec<TableData> with grid and markdown
+    {
+        let tables_array = ruby.ary_new();
+        for table in &result.tables {
+            let table_hash = ruby.hash_new();
+            let grid_hash = ruby.hash_new();
+            grid_hash.aset(ruby.intern("rows"), table.grid.rows as i64)?;
+            grid_hash.aset(ruby.intern("cols"), table.grid.cols as i64)?;
+            let cells_array = ruby.ary_new();
+            for cell in &table.grid.cells {
+                let cell_hash = ruby.hash_new();
+                cell_hash.aset(ruby.intern("content"), cell.content.as_str())?;
+                cell_hash.aset(ruby.intern("row"), cell.row as i64)?;
+                cell_hash.aset(ruby.intern("col"), cell.col as i64)?;
+                cell_hash.aset(ruby.intern("row_span"), cell.row_span as i64)?;
+                cell_hash.aset(ruby.intern("col_span"), cell.col_span as i64)?;
+                cell_hash.aset(ruby.intern("is_header"), cell.is_header)?;
+                cells_array.push(cell_hash)?;
             }
-            val
+            grid_hash.aset(ruby.intern("cells"), cells_array)?;
+            table_hash.aset(ruby.intern("grid"), grid_hash)?;
+            table_hash.aset(ruby.intern("markdown"), table.markdown.as_str())?;
+            tables_array.push(table_hash)?;
         }
-        None => return Err(arg_error("visitor argument is required")),
-    };
-
-    let visitor_wrapper = RubyVisitorWrapper::new(visitor_value);
-    let visitor_handle = std::rc::Rc::new(std::cell::RefCell::new(visitor_wrapper.clone()));
-
-    let result = guard_panic(AssertUnwindSafe(|| {
-        profiling::maybe_profile(|| convert_with_visitor_inner(&html, Some(options), Some(visitor_handle)))
-    }))
-    .map_err(conversion_error)?;
-
-    if let Some(error_msg) = visitor_wrapper.last_error.borrow().as_ref() {
-        return Err(runtime_error(error_msg.clone()));
+        hash.aset(ruby.intern("tables"), tables_array)?;
     }
 
-    Ok(result)
-}
-
-#[cfg(feature = "profiling")]
-fn start_profiling_fn(_ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
-    let output = args.first().ok_or_else(|| arg_error("output_path required"))?;
-    let output: String = String::try_convert(*output)?;
-    let freq = if let Some(value) = args.get(1) {
-        i32::try_convert(*value)?
-    } else {
-        1000
-    };
-    profiling::start(PathBuf::from(output), freq).map_err(conversion_error)?;
-    Ok(true)
-}
-
-#[cfg(feature = "profiling")]
-fn stop_profiling_fn(_ruby: &Ruby, _args: &[Value]) -> Result<bool, Error> {
-    profiling::stop().map_err(conversion_error)?;
-    Ok(true)
-}
-
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    let module = ruby.define_module("HtmlToMarkdown")?;
-    module.define_singleton_method("convert", function!(convert_fn, -1))?;
-    module.define_singleton_method("options", function!(options_handle_fn, -1))?;
-    module.define_singleton_method("convert_with_options", function!(convert_with_options_handle_fn, -1))?;
-
+    // images
     #[cfg(feature = "inline-images")]
     {
-        module.define_singleton_method(
-            "convert_with_inline_images",
-            function!(convert_with_inline_images_fn, -1),
-        )?;
-        module.define_singleton_method(
-            "convert_with_inline_images_handle",
-            function!(convert_with_inline_images_handle_fn, -1),
-        )?;
+        use conversion::inline_image_to_value;
+        let images_array = ruby.ary_new();
+        for image in result.images {
+            let image_value = inline_image_to_value(ruby, image)?;
+            images_array.push(image_value)?;
+        }
+        hash.aset(ruby.intern("images"), images_array)?;
     }
-
-    #[cfg(feature = "metadata")]
+    #[cfg(not(feature = "inline-images"))]
     {
-        module.define_singleton_method("convert_with_metadata", function!(convert_with_metadata_fn, -1))?;
-        module.define_singleton_method(
-            "convert_with_metadata_handle",
-            function!(convert_with_metadata_handle_fn, -1),
-        )?;
+        let empty = ruby.ary_new();
+        hash.aset(ruby.intern("images"), empty)?;
     }
 
-    #[cfg(feature = "visitor")]
+    // warnings
     {
-        module.define_singleton_method("convert_with_visitor", function!(convert_with_visitor_fn, -1))?;
-        module.define_singleton_method("convert_with_tables", function!(convert_with_tables_fn, -1))?;
+        let warnings_array = ruby.ary_new();
+        for warning in &result.warnings {
+            let w_hash = ruby.hash_new();
+            w_hash.aset(ruby.intern("message"), warning.message.as_str())?;
+            let kind_str = match warning.kind {
+                html_to_markdown_rs::WarningKind::ImageExtractionFailed => "image_extraction_failed",
+                html_to_markdown_rs::WarningKind::EncodingFallback => "encoding_fallback",
+                html_to_markdown_rs::WarningKind::TruncatedInput => "truncated_input",
+                html_to_markdown_rs::WarningKind::MalformedHtml => "malformed_html",
+                html_to_markdown_rs::WarningKind::SanitizationApplied => "sanitization_applied",
+            };
+            w_hash.aset(ruby.intern("kind"), kind_str)?;
+            warnings_array.push(w_hash)?;
+        }
+        hash.aset(ruby.intern("warnings"), warnings_array)?;
     }
 
-    #[cfg(feature = "profiling")]
-    {
-        module.define_singleton_method("start_profiling", function!(start_profiling_fn, -1))?;
-        module.define_singleton_method("stop_profiling", function!(stop_profiling_fn, -1))?;
-    }
+    Ok(hash.as_value())
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("HtmlToMarkdown")?;
+    module.define_singleton_method("convert", function!(convert_full_fn, -1))?;
 
     Ok(())
 }

data/ext/html-to-markdown-rb/native/src/options.rs

@@ -175,9 +175,6 @@ pub fn build_conversion_options(ruby: &Ruby, options: Option<Value>) -> Result<C
             "br_in_tables" => {
                 update.br_in_tables = Some(bool::try_convert(val)?);
             }
-            "hocr_spatial_tables" => {
-                update.hocr_spatial_tables = Some(bool::try_convert(val)?);
-            }
             "highlight_style" => {
                 update.highlight_style = Some(parse_highlight_style(val)?);
             }

data/lib/html_to_markdown/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HtmlToMarkdown
-  VERSION = '2.29.0'
+  VERSION = '3.0.0'
 end