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

data/ext/html_to_markdown_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:bbf4dbc4dd189a338ff88a6816fc1b65d7c952b6a87f2a76367ebcc321db930a
+// alef:hash:fbc32dea2062047854006aa7a5d861ef8fc29be3d8b519a3e56646eb14f1b2e9
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -13,12 +13,16 @@
     clippy::unwrap_or_default,
     clippy::derivable_impls,
     clippy::needless_borrows_for_generic_args,
-    clippy::unnecessary_fallible_conversions
+    clippy::unnecessary_fallible_conversions,
+    clippy::type_complexity,
+    clippy::useless_conversion,
+    clippy::clone_on_copy
 )]
 
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::Mutex;
 
 fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     use magnus::IntoValue;
@@ -54,7 +58,7 @@ fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentMetadata")]
 pub struct DocumentMetadata {
@@ -99,6 +103,24 @@ impl magnus::TryConvert for DocumentMetadata {
 
 unsafe impl TryConvertOwned for DocumentMetadata {}
 
+impl Default for DocumentMetadata {
+    fn default() -> Self {
+        Self {
+            title: None,
+            description: None,
+            keywords: vec![],
+            author: None,
+            canonical_url: None,
+            base_href: None,
+            language: None,
+            text_direction: None,
+            open_graph: Default::default(),
+            twitter_card: Default::default(),
+            meta_tags: Default::default(),
+        }
+    }
+}
+
 impl DocumentMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -191,7 +213,7 @@ impl DocumentMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HeaderMetadata")]
 pub struct HeaderMetadata {
     level: u8,
@@ -294,7 +316,7 @@ impl HeaderMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::LinkMetadata")]
 pub struct LinkMetadata {
     href: String,
@@ -354,7 +376,12 @@ impl LinkMetadata {
             link_type: kwargs
                 .get(ruby.to_symbol("link_type"))
                 .and_then(|v| LinkType::try_convert(v).ok())
-                .unwrap_or(LinkType::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: link_type",
+                    )
+                })?,
             rel: kwargs
                 .get(ruby.to_symbol("rel"))
                 .and_then(|v| <Vec<String>>::try_convert(v).ok())
@@ -391,13 +418,13 @@ impl LinkMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ImageMetadata")]
 pub struct ImageMetadata {
     src: String,
     alt: Option<String>,
     title: Option<String>,
-    dimensions: Option<Vec<u32>>,
+    dimensions: Option<ImageDimensions>,
     image_type: ImageType,
     attributes: HashMap<String, String>,
 }
@@ -449,11 +476,16 @@ impl ImageMetadata {
                 .and_then(|v| String::try_convert(v).ok()),
             dimensions: kwargs
                 .get(ruby.to_symbol("dimensions"))
-                .and_then(|v| <Vec<u32>>::try_convert(v).ok()),
+                .and_then(|v| ImageDimensions::try_convert(v).ok()),
             image_type: kwargs
                 .get(ruby.to_symbol("image_type"))
                 .and_then(|v| ImageType::try_convert(v).ok())
-                .unwrap_or(ImageType::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: image_type",
+                    )
+                })?,
             attributes: kwargs
                 .get(ruby.to_symbol("attributes"))
                 .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
@@ -473,7 +505,7 @@ impl ImageMetadata {
         self.title.clone()
     }
 
-    fn dimensions(&self) -> Option<Vec<u32>> {
+    fn dimensions(&self) -> Option<ImageDimensions> {
         self.dimensions.clone()
     }
 
@@ -486,7 +518,7 @@ impl ImageMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::StructuredData")]
 pub struct StructuredData {
     data_type: StructuredDataType,
@@ -532,7 +564,12 @@ impl StructuredData {
             data_type: kwargs
                 .get(ruby.to_symbol("data_type"))
                 .and_then(|v| StructuredDataType::try_convert(v).ok())
-                .unwrap_or(StructuredDataType::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: data_type",
+                    )
+                })?,
             raw_json: kwargs
                 .get(ruby.to_symbol("raw_json"))
                 .and_then(|v| String::try_convert(v).ok())
@@ -556,7 +593,7 @@ impl StructuredData {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HtmlMetadata")]
 pub struct HtmlMetadata {
@@ -595,6 +632,18 @@ impl magnus::TryConvert for HtmlMetadata {
 
 unsafe impl TryConvertOwned for HtmlMetadata {}
 
+impl Default for HtmlMetadata {
+    fn default() -> Self {
+        Self {
+            document: Default::default(),
+            headers: vec![],
+            links: vec![],
+            images: vec![],
+            structured_data: vec![],
+        }
+    }
+}
+
 impl HtmlMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -646,7 +695,7 @@ impl HtmlMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptions")]
 pub struct ConversionOptions {
@@ -663,6 +712,7 @@ pub struct ConversionOptions {
     autolinks: bool,
     default_title: bool,
     br_in_tables: bool,
+    compact_tables: bool,
     highlight_style: HighlightStyle,
     extract_metadata: bool,
     whitespace_mode: WhitespaceMode,
@@ -681,6 +731,7 @@ pub struct ConversionOptions {
     strip_tags: Vec<String>,
     preserve_tags: Vec<String>,
     skip_images: bool,
+    url_escape_style: UrlEscapeStyle,
     link_style: LinkStyle,
     output_format: OutputFormat,
     include_document_structure: bool,
@@ -690,6 +741,7 @@ pub struct ConversionOptions {
     infer_dimensions: bool,
     max_depth: Option<usize>,
     exclude_selectors: Vec<String>,
+    tier_strategy: TierStrategy,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -720,6 +772,56 @@ impl magnus::TryConvert for ConversionOptions {
 
 unsafe impl TryConvertOwned for ConversionOptions {}
 
+impl Default for ConversionOptions {
+    fn default() -> Self {
+        Self {
+            heading_style: Default::default(),
+            list_indent_type: Default::default(),
+            list_indent_width: 2,
+            bullets: "-*+".to_string(),
+            strong_em_symbol: "*".to_string(),
+            escape_asterisks: false,
+            escape_underscores: false,
+            escape_misc: false,
+            escape_ascii: false,
+            code_language: "".to_string(),
+            autolinks: true,
+            default_title: false,
+            br_in_tables: false,
+            compact_tables: false,
+            highlight_style: Default::default(),
+            extract_metadata: true,
+            whitespace_mode: Default::default(),
+            strip_newlines: false,
+            wrap: false,
+            wrap_width: 80,
+            convert_as_inline: false,
+            sub_symbol: "".to_string(),
+            sup_symbol: "".to_string(),
+            newline_style: NewlineStyle::Spaces,
+            code_block_style: Default::default(),
+            keep_inline_images_in: vec![],
+            preprocessing: Default::default(),
+            encoding: "utf-8".to_string(),
+            debug: false,
+            strip_tags: vec![],
+            preserve_tags: vec![],
+            skip_images: false,
+            url_escape_style: Default::default(),
+            link_style: Default::default(),
+            output_format: Default::default(),
+            include_document_structure: false,
+            extract_images: false,
+            max_image_size: 5242880,
+            capture_svg: false,
+            infer_dimensions: true,
+            max_depth: None,
+            exclude_selectors: vec![],
+            tier_strategy: TierStrategy::Auto,
+        }
+    }
+}
+
 impl ConversionOptions {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -779,6 +881,10 @@ impl ConversionOptions {
                 .get(ruby.to_symbol("br_in_tables"))
                 .and_then(|v| bool::try_convert(v).ok())
                 .unwrap_or(false),
+            compact_tables: kwargs
+                .get(ruby.to_symbol("compact_tables"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
             highlight_style: kwargs
                 .get(ruby.to_symbol("highlight_style"))
                 .and_then(|v| HighlightStyle::try_convert(v).ok())
@@ -851,6 +957,10 @@ impl ConversionOptions {
                 .get(ruby.to_symbol("skip_images"))
                 .and_then(|v| bool::try_convert(v).ok())
                 .unwrap_or(false),
+            url_escape_style: kwargs
+                .get(ruby.to_symbol("url_escape_style"))
+                .and_then(|v| UrlEscapeStyle::try_convert(v).ok())
+                .unwrap_or_default(),
             link_style: kwargs
                 .get(ruby.to_symbol("link_style"))
                 .and_then(|v| LinkStyle::try_convert(v).ok())
@@ -886,6 +996,10 @@ impl ConversionOptions {
                 .get(ruby.to_symbol("exclude_selectors"))
                 .and_then(|v| <Vec<String>>::try_convert(v).ok())
                 .unwrap_or_default(),
+            tier_strategy: kwargs
+                .get(ruby.to_symbol("tier_strategy"))
+                .and_then(|v| TierStrategy::try_convert(v).ok())
+                .unwrap_or(TierStrategy::Auto),
         })
     }
 
@@ -941,6 +1055,10 @@ impl ConversionOptions {
         self.br_in_tables
     }
 
+    fn compact_tables(&self) -> bool {
+        self.compact_tables
+    }
+
     fn highlight_style(&self) -> HighlightStyle {
         self.highlight_style.clone()
     }
@@ -1013,6 +1131,10 @@ impl ConversionOptions {
         self.skip_images
     }
 
+    fn url_escape_style(&self) -> UrlEscapeStyle {
+        self.url_escape_style.clone()
+    }
+
     fn link_style(&self) -> LinkStyle {
         self.link_style.clone()
     }
@@ -1049,13 +1171,12 @@ impl ConversionOptions {
         self.exclude_selectors.clone()
     }
 
-    #[allow(unused_variables)]
-    fn apply_update(&mut self, update: ConversionOptionsUpdate) -> () {
-        ()
+    fn tier_strategy(&self) -> TierStrategy {
+        self.tier_strategy.clone()
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptionsUpdate")]
 pub struct ConversionOptionsUpdate {
@@ -1072,6 +1193,7 @@ pub struct ConversionOptionsUpdate {
     autolinks: Option<bool>,
     default_title: Option<bool>,
     br_in_tables: Option<bool>,
+    compact_tables: Option<bool>,
     highlight_style: Option<HighlightStyle>,
     extract_metadata: Option<bool>,
     whitespace_mode: Option<WhitespaceMode>,
@@ -1090,6 +1212,7 @@ pub struct ConversionOptionsUpdate {
     strip_tags: Option<Vec<String>>,
     preserve_tags: Option<Vec<String>>,
     skip_images: Option<bool>,
+    url_escape_style: Option<UrlEscapeStyle>,
     link_style: Option<LinkStyle>,
     output_format: Option<OutputFormat>,
     include_document_structure: Option<bool>,
@@ -1099,6 +1222,7 @@ pub struct ConversionOptionsUpdate {
     infer_dimensions: Option<bool>,
     max_depth: Option<usize>,
     exclude_selectors: Option<Vec<String>>,
+    tier_strategy: Option<TierStrategy>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptionsUpdate {}
@@ -1129,6 +1253,56 @@ impl magnus::TryConvert for ConversionOptionsUpdate {
 
 unsafe impl TryConvertOwned for ConversionOptionsUpdate {}
 
+impl Default for ConversionOptionsUpdate {
+    fn default() -> Self {
+        Self {
+            heading_style: None,
+            list_indent_type: None,
+            list_indent_width: None,
+            bullets: None,
+            strong_em_symbol: None,
+            escape_asterisks: None,
+            escape_underscores: None,
+            escape_misc: None,
+            escape_ascii: None,
+            code_language: None,
+            autolinks: None,
+            default_title: None,
+            br_in_tables: None,
+            compact_tables: None,
+            highlight_style: None,
+            extract_metadata: None,
+            whitespace_mode: None,
+            strip_newlines: None,
+            wrap: None,
+            wrap_width: None,
+            convert_as_inline: None,
+            sub_symbol: None,
+            sup_symbol: None,
+            newline_style: None,
+            code_block_style: None,
+            keep_inline_images_in: None,
+            preprocessing: None,
+            encoding: None,
+            debug: None,
+            strip_tags: None,
+            preserve_tags: None,
+            skip_images: None,
+            url_escape_style: None,
+            link_style: None,
+            output_format: None,
+            include_document_structure: None,
+            extract_images: None,
+            max_image_size: None,
+            capture_svg: None,
+            infer_dimensions: None,
+            max_depth: None,
+            exclude_selectors: None,
+            tier_strategy: None,
+        }
+    }
+}
+
 impl ConversionOptionsUpdate {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1175,6 +1349,9 @@ impl ConversionOptionsUpdate {
             br_in_tables: kwargs
                 .get(ruby.to_symbol("br_in_tables"))
                 .and_then(|v| bool::try_convert(v).ok()),
+            compact_tables: kwargs
+                .get(ruby.to_symbol("compact_tables"))
+                .and_then(|v| bool::try_convert(v).ok()),
             highlight_style: kwargs
                 .get(ruby.to_symbol("highlight_style"))
                 .and_then(|v| HighlightStyle::try_convert(v).ok()),
@@ -1229,6 +1406,9 @@ impl ConversionOptionsUpdate {
             skip_images: kwargs
                 .get(ruby.to_symbol("skip_images"))
                 .and_then(|v| bool::try_convert(v).ok()),
+            url_escape_style: kwargs
+                .get(ruby.to_symbol("url_escape_style"))
+                .and_then(|v| UrlEscapeStyle::try_convert(v).ok()),
             link_style: kwargs
                 .get(ruby.to_symbol("link_style"))
                 .and_then(|v| LinkStyle::try_convert(v).ok()),
@@ -1256,6 +1436,9 @@ impl ConversionOptionsUpdate {
             exclude_selectors: kwargs
                 .get(ruby.to_symbol("exclude_selectors"))
                 .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            tier_strategy: kwargs
+                .get(ruby.to_symbol("tier_strategy"))
+                .and_then(|v| TierStrategy::try_convert(v).ok()),
         })
     }
 
@@ -1311,6 +1494,10 @@ impl ConversionOptionsUpdate {
         self.br_in_tables
     }
 
+    fn compact_tables(&self) -> Option<bool> {
+        self.compact_tables
+    }
+
     fn highlight_style(&self) -> Option<HighlightStyle> {
         self.highlight_style.clone()
     }
@@ -1383,6 +1570,10 @@ impl ConversionOptionsUpdate {
         self.skip_images
     }
 
+    fn url_escape_style(&self) -> Option<UrlEscapeStyle> {
+        self.url_escape_style.clone()
+    }
+
     fn link_style(&self) -> Option<LinkStyle> {
         self.link_style.clone()
     }
@@ -1418,9 +1609,13 @@ impl ConversionOptionsUpdate {
     fn exclude_selectors(&self) -> Option<Vec<String>> {
         self.exclude_selectors.clone()
     }
+
+    fn tier_strategy(&self) -> Option<TierStrategy> {
+        self.tier_strategy.clone()
+    }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptions")]
 pub struct PreprocessingOptions {
@@ -1458,6 +1653,17 @@ impl magnus::TryConvert for PreprocessingOptions {
 
 unsafe impl TryConvertOwned for PreprocessingOptions {}
 
+impl Default for PreprocessingOptions {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            preset: Default::default(),
+            remove_navigation: true,
+            remove_forms: true,
+        }
+    }
+}
+
 impl PreprocessingOptions {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1499,14 +1705,9 @@ impl PreprocessingOptions {
     fn remove_forms(&self) -> bool {
         self.remove_forms
     }
-
-    #[allow(unused_variables)]
-    fn apply_update(&mut self, update: PreprocessingOptionsUpdate) -> () {
-        ()
-    }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptionsUpdate")]
 pub struct PreprocessingOptionsUpdate {
@@ -1544,6 +1745,17 @@ impl magnus::TryConvert for PreprocessingOptionsUpdate {
 
 unsafe impl TryConvertOwned for PreprocessingOptionsUpdate {}
 
+impl Default for PreprocessingOptionsUpdate {
+    fn default() -> Self {
+        Self {
+            enabled: None,
+            preset: None,
+            remove_navigation: None,
+            remove_forms: None,
+        }
+    }
+}
+
 impl PreprocessingOptionsUpdate {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1583,7 +1795,69 @@ impl PreprocessingOptionsUpdate {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ImageDimensions")]
+pub struct ImageDimensions {
+    width: u32,
+    height: u32,
+}
+
+unsafe impl IntoValueFromNative for ImageDimensions {}
+
+impl magnus::TryConvert for ImageDimensions {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ImageDimensions as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ImageDimensions: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ImageDimensions>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ImageDimensions: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ImageDimensions {}
+
+impl ImageDimensions {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            width: kwargs
+                .get(ruby.to_symbol("width"))
+                .and_then(|v| u32::try_convert(v).ok())
+                .unwrap_or_default(),
+            height: kwargs
+                .get(ruby.to_symbol("height"))
+                .and_then(|v| u32::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn width(&self) -> u32 {
+        self.width
+    }
+
+    fn height(&self) -> u32 {
+        self.height
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentStructure")]
 pub struct DocumentStructure {
     nodes: Vec<DocumentNode>,
@@ -1644,7 +1918,7 @@ impl DocumentStructure {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentNode")]
 pub struct DocumentNode {
     id: String,
@@ -1683,6 +1957,19 @@ impl magnus::TryConvert for DocumentNode {
 
 unsafe impl TryConvertOwned for DocumentNode {}
 
+impl Default for DocumentNode {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            content: NodeContent::default(),
+            parent: None,
+            children: vec![],
+            annotations: vec![],
+            attributes: None,
+        }
+    }
+}
+
 impl DocumentNode {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1697,18 +1984,23 @@ impl DocumentNode {
             content: kwargs
                 .get(ruby.to_symbol("content"))
                 .and_then(|v| NodeContent::try_convert(v).ok())
-                .unwrap_or(NodeContent::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: content",
+                    )
+                })?,
             parent: kwargs
                 .get(ruby.to_symbol("parent"))
                 .and_then(|v| u32::try_convert(v).ok()),
             children: kwargs
                 .get(ruby.to_symbol("children"))
                 .and_then(|v| <Vec<u32>>::try_convert(v).ok())
-                .unwrap_or_default(),
+                .unwrap_or(vec![]),
             annotations: kwargs
                 .get(ruby.to_symbol("annotations"))
                 .and_then(|v| <Vec<TextAnnotation>>::try_convert(v).ok())
-                .unwrap_or_default(),
+                .unwrap_or(vec![]),
             attributes: kwargs
                 .get(ruby.to_symbol("attributes"))
                 .and_then(|v| <HashMap<String, String>>::try_convert(v).ok()),
@@ -1740,7 +2032,7 @@ impl DocumentNode {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TextAnnotation")]
 pub struct TextAnnotation {
     start: u32,
@@ -1794,7 +2086,12 @@ impl TextAnnotation {
             kind: kwargs
                 .get(ruby.to_symbol("kind"))
                 .and_then(|v| AnnotationKind::try_convert(v).ok())
-                .unwrap_or(AnnotationKind::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: kind",
+                    )
+                })?,
         })
     }
 
@@ -1811,7 +2108,69 @@ impl TextAnnotation {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::MetadataEntry")]
+pub struct MetadataEntry {
+    key: String,
+    value: String,
+}
+
+unsafe impl IntoValueFromNative for MetadataEntry {}
+
+impl magnus::TryConvert for MetadataEntry {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&MetadataEntry as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into MetadataEntry: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<MetadataEntry>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize MetadataEntry: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for MetadataEntry {}
+
+impl MetadataEntry {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            key: kwargs
+                .get(ruby.to_symbol("key"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            value: kwargs
+                .get(ruby.to_symbol("value"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn key(&self) -> String {
+        self.key.clone()
+    }
+
+    fn value(&self) -> String {
+        self.value.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionResult")]
 pub struct ConversionResult {
@@ -1819,7 +2178,6 @@ pub struct ConversionResult {
     document: Option<DocumentStructure>,
     metadata: HtmlMetadata,
     tables: Vec<TableData>,
-    images: Vec<String>,
     warnings: Vec<ProcessingWarning>,
 }
 
@@ -1851,6 +2209,18 @@ impl magnus::TryConvert for ConversionResult {
 
 unsafe impl TryConvertOwned for ConversionResult {}
 
+impl Default for ConversionResult {
+    fn default() -> Self {
+        Self {
+            content: None,
+            document: None,
+            metadata: Default::default(),
+            tables: vec![],
+            warnings: vec![],
+        }
+    }
+}
+
 impl ConversionResult {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1872,10 +2242,6 @@ impl ConversionResult {
                 .get(ruby.to_symbol("tables"))
                 .and_then(|v| <Vec<TableData>>::try_convert(v).ok())
                 .unwrap_or_default(),
-            images: kwargs
-                .get(ruby.to_symbol("images"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
             warnings: kwargs
                 .get(ruby.to_symbol("warnings"))
                 .and_then(|v| <Vec<ProcessingWarning>>::try_convert(v).ok())
@@ -1899,10 +2265,6 @@ impl ConversionResult {
         self.tables.clone()
     }
 
-    fn images(&self) -> Vec<String> {
-        self.images.clone()
-    }
-
     fn warnings(&self) -> Vec<ProcessingWarning> {
         self.warnings.clone()
     }
@@ -1913,7 +2275,7 @@ impl ConversionResult {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TableGrid")]
 pub struct TableGrid {
@@ -1950,6 +2312,16 @@ impl magnus::TryConvert for TableGrid {
 
 unsafe impl TryConvertOwned for TableGrid {}
 
+impl Default for TableGrid {
+    fn default() -> Self {
+        Self {
+            rows: 0,
+            cols: 0,
+            cells: vec![],
+        }
+    }
+}
+
 impl TableGrid {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1985,7 +2357,7 @@ impl TableGrid {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::GridCell")]
 pub struct GridCell {
     content: String,
@@ -2024,6 +2396,19 @@ impl magnus::TryConvert for GridCell {
 
 unsafe impl TryConvertOwned for GridCell {}
 
+impl Default for GridCell {
+    fn default() -> Self {
+        Self {
+            content: String::new(),
+            row: 0,
+            col: 0,
+            row_span: 0,
+            col_span: 0,
+            is_header: false,
+        }
+    }
+}
+
 impl GridCell {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -2046,15 +2431,15 @@ impl GridCell {
             row_span: kwargs
                 .get(ruby.to_symbol("row_span"))
                 .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
+                .unwrap_or(0),
             col_span: kwargs
                 .get(ruby.to_symbol("col_span"))
                 .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
+                .unwrap_or(0),
             is_header: kwargs
                 .get(ruby.to_symbol("is_header"))
                 .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or_default(),
+                .unwrap_or(false),
         })
     }
 
@@ -2088,7 +2473,7 @@ impl GridCell {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TableData")]
 pub struct TableData {
     grid: TableGrid,
@@ -2133,7 +2518,12 @@ impl TableData {
             grid: kwargs
                 .get(ruby.to_symbol("grid"))
                 .and_then(|v| TableGrid::try_convert(v).ok())
-                .unwrap_or(TableGrid::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: grid",
+                    )
+                })?,
             markdown: kwargs
                 .get(ruby.to_symbol("markdown"))
                 .and_then(|v| String::try_convert(v).ok())
@@ -2150,7 +2540,7 @@ impl TableData {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ProcessingWarning")]
 pub struct ProcessingWarning {
     message: String,
@@ -2199,7 +2589,12 @@ impl ProcessingWarning {
             kind: kwargs
                 .get(ruby.to_symbol("kind"))
                 .and_then(|v| WarningKind::try_convert(v).ok())
-                .unwrap_or(WarningKind::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: kind",
+                    )
+                })?,
         })
     }
 
@@ -2212,12 +2607,30 @@ impl ProcessingWarning {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::VisitorHandle")]
+pub struct VisitorHandle {
+    inner: Arc<html_to_markdown_rs::VisitorHandle>,
+}
+
+unsafe impl IntoValueFromNative for VisitorHandle {}
+
+impl magnus::TryConvert for VisitorHandle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &VisitorHandle = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for VisitorHandle {}
+
+impl VisitorHandle {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::NodeContext")]
 pub struct NodeContext {
     node_type: NodeType,
     tag_name: String,
-    attributes: HashMap<String, String>,
     depth: usize,
     index_in_parent: usize,
     parent_tag: Option<String>,
@@ -2262,15 +2675,16 @@ impl NodeContext {
             node_type: kwargs
                 .get(ruby.to_symbol("node_type"))
                 .and_then(|v| NodeType::try_convert(v).ok())
-                .unwrap_or(NodeType::default()),
+                .ok_or_else(|| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: node_type",
+                    )
+                })?,
             tag_name: kwargs
                 .get(ruby.to_symbol("tag_name"))
                 .and_then(|v| String::try_convert(v).ok())
                 .unwrap_or_default(),
-            attributes: kwargs
-                .get(ruby.to_symbol("attributes"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
             depth: kwargs
                 .get(ruby.to_symbol("depth"))
                 .and_then(|v| usize::try_convert(v).ok())
@@ -2297,10 +2711,6 @@ impl NodeContext {
         self.tag_name.clone()
     }
 
-    fn attributes(&self) -> HashMap<String, String> {
-        self.attributes.clone()
-    }
-
     fn depth(&self) -> usize {
         self.depth
     }
@@ -2316,6 +2726,20 @@ impl NodeContext {
     fn is_inline(&self) -> bool {
         self.is_inline
     }
+
+    fn attributes(&self) -> HashMap<String, String> {
+        let core_self = html_to_markdown_rs::NodeContext::from(self.clone());
+        core_self
+            .attributes()
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    }
+
+    fn into_owned(&self) -> NodeContext {
+        let core_self = html_to_markdown_rs::NodeContext::from(self.clone());
+        core_self.into_owned().into()
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
@@ -2348,10 +2772,12 @@ impl magnus::IntoValue for TextDirection {
 impl magnus::TryConvert for TextDirection {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "left_to_right" => Ok(TextDirection::LeftToRight),
-            "right_to_left" => Ok(TextDirection::RightToLeft),
-            "auto" => Ok(TextDirection::Auto),
+            "left_to_right" | "LeftToRight" => Ok(TextDirection::LeftToRight),
+            "right_to_left" | "RightToLeft" => Ok(TextDirection::RightToLeft),
+            "auto" | "Auto" => Ok(TextDirection::Auto),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid TextDirection value: {other}"),
@@ -2397,13 +2823,15 @@ impl magnus::IntoValue for LinkType {
 impl magnus::TryConvert for LinkType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "anchor" => Ok(LinkType::Anchor),
-            "internal" => Ok(LinkType::Internal),
-            "external" => Ok(LinkType::External),
-            "email" => Ok(LinkType::Email),
-            "phone" => Ok(LinkType::Phone),
-            "other" => Ok(LinkType::Other),
+            "anchor" | "Anchor" => Ok(LinkType::Anchor),
+            "internal" | "Internal" => Ok(LinkType::Internal),
+            "external" | "External" => Ok(LinkType::External),
+            "email" | "Email" => Ok(LinkType::Email),
+            "phone" | "Phone" => Ok(LinkType::Phone),
+            "other" | "Other" => Ok(LinkType::Other),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid LinkType value: {other}"),
@@ -2445,11 +2873,13 @@ impl magnus::IntoValue for ImageType {
 impl magnus::TryConvert for ImageType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "data_uri" => Ok(ImageType::DataUri),
-            "inline_svg" => Ok(ImageType::InlineSvg),
-            "external" => Ok(ImageType::External),
-            "relative" => Ok(ImageType::Relative),
+            "data_uri" | "DataUri" => Ok(ImageType::DataUri),
+            "inline_svg" | "InlineSvg" => Ok(ImageType::InlineSvg),
+            "external" | "External" => Ok(ImageType::External),
+            "relative" | "Relative" => Ok(ImageType::Relative),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ImageType value: {other}"),
@@ -2482,7 +2912,7 @@ impl magnus::IntoValue for StructuredDataType {
         let sym = match self {
             StructuredDataType::JsonLd => "json_ld",
             StructuredDataType::Microdata => "microdata",
-            StructuredDataType::RDFa => "r_d_fa",
+            StructuredDataType::RDFa => "rd_fa",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2491,10 +2921,12 @@ impl magnus::IntoValue for StructuredDataType {
 impl magnus::TryConvert for StructuredDataType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "json_ld" => Ok(StructuredDataType::JsonLd),
-            "microdata" => Ok(StructuredDataType::Microdata),
-            "r_d_fa" => Ok(StructuredDataType::RDFa),
+            "json_ld" | "JsonLd" => Ok(StructuredDataType::JsonLd),
+            "microdata" | "Microdata" => Ok(StructuredDataType::Microdata),
+            "rd_fa" | "RDFa" => Ok(StructuredDataType::RDFa),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid StructuredDataType value: {other}"),
@@ -2506,6 +2938,50 @@ impl magnus::TryConvert for StructuredDataType {
 unsafe impl IntoValueFromNative for StructuredDataType {}
 unsafe impl TryConvertOwned for StructuredDataType {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum TierStrategy {
+    Auto,
+    Tier2,
+    Tier1,
+}
+
+impl Default for TierStrategy {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+impl magnus::IntoValue for TierStrategy {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            TierStrategy::Auto => "auto",
+            TierStrategy::Tier2 => "tier2",
+            TierStrategy::Tier1 => "tier1",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for TierStrategy {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
+        match s.as_str() {
+            "auto" | "Auto" => Ok(TierStrategy::Auto),
+            "tier2" | "Tier2" => Ok(TierStrategy::Tier2),
+            "tier1" | "Tier1" => Ok(TierStrategy::Tier1),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid TierStrategy value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for TierStrategy {}
+unsafe impl TryConvertOwned for TierStrategy {}
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PreprocessingPreset {
     Minimal,
@@ -2515,7 +2991,7 @@ pub enum PreprocessingPreset {
 
 impl Default for PreprocessingPreset {
     fn default() -> Self {
-        Self::Minimal
+        Self::Standard
     }
 }
 
@@ -2533,10 +3009,12 @@ impl magnus::IntoValue for PreprocessingPreset {
 impl magnus::TryConvert for PreprocessingPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "minimal" => Ok(PreprocessingPreset::Minimal),
-            "standard" => Ok(PreprocessingPreset::Standard),
-            "aggressive" => Ok(PreprocessingPreset::Aggressive),
+            "minimal" | "Minimal" => Ok(PreprocessingPreset::Minimal),
+            "standard" | "Standard" => Ok(PreprocessingPreset::Standard),
+            "aggressive" | "Aggressive" => Ok(PreprocessingPreset::Aggressive),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid PreprocessingPreset value: {other}"),
@@ -2557,7 +3035,7 @@ pub enum HeadingStyle {
 
 impl Default for HeadingStyle {
     fn default() -> Self {
-        Self::Underlined
+        Self::Atx
     }
 }
 
@@ -2575,10 +3053,12 @@ impl magnus::IntoValue for HeadingStyle {
 impl magnus::TryConvert for HeadingStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "underlined" => Ok(HeadingStyle::Underlined),
-            "atx" => Ok(HeadingStyle::Atx),
-            "atx_closed" => Ok(HeadingStyle::AtxClosed),
+            "underlined" | "Underlined" => Ok(HeadingStyle::Underlined),
+            "atx" | "Atx" => Ok(HeadingStyle::Atx),
+            "atx_closed" | "AtxClosed" => Ok(HeadingStyle::AtxClosed),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid HeadingStyle value: {other}"),
@@ -2615,9 +3095,11 @@ impl magnus::IntoValue for ListIndentType {
 impl magnus::TryConvert for ListIndentType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "spaces" => Ok(ListIndentType::Spaces),
-            "tabs" => Ok(ListIndentType::Tabs),
+            "spaces" | "Spaces" => Ok(ListIndentType::Spaces),
+            "tabs" | "Tabs" => Ok(ListIndentType::Tabs),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ListIndentType value: {other}"),
@@ -2654,9 +3136,11 @@ impl magnus::IntoValue for WhitespaceMode {
 impl magnus::TryConvert for WhitespaceMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "normalized" => Ok(WhitespaceMode::Normalized),
-            "strict" => Ok(WhitespaceMode::Strict),
+            "normalized" | "Normalized" => Ok(WhitespaceMode::Normalized),
+            "strict" | "Strict" => Ok(WhitespaceMode::Strict),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid WhitespaceMode value: {other}"),
@@ -2693,9 +3177,11 @@ impl magnus::IntoValue for NewlineStyle {
 impl magnus::TryConvert for NewlineStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "spaces" => Ok(NewlineStyle::Spaces),
-            "backslash" => Ok(NewlineStyle::Backslash),
+            "spaces" | "Spaces" => Ok(NewlineStyle::Spaces),
+            "backslash" | "Backslash" => Ok(NewlineStyle::Backslash),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid NewlineStyle value: {other}"),
@@ -2716,7 +3202,7 @@ pub enum CodeBlockStyle {
 
 impl Default for CodeBlockStyle {
     fn default() -> Self {
-        Self::Indented
+        Self::Backticks
     }
 }
 
@@ -2734,10 +3220,12 @@ impl magnus::IntoValue for CodeBlockStyle {
 impl magnus::TryConvert for CodeBlockStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "indented" => Ok(CodeBlockStyle::Indented),
-            "backticks" => Ok(CodeBlockStyle::Backticks),
-            "tildes" => Ok(CodeBlockStyle::Tildes),
+            "indented" | "Indented" => Ok(CodeBlockStyle::Indented),
+            "backticks" | "Backticks" => Ok(CodeBlockStyle::Backticks),
+            "tildes" | "Tildes" => Ok(CodeBlockStyle::Tildes),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid CodeBlockStyle value: {other}"),
@@ -2778,11 +3266,13 @@ impl magnus::IntoValue for HighlightStyle {
 impl magnus::TryConvert for HighlightStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "double_equal" => Ok(HighlightStyle::DoubleEqual),
-            "html" => Ok(HighlightStyle::Html),
-            "bold" => Ok(HighlightStyle::Bold),
-            "none" => Ok(HighlightStyle::None),
+            "double_equal" | "DoubleEqual" => Ok(HighlightStyle::DoubleEqual),
+            "html" | "Html" => Ok(HighlightStyle::Html),
+            "bold" | "Bold" => Ok(HighlightStyle::Bold),
+            "none" | "None" => Ok(HighlightStyle::None),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid HighlightStyle value: {other}"),
@@ -2819,9 +3309,11 @@ impl magnus::IntoValue for LinkStyle {
 impl magnus::TryConvert for LinkStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "inline" => Ok(LinkStyle::Inline),
-            "reference" => Ok(LinkStyle::Reference),
+            "inline" | "Inline" => Ok(LinkStyle::Inline),
+            "reference" | "Reference" => Ok(LinkStyle::Reference),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid LinkStyle value: {other}"),
@@ -2834,48 +3326,91 @@ unsafe impl IntoValueFromNative for LinkStyle {}
 unsafe impl TryConvertOwned for LinkStyle {}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
-pub enum OutputFormat {
-    Markdown,
-    Djot,
-    Plain,
+pub enum UrlEscapeStyle {
+    Angle,
+    Percent,
 }
 
-impl Default for OutputFormat {
+impl Default for UrlEscapeStyle {
     fn default() -> Self {
-        Self::Markdown
+        Self::Angle
     }
 }
 
-impl magnus::IntoValue for OutputFormat {
+impl magnus::IntoValue for UrlEscapeStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            OutputFormat::Markdown => "markdown",
-            OutputFormat::Djot => "djot",
-            OutputFormat::Plain => "plain",
+            UrlEscapeStyle::Angle => "angle",
+            UrlEscapeStyle::Percent => "percent",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
 }
 
-impl magnus::TryConvert for OutputFormat {
+impl magnus::TryConvert for UrlEscapeStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "markdown" => Ok(OutputFormat::Markdown),
-            "djot" => Ok(OutputFormat::Djot),
-            "plain" => Ok(OutputFormat::Plain),
+            "angle" | "Angle" => Ok(UrlEscapeStyle::Angle),
+            "percent" | "Percent" => Ok(UrlEscapeStyle::Percent),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
-                format!("invalid OutputFormat value: {other}"),
+                format!("invalid UrlEscapeStyle value: {other}"),
             )),
         }
     }
 }
 
-unsafe impl IntoValueFromNative for OutputFormat {}
-unsafe impl TryConvertOwned for OutputFormat {}
+unsafe impl IntoValueFromNative for UrlEscapeStyle {}
+unsafe impl TryConvertOwned for UrlEscapeStyle {}
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum OutputFormat {
+    Markdown,
+    Djot,
+    Plain,
+}
+
+impl Default for OutputFormat {
+    fn default() -> Self {
+        Self::Markdown
+    }
+}
+
+impl magnus::IntoValue for OutputFormat {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            OutputFormat::Markdown => "markdown",
+            OutputFormat::Djot => "djot",
+            OutputFormat::Plain => "plain",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for OutputFormat {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
+        match s.as_str() {
+            "markdown" | "Markdown" => Ok(OutputFormat::Markdown),
+            "djot" | "Djot" => Ok(OutputFormat::Djot),
+            "plain" | "Plain" => Ok(OutputFormat::Plain),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid OutputFormat value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for OutputFormat {}
+unsafe impl TryConvertOwned for OutputFormat {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "node_type")]
 #[serde(rename_all = "snake_case")]
 pub enum NodeContent {
@@ -2915,7 +3450,7 @@ pub enum NodeContent {
         content: String,
     },
     MetadataBlock {
-        entries: Vec<String>,
+        entries: Vec<MetadataEntry>,
     },
     Group {
         label: Option<String>,
@@ -2944,15 +3479,26 @@ impl magnus::IntoValue for NodeContent {
 
 impl magnus::TryConvert for NodeContent {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into NodeContent: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2997,15 +3543,26 @@ impl magnus::IntoValue for AnnotationKind {
 
 impl magnus::TryConvert for AnnotationKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into AnnotationKind: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -3052,13 +3609,15 @@ impl magnus::IntoValue for WarningKind {
 impl magnus::TryConvert for WarningKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "image_extraction_failed" => Ok(WarningKind::ImageExtractionFailed),
-            "encoding_fallback" => Ok(WarningKind::EncodingFallback),
-            "truncated_input" => Ok(WarningKind::TruncatedInput),
-            "malformed_html" => Ok(WarningKind::MalformedHtml),
-            "sanitization_applied" => Ok(WarningKind::SanitizationApplied),
-            "depth_limit_exceeded" => Ok(WarningKind::DepthLimitExceeded),
+            "image_extraction_failed" | "ImageExtractionFailed" => Ok(WarningKind::ImageExtractionFailed),
+            "encoding_fallback" | "EncodingFallback" => Ok(WarningKind::EncodingFallback),
+            "truncated_input" | "TruncatedInput" => Ok(WarningKind::TruncatedInput),
+            "malformed_html" | "MalformedHtml" => Ok(WarningKind::MalformedHtml),
+            "sanitization_applied" | "SanitizationApplied" => Ok(WarningKind::SanitizationApplied),
+            "depth_limit_exceeded" | "DepthLimitExceeded" => Ok(WarningKind::DepthLimitExceeded),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid WarningKind value: {other}"),
@@ -3267,95 +3826,97 @@ impl magnus::IntoValue for NodeType {
 impl magnus::TryConvert for NodeType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "text" => Ok(NodeType::Text),
-            "element" => Ok(NodeType::Element),
-            "heading" => Ok(NodeType::Heading),
-            "paragraph" => Ok(NodeType::Paragraph),
-            "div" => Ok(NodeType::Div),
-            "blockquote" => Ok(NodeType::Blockquote),
-            "pre" => Ok(NodeType::Pre),
-            "hr" => Ok(NodeType::Hr),
-            "list" => Ok(NodeType::List),
-            "list_item" => Ok(NodeType::ListItem),
-            "definition_list" => Ok(NodeType::DefinitionList),
-            "definition_term" => Ok(NodeType::DefinitionTerm),
-            "definition_description" => Ok(NodeType::DefinitionDescription),
-            "table" => Ok(NodeType::Table),
-            "table_row" => Ok(NodeType::TableRow),
-            "table_cell" => Ok(NodeType::TableCell),
-            "table_header" => Ok(NodeType::TableHeader),
-            "table_body" => Ok(NodeType::TableBody),
-            "table_head" => Ok(NodeType::TableHead),
-            "table_foot" => Ok(NodeType::TableFoot),
-            "link" => Ok(NodeType::Link),
-            "image" => Ok(NodeType::Image),
-            "strong" => Ok(NodeType::Strong),
-            "em" => Ok(NodeType::Em),
-            "code" => Ok(NodeType::Code),
-            "strikethrough" => Ok(NodeType::Strikethrough),
-            "underline" => Ok(NodeType::Underline),
-            "subscript" => Ok(NodeType::Subscript),
-            "superscript" => Ok(NodeType::Superscript),
-            "mark" => Ok(NodeType::Mark),
-            "small" => Ok(NodeType::Small),
-            "br" => Ok(NodeType::Br),
-            "span" => Ok(NodeType::Span),
-            "article" => Ok(NodeType::Article),
-            "section" => Ok(NodeType::Section),
-            "nav" => Ok(NodeType::Nav),
-            "aside" => Ok(NodeType::Aside),
-            "header" => Ok(NodeType::Header),
-            "footer" => Ok(NodeType::Footer),
-            "main" => Ok(NodeType::Main),
-            "figure" => Ok(NodeType::Figure),
-            "figcaption" => Ok(NodeType::Figcaption),
-            "time" => Ok(NodeType::Time),
-            "details" => Ok(NodeType::Details),
-            "summary" => Ok(NodeType::Summary),
-            "form" => Ok(NodeType::Form),
-            "input" => Ok(NodeType::Input),
-            "select" => Ok(NodeType::Select),
-            "option" => Ok(NodeType::Option),
-            "button" => Ok(NodeType::Button),
-            "textarea" => Ok(NodeType::Textarea),
-            "label" => Ok(NodeType::Label),
-            "fieldset" => Ok(NodeType::Fieldset),
-            "legend" => Ok(NodeType::Legend),
-            "audio" => Ok(NodeType::Audio),
-            "video" => Ok(NodeType::Video),
-            "picture" => Ok(NodeType::Picture),
-            "source" => Ok(NodeType::Source),
-            "iframe" => Ok(NodeType::Iframe),
-            "svg" => Ok(NodeType::Svg),
-            "canvas" => Ok(NodeType::Canvas),
-            "ruby" => Ok(NodeType::Ruby),
-            "rt" => Ok(NodeType::Rt),
-            "rp" => Ok(NodeType::Rp),
-            "abbr" => Ok(NodeType::Abbr),
-            "kbd" => Ok(NodeType::Kbd),
-            "samp" => Ok(NodeType::Samp),
-            "var" => Ok(NodeType::Var),
-            "cite" => Ok(NodeType::Cite),
-            "q" => Ok(NodeType::Q),
-            "del" => Ok(NodeType::Del),
-            "ins" => Ok(NodeType::Ins),
-            "data" => Ok(NodeType::Data),
-            "meter" => Ok(NodeType::Meter),
-            "progress" => Ok(NodeType::Progress),
-            "output" => Ok(NodeType::Output),
-            "template" => Ok(NodeType::Template),
-            "slot" => Ok(NodeType::Slot),
-            "html" => Ok(NodeType::Html),
-            "head" => Ok(NodeType::Head),
-            "body" => Ok(NodeType::Body),
-            "title" => Ok(NodeType::Title),
-            "meta" => Ok(NodeType::Meta),
-            "link_tag" => Ok(NodeType::LinkTag),
-            "style" => Ok(NodeType::Style),
-            "script" => Ok(NodeType::Script),
-            "base" => Ok(NodeType::Base),
-            "custom" => Ok(NodeType::Custom),
+            "text" | "Text" => Ok(NodeType::Text),
+            "element" | "Element" => Ok(NodeType::Element),
+            "heading" | "Heading" => Ok(NodeType::Heading),
+            "paragraph" | "Paragraph" => Ok(NodeType::Paragraph),
+            "div" | "Div" => Ok(NodeType::Div),
+            "blockquote" | "Blockquote" => Ok(NodeType::Blockquote),
+            "pre" | "Pre" => Ok(NodeType::Pre),
+            "hr" | "Hr" => Ok(NodeType::Hr),
+            "list" | "List" => Ok(NodeType::List),
+            "list_item" | "ListItem" => Ok(NodeType::ListItem),
+            "definition_list" | "DefinitionList" => Ok(NodeType::DefinitionList),
+            "definition_term" | "DefinitionTerm" => Ok(NodeType::DefinitionTerm),
+            "definition_description" | "DefinitionDescription" => Ok(NodeType::DefinitionDescription),
+            "table" | "Table" => Ok(NodeType::Table),
+            "table_row" | "TableRow" => Ok(NodeType::TableRow),
+            "table_cell" | "TableCell" => Ok(NodeType::TableCell),
+            "table_header" | "TableHeader" => Ok(NodeType::TableHeader),
+            "table_body" | "TableBody" => Ok(NodeType::TableBody),
+            "table_head" | "TableHead" => Ok(NodeType::TableHead),
+            "table_foot" | "TableFoot" => Ok(NodeType::TableFoot),
+            "link" | "Link" => Ok(NodeType::Link),
+            "image" | "Image" => Ok(NodeType::Image),
+            "strong" | "Strong" => Ok(NodeType::Strong),
+            "em" | "Em" => Ok(NodeType::Em),
+            "code" | "Code" => Ok(NodeType::Code),
+            "strikethrough" | "Strikethrough" => Ok(NodeType::Strikethrough),
+            "underline" | "Underline" => Ok(NodeType::Underline),
+            "subscript" | "Subscript" => Ok(NodeType::Subscript),
+            "superscript" | "Superscript" => Ok(NodeType::Superscript),
+            "mark" | "Mark" => Ok(NodeType::Mark),
+            "small" | "Small" => Ok(NodeType::Small),
+            "br" | "Br" => Ok(NodeType::Br),
+            "span" | "Span" => Ok(NodeType::Span),
+            "article" | "Article" => Ok(NodeType::Article),
+            "section" | "Section" => Ok(NodeType::Section),
+            "nav" | "Nav" => Ok(NodeType::Nav),
+            "aside" | "Aside" => Ok(NodeType::Aside),
+            "header" | "Header" => Ok(NodeType::Header),
+            "footer" | "Footer" => Ok(NodeType::Footer),
+            "main" | "Main" => Ok(NodeType::Main),
+            "figure" | "Figure" => Ok(NodeType::Figure),
+            "figcaption" | "Figcaption" => Ok(NodeType::Figcaption),
+            "time" | "Time" => Ok(NodeType::Time),
+            "details" | "Details" => Ok(NodeType::Details),
+            "summary" | "Summary" => Ok(NodeType::Summary),
+            "form" | "Form" => Ok(NodeType::Form),
+            "input" | "Input" => Ok(NodeType::Input),
+            "select" | "Select" => Ok(NodeType::Select),
+            "option" | "Option" => Ok(NodeType::Option),
+            "button" | "Button" => Ok(NodeType::Button),
+            "textarea" | "Textarea" => Ok(NodeType::Textarea),
+            "label" | "Label" => Ok(NodeType::Label),
+            "fieldset" | "Fieldset" => Ok(NodeType::Fieldset),
+            "legend" | "Legend" => Ok(NodeType::Legend),
+            "audio" | "Audio" => Ok(NodeType::Audio),
+            "video" | "Video" => Ok(NodeType::Video),
+            "picture" | "Picture" => Ok(NodeType::Picture),
+            "source" | "Source" => Ok(NodeType::Source),
+            "iframe" | "Iframe" => Ok(NodeType::Iframe),
+            "svg" | "Svg" => Ok(NodeType::Svg),
+            "canvas" | "Canvas" => Ok(NodeType::Canvas),
+            "ruby" | "Ruby" => Ok(NodeType::Ruby),
+            "rt" | "Rt" => Ok(NodeType::Rt),
+            "rp" | "Rp" => Ok(NodeType::Rp),
+            "abbr" | "Abbr" => Ok(NodeType::Abbr),
+            "kbd" | "Kbd" => Ok(NodeType::Kbd),
+            "samp" | "Samp" => Ok(NodeType::Samp),
+            "var" | "Var" => Ok(NodeType::Var),
+            "cite" | "Cite" => Ok(NodeType::Cite),
+            "q" | "Q" => Ok(NodeType::Q),
+            "del" | "Del" => Ok(NodeType::Del),
+            "ins" | "Ins" => Ok(NodeType::Ins),
+            "data" | "Data" => Ok(NodeType::Data),
+            "meter" | "Meter" => Ok(NodeType::Meter),
+            "progress" | "Progress" => Ok(NodeType::Progress),
+            "output" | "Output" => Ok(NodeType::Output),
+            "template" | "Template" => Ok(NodeType::Template),
+            "slot" | "Slot" => Ok(NodeType::Slot),
+            "html" | "Html" => Ok(NodeType::Html),
+            "head" | "Head" => Ok(NodeType::Head),
+            "body" | "Body" => Ok(NodeType::Body),
+            "title" | "Title" => Ok(NodeType::Title),
+            "meta" | "Meta" => Ok(NodeType::Meta),
+            "link_tag" | "LinkTag" => Ok(NodeType::LinkTag),
+            "style" | "Style" => Ok(NodeType::Style),
+            "script" | "Script" => Ok(NodeType::Script),
+            "base" | "Base" => Ok(NodeType::Base),
+            "custom" | "Custom" => Ok(NodeType::Custom),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid NodeType value: {other}"),
@@ -3393,15 +3954,26 @@ impl magnus::IntoValue for VisitResult {
 
 impl magnus::TryConvert for VisitResult {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into VisitResult: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -3422,12 +3994,23 @@ pub fn convert(args: &[magnus::Value]) -> Result<ConversionResult, Error> {
     let options_core = match visitor {
         Some(v) if !v.is_nil() => {
             if magnus::RHash::from_value(v).is_some() {
-                let json = v.funcall::<_, _, String>("to_json", ()).unwrap_or_default();
-                serde_json::from_str::<html_to_markdown_rs::ConversionOptions>(&json).unwrap_or_default()
+                let json = v.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(),
+                        format!("failed to serialize Ruby options to JSON: {}", e),
+                    )
+                })?;
+                serde_json::from_str::<html_to_markdown_rs::ConversionOptions>(&json).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(),
+                        format!("failed to deserialize options JSON: {}", e),
+                    )
+                })?
+            } else if let Ok(opts_binding) = <&ConversionOptions as magnus::TryConvert>::try_convert(v) {
+                opts_binding.clone().into()
             } else {
                 let bridge = RbHtmlVisitorBridge::new(v);
-                let handle =
-                    std::rc::Rc::new(std::cell::RefCell::new(bridge)) as html_to_markdown_rs::visitor::VisitorHandle;
+                let handle = std::sync::Arc::new(std::sync::Mutex::new(bridge)) as html_to_markdown_rs::VisitorHandle;
                 let mut opts = html_to_markdown_rs::ConversionOptions::default();
                 opts.visitor = Some(handle);
                 opts
@@ -3445,25 +4028,21 @@ pub fn convert(args: &[magnus::Value]) -> Result<ConversionResult, Error> {
         })
 }
 
-fn nodecontext_to_rb_hash(ctx: &html_to_markdown_rs::visitor::NodeContext) -> magnus::RHash {
+fn nodecontext_to_rb_hash(ctx: &html_to_markdown_rs::NodeContext) -> magnus::RHash {
     let ruby = unsafe { magnus::Ruby::get_unchecked() };
     let h = ruby.hash_new();
     h.aset(ruby.to_symbol("node_type"), format!("{:?}", ctx.node_type)).ok();
-    h.aset(ruby.to_symbol("tag_name"), ctx.tag_name.as_str()).ok();
+    h.aset(ruby.to_symbol("tag_name"), AsRef::<str>::as_ref(&ctx.tag_name))
+        .ok();
     h.aset(ruby.to_symbol("depth"), ctx.depth as i64).ok();
     h.aset(ruby.to_symbol("index_in_parent"), ctx.index_in_parent as i64)
         .ok();
-    h.aset(ruby.to_symbol("is_inline"), ctx.is_inline).ok();
     h.aset(
         ruby.to_symbol("parent_tag"),
-        ctx.parent_tag.as_deref().map(|s| ruby.str_new(s).as_value()),
+        ctx.parent_tag.as_deref().map(|value| ruby.str_new(value).as_value()),
     )
     .ok();
-    let attrs = ruby.hash_new();
-    for (k, v) in &ctx.attributes {
-        attrs.aset(ruby.str_new(k), ruby.str_new(v)).ok();
-    }
-    h.aset(ruby.to_symbol("attributes"), attrs).ok();
+    h.aset(ruby.to_symbol("is_inline"), ctx.is_inline).ok();
     h
 }
 
@@ -3483,81 +4062,96 @@ impl RbHtmlVisitorBridge {
     }
 }
 
+// SAFETY: `magnus::Value` wraps a `VALUE` (a GC-managed Ruby object pointer).
+// Ruby is effectively single-threaded (GIL/GVL); the bridge is only invoked
+// synchronously from the Ruby thread that constructed it. The `Arc<Mutex>`
+// outer wrapper ensures exclusive access. Sending the bridge across threads
+// would cause undefined behaviour in the Ruby runtime — callers must not do so.
+unsafe impl Send for RbHtmlVisitorBridge {}
+// SAFETY: see Send impl above.
+unsafe impl Sync for RbHtmlVisitorBridge {}
+
 impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
-    fn visit_element_start(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
-        let responds = self.rb_obj.respond_to("visit_element_start", false).unwrap_or(false);
+    fn visit_text(&mut self, _ctx: &html_to_markdown_rs::NodeContext, _text: &str) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_text", false).unwrap_or(false);
         if !responds {
             return html_to_markdown_rs::VisitResult::Continue;
         }
-        let result: Result<magnus::Value, magnus::Error> = self
-            .rb_obj
-            .funcall("visit_element_start", (nodecontext_to_rb_hash(_ctx),));
+        let result: Result<magnus::Value, magnus::Error> = self.rb_obj.funcall(
+            "visit_text",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_text)
+            }),
+        );
         match result {
             Err(_) => html_to_markdown_rs::VisitResult::Continue,
             Ok(val) => {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
     }
-    fn visit_element_end(
-        &mut self,
-        _ctx: &html_to_markdown_rs::NodeContext,
-        _output: &str,
-    ) -> html_to_markdown_rs::VisitResult {
-        let responds = self.rb_obj.respond_to("visit_element_end", false).unwrap_or(false);
+    fn visit_element_start(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_element_start", false).unwrap_or(false);
         if !responds {
             return html_to_markdown_rs::VisitResult::Continue;
         }
-        let result: Result<magnus::Value, magnus::Error> = self.rb_obj.funcall(
-            "visit_element_end",
-            (nodecontext_to_rb_hash(_ctx), {
-                let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                ruby.str_new(_output)
-            }),
-        );
+        let result: Result<magnus::Value, magnus::Error> = self
+            .rb_obj
+            .funcall("visit_element_start", (nodecontext_to_rb_hash(_ctx),));
         match result {
             Err(_) => html_to_markdown_rs::VisitResult::Continue,
             Ok(val) => {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
     }
-    fn visit_text(&mut self, _ctx: &html_to_markdown_rs::NodeContext, _text: &str) -> html_to_markdown_rs::VisitResult {
-        let responds = self.rb_obj.respond_to("visit_text", false).unwrap_or(false);
+    fn visit_element_end(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _output: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_element_end", false).unwrap_or(false);
         if !responds {
             return html_to_markdown_rs::VisitResult::Continue;
         }
         let result: Result<magnus::Value, magnus::Error> = self.rb_obj.funcall(
-            "visit_text",
+            "visit_element_end",
             (nodecontext_to_rb_hash(_ctx), {
                 let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                ruby.str_new(_text)
+                ruby.str_new(_output)
             }),
         );
         match result {
@@ -3566,16 +4160,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3618,16 +4215,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3670,16 +4270,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3719,16 +4322,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3766,16 +4372,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3802,16 +4411,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3848,16 +4460,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3880,16 +4495,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3917,16 +4535,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3945,16 +4566,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -3989,16 +4613,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4025,16 +4652,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4066,16 +4696,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4102,16 +4735,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4138,16 +4774,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4174,16 +4813,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4210,16 +4852,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4246,16 +4891,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4282,16 +4930,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4314,16 +4965,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4341,16 +4995,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4369,16 +5026,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4413,16 +5073,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4447,16 +5110,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4483,16 +5149,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4522,16 +5191,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4561,16 +5233,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4611,16 +5286,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4666,16 +5344,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4702,16 +5383,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4741,16 +5425,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4780,16 +5467,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4819,16 +5509,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4851,16 +5544,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4887,16 +5583,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4915,16 +5614,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4951,16 +5653,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -4987,16 +5692,19 @@ impl html_to_markdown_rs::visitor::HtmlVisitor for RbHtmlVisitorBridge {
                 // Hash with :custom key — e.g. { custom: '--- {text} ---' }
                 if let Some(hash) = magnus::RHash::from_value(val) {
                     let ruby = unsafe { magnus::Ruby::get_unchecked() };
-                    if let Some(custom_val) = hash.get(ruby.to_symbol("custom")) {
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Custom")) {
                         return html_to_markdown_rs::VisitResult::Custom(custom_val.to_string());
                     }
+                    if let Some(custom_val) = hash.get(ruby.to_symbol("Error")) {
+                        return html_to_markdown_rs::VisitResult::Error(custom_val.to_string());
+                    }
                 }
                 let s: String = val.to_string();
-                match s.to_lowercase().as_str() {
-                    "continue" => html_to_markdown_rs::VisitResult::Continue,
-                    "skip" => html_to_markdown_rs::VisitResult::Skip,
-                    "preserve_html" | "preservehtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
-                    other => html_to_markdown_rs::VisitResult::Custom(other.to_string()),
+                match s.as_str() {
+                    "Continue" => html_to_markdown_rs::VisitResult::Continue,
+                    "Skip" => html_to_markdown_rs::VisitResult::Skip,
+                    "PreserveHtml" => html_to_markdown_rs::VisitResult::PreserveHtml,
+                    _ => html_to_markdown_rs::VisitResult::Continue,
                 }
             }
         }
@@ -5009,7 +5717,7 @@ impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata
         Self {
             title: val.title,
             description: val.description,
-            keywords: val.keywords,
+            keywords: val.keywords.into_iter().collect(),
             author: val.author,
             canonical_url: val.canonical_url,
             base_href: val.base_href,
@@ -5030,13 +5738,13 @@ impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata
 impl From<html_to_markdown_rs::metadata::DocumentMetadata> for DocumentMetadata {
     fn from(val: html_to_markdown_rs::metadata::DocumentMetadata) -> Self {
         Self {
-            title: val.title,
-            description: val.description,
-            keywords: val.keywords,
-            author: val.author,
-            canonical_url: val.canonical_url,
-            base_href: val.base_href,
-            language: val.language,
+            title: val.title.map(|v| v.to_string()),
+            description: val.description.map(|v| v.to_string()),
+            keywords: val.keywords.into_iter().collect(),
+            author: val.author.map(|v| v.to_string()),
+            canonical_url: val.canonical_url.map(|v| v.to_string()),
+            base_href: val.base_href.map(|v| v.to_string()),
+            language: val.language.map(|v| v.to_string()),
             text_direction: val.text_direction.map(Into::into),
             open_graph: val.open_graph.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
             twitter_card: val
@@ -5067,8 +5775,8 @@ impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
     fn from(val: html_to_markdown_rs::metadata::HeaderMetadata) -> Self {
         Self {
             level: val.level,
-            text: val.text,
-            id: val.id,
+            text: val.text.to_string(),
+            id: val.id.map(|v| v.to_string()),
             depth: val.depth,
             html_offset: val.html_offset,
         }
@@ -5083,7 +5791,7 @@ impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
             text: val.text,
             title: val.title,
             link_type: val.link_type.into(),
-            rel: val.rel,
+            rel: val.rel.into_iter().collect(),
             attributes: val.attributes.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
         }
     }
@@ -5093,11 +5801,11 @@ impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
 impl From<html_to_markdown_rs::metadata::LinkMetadata> for LinkMetadata {
     fn from(val: html_to_markdown_rs::metadata::LinkMetadata) -> Self {
         Self {
-            href: val.href,
-            text: val.text,
-            title: val.title,
+            href: val.href.to_string(),
+            text: val.text.to_string(),
+            title: val.title.map(|v| v.to_string()),
             link_type: val.link_type.into(),
-            rel: val.rel,
+            rel: val.rel.into_iter().collect(),
             attributes: val.attributes.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
         }
     }
@@ -5110,7 +5818,7 @@ impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
             src: val.src,
             alt: val.alt,
             title: val.title,
-            dimensions: Default::default(),
+            dimensions: val.dimensions.map(Into::into),
             image_type: val.image_type.into(),
             attributes: val.attributes.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
         }
@@ -5121,13 +5829,10 @@ impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
 impl From<html_to_markdown_rs::metadata::ImageMetadata> for ImageMetadata {
     fn from(val: html_to_markdown_rs::metadata::ImageMetadata) -> Self {
         Self {
-            src: val.src,
-            alt: val.alt,
-            title: val.title,
-            dimensions: val.dimensions.map(|t| {
-                let arr: Vec<_> = [t.0, t.1].into_iter().map(|v| v as _).collect();
-                arr
-            }),
+            src: val.src.to_string(),
+            alt: val.alt.map(|v| v.to_string()),
+            title: val.title.map(|v| v.to_string()),
+            dimensions: val.dimensions.map(Into::into),
             image_type: val.image_type.into(),
             attributes: val.attributes.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
         }
@@ -5150,8 +5855,8 @@ impl From<html_to_markdown_rs::metadata::StructuredData> for StructuredData {
     fn from(val: html_to_markdown_rs::metadata::StructuredData) -> Self {
         Self {
             data_type: val.data_type.into(),
-            raw_json: val.raw_json,
-            schema_type: val.schema_type,
+            raw_json: val.raw_json.to_string(),
+            schema_type: val.schema_type.map(|v| v.to_string()),
         }
     }
 }
@@ -5200,6 +5905,7 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             autolinks: val.autolinks,
             default_title: val.default_title,
             br_in_tables: val.br_in_tables,
+            compact_tables: val.compact_tables,
             highlight_style: val.highlight_style.into(),
             extract_metadata: val.extract_metadata,
             whitespace_mode: val.whitespace_mode.into(),
@@ -5211,13 +5917,14 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             sup_symbol: val.sup_symbol,
             newline_style: val.newline_style.into(),
             code_block_style: val.code_block_style.into(),
-            keep_inline_images_in: val.keep_inline_images_in,
+            keep_inline_images_in: val.keep_inline_images_in.into_iter().collect(),
             preprocessing: val.preprocessing.into(),
             encoding: val.encoding,
             debug: val.debug,
-            strip_tags: val.strip_tags,
-            preserve_tags: val.preserve_tags,
+            strip_tags: val.strip_tags.into_iter().collect(),
+            preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
             include_document_structure: val.include_document_structure,
@@ -5226,7 +5933,8 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
             max_depth: val.max_depth,
-            exclude_selectors: val.exclude_selectors,
+            exclude_selectors: val.exclude_selectors.into_iter().collect(),
+            tier_strategy: val.tier_strategy.into(),
             ..Default::default()
         }
     }
@@ -5239,16 +5947,17 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             heading_style: val.heading_style.into(),
             list_indent_type: val.list_indent_type.into(),
             list_indent_width: val.list_indent_width,
-            bullets: val.bullets,
+            bullets: val.bullets.to_string(),
             strong_em_symbol: val.strong_em_symbol.to_string(),
             escape_asterisks: val.escape_asterisks,
             escape_underscores: val.escape_underscores,
             escape_misc: val.escape_misc,
             escape_ascii: val.escape_ascii,
-            code_language: val.code_language,
+            code_language: val.code_language.to_string(),
             autolinks: val.autolinks,
             default_title: val.default_title,
             br_in_tables: val.br_in_tables,
+            compact_tables: val.compact_tables,
             highlight_style: val.highlight_style.into(),
             extract_metadata: val.extract_metadata,
             whitespace_mode: val.whitespace_mode.into(),
@@ -5256,17 +5965,18 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             convert_as_inline: val.convert_as_inline,
-            sub_symbol: val.sub_symbol,
-            sup_symbol: val.sup_symbol,
+            sub_symbol: val.sub_symbol.to_string(),
+            sup_symbol: val.sup_symbol.to_string(),
             newline_style: val.newline_style.into(),
             code_block_style: val.code_block_style.into(),
-            keep_inline_images_in: val.keep_inline_images_in,
+            keep_inline_images_in: val.keep_inline_images_in.into_iter().collect(),
             preprocessing: val.preprocessing.into(),
-            encoding: val.encoding,
+            encoding: val.encoding.to_string(),
             debug: val.debug,
-            strip_tags: val.strip_tags,
-            preserve_tags: val.preserve_tags,
+            strip_tags: val.strip_tags.into_iter().collect(),
+            preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
             include_document_structure: val.include_document_structure,
@@ -5275,57 +5985,8 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
             max_depth: val.max_depth,
-            exclude_selectors: val.exclude_selectors,
-        }
-    }
-}
-
-#[allow(clippy::needless_update)]
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<ConversionOptionsUpdate> for html_to_markdown_rs::options::ConversionOptionsUpdate {
-    fn from(val: ConversionOptionsUpdate) -> Self {
-        Self {
-            heading_style: val.heading_style.map(Into::into),
-            list_indent_type: val.list_indent_type.map(Into::into),
-            list_indent_width: val.list_indent_width,
-            bullets: val.bullets,
-            strong_em_symbol: val.strong_em_symbol.and_then(|s| s.chars().next()),
-            escape_asterisks: val.escape_asterisks,
-            escape_underscores: val.escape_underscores,
-            escape_misc: val.escape_misc,
-            escape_ascii: val.escape_ascii,
-            code_language: val.code_language,
-            autolinks: val.autolinks,
-            default_title: val.default_title,
-            br_in_tables: val.br_in_tables,
-            highlight_style: val.highlight_style.map(Into::into),
-            extract_metadata: val.extract_metadata,
-            whitespace_mode: val.whitespace_mode.map(Into::into),
-            strip_newlines: val.strip_newlines,
-            wrap: val.wrap,
-            wrap_width: val.wrap_width,
-            convert_as_inline: val.convert_as_inline,
-            sub_symbol: val.sub_symbol,
-            sup_symbol: val.sup_symbol,
-            newline_style: val.newline_style.map(Into::into),
-            code_block_style: val.code_block_style.map(Into::into),
-            keep_inline_images_in: val.keep_inline_images_in,
-            preprocessing: val.preprocessing.map(Into::into),
-            encoding: val.encoding,
-            debug: val.debug,
-            strip_tags: val.strip_tags,
-            preserve_tags: val.preserve_tags,
-            skip_images: val.skip_images,
-            link_style: val.link_style.map(Into::into),
-            output_format: val.output_format.map(Into::into),
-            include_document_structure: val.include_document_structure,
-            extract_images: val.extract_images,
-            max_image_size: val.max_image_size,
-            capture_svg: val.capture_svg,
-            infer_dimensions: val.infer_dimensions,
-            max_depth: (val.max_depth).map(Some),
-            exclude_selectors: val.exclude_selectors,
-            ..Default::default()
+            exclude_selectors: val.exclude_selectors.into_iter().collect(),
+            tier_strategy: val.tier_strategy.into(),
         }
     }
 }
@@ -5337,16 +5998,17 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             heading_style: val.heading_style.map(Into::into),
             list_indent_type: val.list_indent_type.map(Into::into),
             list_indent_width: val.list_indent_width,
-            bullets: val.bullets,
+            bullets: val.bullets.map(|v| v.to_string()),
             strong_em_symbol: val.strong_em_symbol.map(|c| c.to_string()),
             escape_asterisks: val.escape_asterisks,
             escape_underscores: val.escape_underscores,
             escape_misc: val.escape_misc,
             escape_ascii: val.escape_ascii,
-            code_language: val.code_language,
+            code_language: val.code_language.map(|v| v.to_string()),
             autolinks: val.autolinks,
             default_title: val.default_title,
             br_in_tables: val.br_in_tables,
+            compact_tables: val.compact_tables,
             highlight_style: val.highlight_style.map(Into::into),
             extract_metadata: val.extract_metadata,
             whitespace_mode: val.whitespace_mode.map(Into::into),
@@ -5354,17 +6016,18 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             convert_as_inline: val.convert_as_inline,
-            sub_symbol: val.sub_symbol,
-            sup_symbol: val.sup_symbol,
+            sub_symbol: val.sub_symbol.map(|v| v.to_string()),
+            sup_symbol: val.sup_symbol.map(|v| v.to_string()),
             newline_style: val.newline_style.map(Into::into),
             code_block_style: val.code_block_style.map(Into::into),
-            keep_inline_images_in: val.keep_inline_images_in,
+            keep_inline_images_in: val.keep_inline_images_in.map(|v| v.into_iter().collect()),
             preprocessing: val.preprocessing.map(Into::into),
-            encoding: val.encoding,
+            encoding: val.encoding.map(|v| v.to_string()),
             debug: val.debug,
-            strip_tags: val.strip_tags,
-            preserve_tags: val.preserve_tags,
+            strip_tags: val.strip_tags.map(|v| v.into_iter().collect()),
+            preserve_tags: val.preserve_tags.map(|v| v.into_iter().collect()),
             skip_images: val.skip_images,
+            url_escape_style: val.url_escape_style.map(Into::into),
             link_style: val.link_style.map(Into::into),
             output_format: val.output_format.map(Into::into),
             include_document_structure: val.include_document_structure,
@@ -5373,7 +6036,8 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
             max_depth: val.max_depth.flatten(),
-            exclude_selectors: val.exclude_selectors,
+            exclude_selectors: val.exclude_selectors.map(|v| v.into_iter().collect()),
+            tier_strategy: val.tier_strategy.map(Into::into),
         }
     }
 }
@@ -5403,8 +6067,8 @@ impl From<html_to_markdown_rs::options::PreprocessingOptions> for PreprocessingO
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<PreprocessingOptionsUpdate> for html_to_markdown_rs::options::PreprocessingOptionsUpdate {
-    fn from(val: PreprocessingOptionsUpdate) -> Self {
+impl From<html_to_markdown_rs::options::PreprocessingOptionsUpdate> for PreprocessingOptionsUpdate {
+    fn from(val: html_to_markdown_rs::options::PreprocessingOptionsUpdate) -> Self {
         Self {
             enabled: val.enabled,
             preset: val.preset.map(Into::into),
@@ -5415,13 +6079,21 @@ impl From<PreprocessingOptionsUpdate> for html_to_markdown_rs::options::Preproce
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<html_to_markdown_rs::options::PreprocessingOptionsUpdate> for PreprocessingOptionsUpdate {
-    fn from(val: html_to_markdown_rs::options::PreprocessingOptionsUpdate) -> Self {
+impl From<ImageDimensions> for html_to_markdown_rs::ImageDimensions {
+    fn from(val: ImageDimensions) -> Self {
         Self {
-            enabled: val.enabled,
-            preset: val.preset.map(Into::into),
-            remove_navigation: val.remove_navigation,
-            remove_forms: val.remove_forms,
+            width: val.width,
+            height: val.height,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<html_to_markdown_rs::ImageDimensions> for ImageDimensions {
+    fn from(val: html_to_markdown_rs::ImageDimensions) -> Self {
+        Self {
+            width: val.width,
+            height: val.height,
         }
     }
 }
@@ -5441,7 +6113,7 @@ impl From<html_to_markdown_rs::DocumentStructure> for DocumentStructure {
     fn from(val: html_to_markdown_rs::DocumentStructure) -> Self {
         Self {
             nodes: val.nodes.into_iter().map(Into::into).collect(),
-            source_format: val.source_format,
+            source_format: val.source_format.map(|v| v.to_string()),
         }
     }
 }
@@ -5453,7 +6125,7 @@ impl From<DocumentNode> for html_to_markdown_rs::DocumentNode {
             id: val.id,
             content: val.content.into(),
             parent: val.parent,
-            children: val.children,
+            children: val.children.into_iter().collect(),
             annotations: val.annotations.into_iter().map(Into::into).collect(),
             attributes: val
                 .attributes
@@ -5466,10 +6138,10 @@ impl From<DocumentNode> for html_to_markdown_rs::DocumentNode {
 impl From<html_to_markdown_rs::DocumentNode> for DocumentNode {
     fn from(val: html_to_markdown_rs::DocumentNode) -> Self {
         Self {
-            id: val.id,
+            id: val.id.to_string(),
             content: val.content.into(),
             parent: val.parent,
-            children: val.children,
+            children: val.children.into_iter().collect(),
             annotations: val.annotations.into_iter().map(Into::into).collect(),
             attributes: val
                 .attributes
@@ -5500,6 +6172,26 @@ impl From<html_to_markdown_rs::TextAnnotation> for TextAnnotation {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<MetadataEntry> for html_to_markdown_rs::MetadataEntry {
+    fn from(val: MetadataEntry) -> Self {
+        Self {
+            key: val.key,
+            value: val.value,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<html_to_markdown_rs::MetadataEntry> for MetadataEntry {
+    fn from(val: html_to_markdown_rs::MetadataEntry) -> Self {
+        Self {
+            key: val.key.to_string(),
+            value: val.value.to_string(),
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
@@ -5509,7 +6201,6 @@ impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
             document: val.document.map(Into::into),
             metadata: val.metadata.into(),
             tables: val.tables.into_iter().map(Into::into).collect(),
-            images: Default::default(),
             warnings: val.warnings.into_iter().map(Into::into).collect(),
             ..Default::default()
         }
@@ -5520,11 +6211,10 @@ impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
 impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
     fn from(val: html_to_markdown_rs::ConversionResult) -> Self {
         Self {
-            content: val.content,
+            content: val.content.map(|v| v.to_string()),
             document: val.document.map(Into::into),
             metadata: val.metadata.into(),
             tables: val.tables.into_iter().map(Into::into).collect(),
-            images: val.images.iter().map(|i| format!("{:?}", i)).collect(),
             warnings: val.warnings.into_iter().map(Into::into).collect(),
         }
     }
@@ -5570,7 +6260,7 @@ impl From<GridCell> for html_to_markdown_rs::GridCell {
 impl From<html_to_markdown_rs::GridCell> for GridCell {
     fn from(val: html_to_markdown_rs::GridCell) -> Self {
         Self {
-            content: val.content,
+            content: val.content.to_string(),
             row: val.row,
             col: val.col,
             row_span: val.row_span,
@@ -5595,7 +6285,7 @@ impl From<html_to_markdown_rs::TableData> for TableData {
     fn from(val: html_to_markdown_rs::TableData) -> Self {
         Self {
             grid: val.grid.into(),
-            markdown: val.markdown,
+            markdown: val.markdown.to_string(),
         }
     }
 }
@@ -5614,22 +6304,36 @@ impl From<ProcessingWarning> for html_to_markdown_rs::ProcessingWarning {
 impl From<html_to_markdown_rs::ProcessingWarning> for ProcessingWarning {
     fn from(val: html_to_markdown_rs::ProcessingWarning) -> Self {
         Self {
-            message: val.message,
+            message: val.message.to_string(),
             kind: val.kind.into(),
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<html_to_markdown_rs::NodeContext> for NodeContext {
-    fn from(val: html_to_markdown_rs::NodeContext) -> Self {
+impl From<NodeContext> for html_to_markdown_rs::NodeContext<'_> {
+    fn from(val: NodeContext) -> Self {
+        html_to_markdown_rs::NodeContext::with_owned_attributes(
+            val.node_type.into(),
+            val.tag_name.into(),
+            std::collections::BTreeMap::new(),
+            val.depth,
+            val.index_in_parent,
+            val.parent_tag.map(Into::into),
+            val.is_inline,
+        )
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<html_to_markdown_rs::NodeContext<'_>> for NodeContext {
+    fn from(val: html_to_markdown_rs::NodeContext<'_>) -> Self {
         Self {
             node_type: val.node_type.into(),
-            tag_name: val.tag_name,
-            attributes: val.attributes.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
+            tag_name: val.tag_name.to_string(),
             depth: val.depth,
             index_in_parent: val.index_in_parent,
-            parent_tag: val.parent_tag,
+            parent_tag: val.parent_tag.as_ref().map(|v| v.to_string()),
             is_inline: val.is_inline,
         }
     }
@@ -5723,6 +6427,26 @@ impl From<html_to_markdown_rs::metadata::StructuredDataType> for StructuredDataT
     }
 }
 
+impl From<TierStrategy> for html_to_markdown_rs::options::TierStrategy {
+    fn from(val: TierStrategy) -> Self {
+        match val {
+            TierStrategy::Auto => Self::Auto,
+            TierStrategy::Tier2 => Self::Tier2,
+            TierStrategy::Tier1 => Self::Tier1,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::TierStrategy> for TierStrategy {
+    fn from(val: html_to_markdown_rs::options::TierStrategy) -> Self {
+        match val {
+            html_to_markdown_rs::options::TierStrategy::Auto => Self::Auto,
+            html_to_markdown_rs::options::TierStrategy::Tier2 => Self::Tier2,
+            html_to_markdown_rs::options::TierStrategy::Tier1 => Self::Tier1,
+        }
+    }
+}
+
 impl From<PreprocessingPreset> for html_to_markdown_rs::options::PreprocessingPreset {
     fn from(val: PreprocessingPreset) -> Self {
         match val {
@@ -5877,6 +6601,24 @@ impl From<html_to_markdown_rs::options::LinkStyle> for LinkStyle {
     }
 }
 
+impl From<UrlEscapeStyle> for html_to_markdown_rs::options::UrlEscapeStyle {
+    fn from(val: UrlEscapeStyle) -> Self {
+        match val {
+            UrlEscapeStyle::Angle => Self::Angle,
+            UrlEscapeStyle::Percent => Self::Percent,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::UrlEscapeStyle> for UrlEscapeStyle {
+    fn from(val: html_to_markdown_rs::options::UrlEscapeStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::UrlEscapeStyle::Angle => Self::Angle,
+            html_to_markdown_rs::options::UrlEscapeStyle::Percent => Self::Percent,
+        }
+    }
+}
+
 impl From<OutputFormat> for html_to_markdown_rs::options::OutputFormat {
     fn from(val: OutputFormat) -> Self {
         match val {
@@ -5920,7 +6662,7 @@ impl From<NodeContent> for html_to_markdown_rs::NodeContent {
             NodeContent::DefinitionItem { term, definition } => Self::DefinitionItem { term, definition },
             NodeContent::RawBlock { format, content } => Self::RawBlock { format, content },
             NodeContent::MetadataBlock { entries } => Self::MetadataBlock {
-                entries: entries.iter().filter_map(|s| serde_json::from_str(s).ok()).collect(),
+                entries: entries.into_iter().map(Into::into).collect(),
             },
             NodeContent::Group {
                 label,
@@ -5938,38 +6680,48 @@ impl From<NodeContent> for html_to_markdown_rs::NodeContent {
 impl From<html_to_markdown_rs::NodeContent> for NodeContent {
     fn from(val: html_to_markdown_rs::NodeContent) -> Self {
         match val {
-            html_to_markdown_rs::NodeContent::Heading { level, text } => Self::Heading { level, text },
-            html_to_markdown_rs::NodeContent::Paragraph { text } => Self::Paragraph { text },
+            html_to_markdown_rs::NodeContent::Heading { level, text } => Self::Heading {
+                level,
+                text: text.to_string(),
+            },
+            html_to_markdown_rs::NodeContent::Paragraph { text } => Self::Paragraph { text: text.to_string() },
             html_to_markdown_rs::NodeContent::List { ordered } => Self::List { ordered },
-            html_to_markdown_rs::NodeContent::ListItem { text } => Self::ListItem { text },
+            html_to_markdown_rs::NodeContent::ListItem { text } => Self::ListItem { text: text.to_string() },
             html_to_markdown_rs::NodeContent::Table { grid } => Self::Table { grid: grid.into() },
             html_to_markdown_rs::NodeContent::Image {
                 description,
                 src,
                 image_index,
             } => Self::Image {
-                description,
-                src,
+                description: description.map(|v| v.to_string()),
+                src: src.map(|v| v.to_string()),
                 image_index,
             },
-            html_to_markdown_rs::NodeContent::Code { text, language } => Self::Code { text, language },
+            html_to_markdown_rs::NodeContent::Code { text, language } => Self::Code {
+                text: text.to_string(),
+                language: language.map(|v| v.to_string()),
+            },
             html_to_markdown_rs::NodeContent::Quote => Self::Quote,
             html_to_markdown_rs::NodeContent::DefinitionList => Self::DefinitionList,
-            html_to_markdown_rs::NodeContent::DefinitionItem { term, definition } => {
-                Self::DefinitionItem { term, definition }
-            }
-            html_to_markdown_rs::NodeContent::RawBlock { format, content } => Self::RawBlock { format, content },
+            html_to_markdown_rs::NodeContent::DefinitionItem { term, definition } => Self::DefinitionItem {
+                term: term.to_string(),
+                definition: definition.to_string(),
+            },
+            html_to_markdown_rs::NodeContent::RawBlock { format, content } => Self::RawBlock {
+                format: format.to_string(),
+                content: content.to_string(),
+            },
             html_to_markdown_rs::NodeContent::MetadataBlock { entries } => Self::MetadataBlock {
-                entries: entries.iter().map(|i| format!("{:?}", i)).collect(),
+                entries: entries.into_iter().map(Into::into).collect(),
             },
             html_to_markdown_rs::NodeContent::Group {
                 label,
                 heading_level,
                 heading_text,
             } => Self::Group {
-                label,
+                label: label.map(|v| v.to_string()),
                 heading_level,
-                heading_text,
+                heading_text: heading_text.map(|v| v.to_string()),
             },
         }
     }
@@ -6002,7 +6754,10 @@ impl From<html_to_markdown_rs::AnnotationKind> for AnnotationKind {
             html_to_markdown_rs::AnnotationKind::Subscript => Self::Subscript,
             html_to_markdown_rs::AnnotationKind::Superscript => Self::Superscript,
             html_to_markdown_rs::AnnotationKind::Highlight => Self::Highlight,
-            html_to_markdown_rs::AnnotationKind::Link { url, title } => Self::Link { url, title },
+            html_to_markdown_rs::AnnotationKind::Link { url, title } => Self::Link {
+                url: url.to_string(),
+                title: title.map(|v| v.to_string()),
+            },
         }
     }
 }
@@ -6033,6 +6788,101 @@ impl From<html_to_markdown_rs::WarningKind> for WarningKind {
     }
 }
 
+impl From<NodeType> for html_to_markdown_rs::NodeType {
+    fn from(val: NodeType) -> Self {
+        match val {
+            NodeType::Text => Self::Text,
+            NodeType::Element => Self::Element,
+            NodeType::Heading => Self::Heading,
+            NodeType::Paragraph => Self::Paragraph,
+            NodeType::Div => Self::Div,
+            NodeType::Blockquote => Self::Blockquote,
+            NodeType::Pre => Self::Pre,
+            NodeType::Hr => Self::Hr,
+            NodeType::List => Self::List,
+            NodeType::ListItem => Self::ListItem,
+            NodeType::DefinitionList => Self::DefinitionList,
+            NodeType::DefinitionTerm => Self::DefinitionTerm,
+            NodeType::DefinitionDescription => Self::DefinitionDescription,
+            NodeType::Table => Self::Table,
+            NodeType::TableRow => Self::TableRow,
+            NodeType::TableCell => Self::TableCell,
+            NodeType::TableHeader => Self::TableHeader,
+            NodeType::TableBody => Self::TableBody,
+            NodeType::TableHead => Self::TableHead,
+            NodeType::TableFoot => Self::TableFoot,
+            NodeType::Link => Self::Link,
+            NodeType::Image => Self::Image,
+            NodeType::Strong => Self::Strong,
+            NodeType::Em => Self::Em,
+            NodeType::Code => Self::Code,
+            NodeType::Strikethrough => Self::Strikethrough,
+            NodeType::Underline => Self::Underline,
+            NodeType::Subscript => Self::Subscript,
+            NodeType::Superscript => Self::Superscript,
+            NodeType::Mark => Self::Mark,
+            NodeType::Small => Self::Small,
+            NodeType::Br => Self::Br,
+            NodeType::Span => Self::Span,
+            NodeType::Article => Self::Article,
+            NodeType::Section => Self::Section,
+            NodeType::Nav => Self::Nav,
+            NodeType::Aside => Self::Aside,
+            NodeType::Header => Self::Header,
+            NodeType::Footer => Self::Footer,
+            NodeType::Main => Self::Main,
+            NodeType::Figure => Self::Figure,
+            NodeType::Figcaption => Self::Figcaption,
+            NodeType::Time => Self::Time,
+            NodeType::Details => Self::Details,
+            NodeType::Summary => Self::Summary,
+            NodeType::Form => Self::Form,
+            NodeType::Input => Self::Input,
+            NodeType::Select => Self::Select,
+            NodeType::Option => Self::Option,
+            NodeType::Button => Self::Button,
+            NodeType::Textarea => Self::Textarea,
+            NodeType::Label => Self::Label,
+            NodeType::Fieldset => Self::Fieldset,
+            NodeType::Legend => Self::Legend,
+            NodeType::Audio => Self::Audio,
+            NodeType::Video => Self::Video,
+            NodeType::Picture => Self::Picture,
+            NodeType::Source => Self::Source,
+            NodeType::Iframe => Self::Iframe,
+            NodeType::Svg => Self::Svg,
+            NodeType::Canvas => Self::Canvas,
+            NodeType::Ruby => Self::Ruby,
+            NodeType::Rt => Self::Rt,
+            NodeType::Rp => Self::Rp,
+            NodeType::Abbr => Self::Abbr,
+            NodeType::Kbd => Self::Kbd,
+            NodeType::Samp => Self::Samp,
+            NodeType::Var => Self::Var,
+            NodeType::Cite => Self::Cite,
+            NodeType::Q => Self::Q,
+            NodeType::Del => Self::Del,
+            NodeType::Ins => Self::Ins,
+            NodeType::Data => Self::Data,
+            NodeType::Meter => Self::Meter,
+            NodeType::Progress => Self::Progress,
+            NodeType::Output => Self::Output,
+            NodeType::Template => Self::Template,
+            NodeType::Slot => Self::Slot,
+            NodeType::Html => Self::Html,
+            NodeType::Head => Self::Head,
+            NodeType::Body => Self::Body,
+            NodeType::Title => Self::Title,
+            NodeType::Meta => Self::Meta,
+            NodeType::LinkTag => Self::LinkTag,
+            NodeType::Style => Self::Style,
+            NodeType::Script => Self::Script,
+            NodeType::Base => Self::Base,
+            NodeType::Custom => Self::Custom,
+        }
+    }
+}
+
 impl From<html_to_markdown_rs::NodeType> for NodeType {
     fn from(val: html_to_markdown_rs::NodeType) -> Self {
         match val {
@@ -6132,10 +6982,10 @@ impl From<html_to_markdown_rs::VisitResult> for VisitResult {
     fn from(val: html_to_markdown_rs::VisitResult) -> Self {
         match val {
             html_to_markdown_rs::VisitResult::Continue => Self::Continue,
-            html_to_markdown_rs::VisitResult::Custom(_0) => Self::Custom { _0 },
+            html_to_markdown_rs::VisitResult::Custom(_0) => Self::Custom { _0: _0.to_string() },
             html_to_markdown_rs::VisitResult::Skip => Self::Skip,
             html_to_markdown_rs::VisitResult::PreserveHtml => Self::PreserveHtml,
-            html_to_markdown_rs::VisitResult::Error(_0) => Self::Error { _0 },
+            html_to_markdown_rs::VisitResult::Error(_0) => Self::Error { _0: _0.to_string() },
         }
     }
 }
@@ -6151,272 +7001,491 @@ fn conversion_error_to_magnus_err(e: html_to_markdown_rs::error::ConversionError
 fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("HtmlToMarkdownRs")?;
 
+    // Ensure JSON library is loaded for Hash#to_json
+    let _ = ruby.eval::<magnus::Value>("require \"json\"");
+
     let class = module.define_class("DocumentMetadata", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocumentMetadata::new, -1))?;
+
     class.define_method("title", method!(DocumentMetadata::title, 0))?;
+
     class.define_method("description", method!(DocumentMetadata::description, 0))?;
+
     class.define_method("keywords", method!(DocumentMetadata::keywords, 0))?;
+
     class.define_method("author", method!(DocumentMetadata::author, 0))?;
+
     class.define_method("canonical_url", method!(DocumentMetadata::canonical_url, 0))?;
+
     class.define_method("base_href", method!(DocumentMetadata::base_href, 0))?;
+
     class.define_method("language", method!(DocumentMetadata::language, 0))?;
+
     class.define_method("text_direction", method!(DocumentMetadata::text_direction, 0))?;
+
     class.define_method("open_graph", method!(DocumentMetadata::open_graph, 0))?;
+
     class.define_method("twitter_card", method!(DocumentMetadata::twitter_card, 0))?;
+
     class.define_method("meta_tags", method!(DocumentMetadata::meta_tags, 0))?;
 
     let class = module.define_class("HeaderMetadata", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(HeaderMetadata::new, -1))?;
+
     class.define_method("level", method!(HeaderMetadata::level, 0))?;
+
     class.define_method("text", method!(HeaderMetadata::text, 0))?;
+
     class.define_method("id", method!(HeaderMetadata::id, 0))?;
+
     class.define_method("depth", method!(HeaderMetadata::depth, 0))?;
+
     class.define_method("html_offset", method!(HeaderMetadata::html_offset, 0))?;
+
     class.define_method("is_valid", method!(HeaderMetadata::is_valid, 0))?;
 
     let class = module.define_class("LinkMetadata", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(LinkMetadata::new, -1))?;
+
     class.define_method("href", method!(LinkMetadata::href, 0))?;
+
     class.define_method("text", method!(LinkMetadata::text, 0))?;
+
     class.define_method("title", method!(LinkMetadata::title, 0))?;
+
     class.define_method("link_type", method!(LinkMetadata::link_type, 0))?;
+
     class.define_method("rel", method!(LinkMetadata::rel, 0))?;
+
     class.define_method("attributes", method!(LinkMetadata::attributes, 0))?;
 
     let class = module.define_class("ImageMetadata", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ImageMetadata::new, -1))?;
+
     class.define_method("src", method!(ImageMetadata::src, 0))?;
+
     class.define_method("alt", method!(ImageMetadata::alt, 0))?;
+
     class.define_method("title", method!(ImageMetadata::title, 0))?;
+
     class.define_method("dimensions", method!(ImageMetadata::dimensions, 0))?;
+
     class.define_method("image_type", method!(ImageMetadata::image_type, 0))?;
+
     class.define_method("attributes", method!(ImageMetadata::attributes, 0))?;
 
     let class = module.define_class("StructuredData", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(StructuredData::new, -1))?;
+
     class.define_method("data_type", method!(StructuredData::data_type, 0))?;
+
     class.define_method("raw_json", method!(StructuredData::raw_json, 0))?;
+
     class.define_method("schema_type", method!(StructuredData::schema_type, 0))?;
 
     let class = module.define_class("HtmlMetadata", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(HtmlMetadata::new, -1))?;
+
     class.define_method("document", method!(HtmlMetadata::document, 0))?;
+
     class.define_method("headers", method!(HtmlMetadata::headers, 0))?;
+
     class.define_method("links", method!(HtmlMetadata::links, 0))?;
+
     class.define_method("images", method!(HtmlMetadata::images, 0))?;
+
     class.define_method("structured_data", method!(HtmlMetadata::structured_data, 0))?;
 
     let class = module.define_class("ConversionOptions", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ConversionOptions::new, -1))?;
+
     class.define_method("heading_style", method!(ConversionOptions::heading_style, 0))?;
+
     class.define_method("list_indent_type", method!(ConversionOptions::list_indent_type, 0))?;
+
     class.define_method("list_indent_width", method!(ConversionOptions::list_indent_width, 0))?;
+
     class.define_method("bullets", method!(ConversionOptions::bullets, 0))?;
+
     class.define_method("strong_em_symbol", method!(ConversionOptions::strong_em_symbol, 0))?;
+
     class.define_method("escape_asterisks", method!(ConversionOptions::escape_asterisks, 0))?;
+
     class.define_method("escape_underscores", method!(ConversionOptions::escape_underscores, 0))?;
+
     class.define_method("escape_misc", method!(ConversionOptions::escape_misc, 0))?;
+
     class.define_method("escape_ascii", method!(ConversionOptions::escape_ascii, 0))?;
+
     class.define_method("code_language", method!(ConversionOptions::code_language, 0))?;
+
     class.define_method("autolinks", method!(ConversionOptions::autolinks, 0))?;
+
     class.define_method("default_title", method!(ConversionOptions::default_title, 0))?;
+
     class.define_method("br_in_tables", method!(ConversionOptions::br_in_tables, 0))?;
+
+    class.define_method("compact_tables", method!(ConversionOptions::compact_tables, 0))?;
+
     class.define_method("highlight_style", method!(ConversionOptions::highlight_style, 0))?;
+
     class.define_method("extract_metadata", method!(ConversionOptions::extract_metadata, 0))?;
+
     class.define_method("whitespace_mode", method!(ConversionOptions::whitespace_mode, 0))?;
+
     class.define_method("strip_newlines", method!(ConversionOptions::strip_newlines, 0))?;
+
     class.define_method("wrap", method!(ConversionOptions::wrap, 0))?;
+
     class.define_method("wrap_width", method!(ConversionOptions::wrap_width, 0))?;
+
     class.define_method("convert_as_inline", method!(ConversionOptions::convert_as_inline, 0))?;
+
     class.define_method("sub_symbol", method!(ConversionOptions::sub_symbol, 0))?;
+
     class.define_method("sup_symbol", method!(ConversionOptions::sup_symbol, 0))?;
+
     class.define_method("newline_style", method!(ConversionOptions::newline_style, 0))?;
+
     class.define_method("code_block_style", method!(ConversionOptions::code_block_style, 0))?;
+
     class.define_method(
         "keep_inline_images_in",
         method!(ConversionOptions::keep_inline_images_in, 0),
     )?;
+
     class.define_method("preprocessing", method!(ConversionOptions::preprocessing, 0))?;
+
     class.define_method("encoding", method!(ConversionOptions::encoding, 0))?;
+
     class.define_method("debug", method!(ConversionOptions::debug, 0))?;
+
     class.define_method("strip_tags", method!(ConversionOptions::strip_tags, 0))?;
+
     class.define_method("preserve_tags", method!(ConversionOptions::preserve_tags, 0))?;
+
     class.define_method("skip_images", method!(ConversionOptions::skip_images, 0))?;
+
+    class.define_method("url_escape_style", method!(ConversionOptions::url_escape_style, 0))?;
+
     class.define_method("link_style", method!(ConversionOptions::link_style, 0))?;
+
     class.define_method("output_format", method!(ConversionOptions::output_format, 0))?;
+
     class.define_method(
         "include_document_structure",
         method!(ConversionOptions::include_document_structure, 0),
     )?;
+
     class.define_method("extract_images", method!(ConversionOptions::extract_images, 0))?;
+
     class.define_method("max_image_size", method!(ConversionOptions::max_image_size, 0))?;
+
     class.define_method("capture_svg", method!(ConversionOptions::capture_svg, 0))?;
+
     class.define_method("infer_dimensions", method!(ConversionOptions::infer_dimensions, 0))?;
+
     class.define_method("max_depth", method!(ConversionOptions::max_depth, 0))?;
+
     class.define_method("exclude_selectors", method!(ConversionOptions::exclude_selectors, 0))?;
 
+    class.define_method("tier_strategy", method!(ConversionOptions::tier_strategy, 0))?;
+
     let class = module.define_class("ConversionOptionsUpdate", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ConversionOptionsUpdate::new, -1))?;
+
     class.define_method("heading_style", method!(ConversionOptionsUpdate::heading_style, 0))?;
+
     class.define_method(
         "list_indent_type",
         method!(ConversionOptionsUpdate::list_indent_type, 0),
     )?;
+
     class.define_method(
         "list_indent_width",
         method!(ConversionOptionsUpdate::list_indent_width, 0),
     )?;
+
     class.define_method("bullets", method!(ConversionOptionsUpdate::bullets, 0))?;
+
     class.define_method(
         "strong_em_symbol",
         method!(ConversionOptionsUpdate::strong_em_symbol, 0),
     )?;
+
     class.define_method(
         "escape_asterisks",
         method!(ConversionOptionsUpdate::escape_asterisks, 0),
     )?;
+
     class.define_method(
         "escape_underscores",
         method!(ConversionOptionsUpdate::escape_underscores, 0),
     )?;
+
     class.define_method("escape_misc", method!(ConversionOptionsUpdate::escape_misc, 0))?;
+
     class.define_method("escape_ascii", method!(ConversionOptionsUpdate::escape_ascii, 0))?;
+
     class.define_method("code_language", method!(ConversionOptionsUpdate::code_language, 0))?;
+
     class.define_method("autolinks", method!(ConversionOptionsUpdate::autolinks, 0))?;
+
     class.define_method("default_title", method!(ConversionOptionsUpdate::default_title, 0))?;
+
     class.define_method("br_in_tables", method!(ConversionOptionsUpdate::br_in_tables, 0))?;
+
+    class.define_method("compact_tables", method!(ConversionOptionsUpdate::compact_tables, 0))?;
+
     class.define_method("highlight_style", method!(ConversionOptionsUpdate::highlight_style, 0))?;
+
     class.define_method(
         "extract_metadata",
         method!(ConversionOptionsUpdate::extract_metadata, 0),
     )?;
+
     class.define_method("whitespace_mode", method!(ConversionOptionsUpdate::whitespace_mode, 0))?;
+
     class.define_method("strip_newlines", method!(ConversionOptionsUpdate::strip_newlines, 0))?;
+
     class.define_method("wrap", method!(ConversionOptionsUpdate::wrap, 0))?;
+
     class.define_method("wrap_width", method!(ConversionOptionsUpdate::wrap_width, 0))?;
+
     class.define_method(
         "convert_as_inline",
         method!(ConversionOptionsUpdate::convert_as_inline, 0),
     )?;
+
     class.define_method("sub_symbol", method!(ConversionOptionsUpdate::sub_symbol, 0))?;
+
     class.define_method("sup_symbol", method!(ConversionOptionsUpdate::sup_symbol, 0))?;
+
     class.define_method("newline_style", method!(ConversionOptionsUpdate::newline_style, 0))?;
+
     class.define_method(
         "code_block_style",
         method!(ConversionOptionsUpdate::code_block_style, 0),
     )?;
+
     class.define_method(
         "keep_inline_images_in",
         method!(ConversionOptionsUpdate::keep_inline_images_in, 0),
     )?;
+
     class.define_method("preprocessing", method!(ConversionOptionsUpdate::preprocessing, 0))?;
+
     class.define_method("encoding", method!(ConversionOptionsUpdate::encoding, 0))?;
+
     class.define_method("debug", method!(ConversionOptionsUpdate::debug, 0))?;
+
     class.define_method("strip_tags", method!(ConversionOptionsUpdate::strip_tags, 0))?;
+
     class.define_method("preserve_tags", method!(ConversionOptionsUpdate::preserve_tags, 0))?;
+
     class.define_method("skip_images", method!(ConversionOptionsUpdate::skip_images, 0))?;
+
+    class.define_method(
+        "url_escape_style",
+        method!(ConversionOptionsUpdate::url_escape_style, 0),
+    )?;
+
     class.define_method("link_style", method!(ConversionOptionsUpdate::link_style, 0))?;
+
     class.define_method("output_format", method!(ConversionOptionsUpdate::output_format, 0))?;
+
     class.define_method(
         "include_document_structure",
         method!(ConversionOptionsUpdate::include_document_structure, 0),
     )?;
+
     class.define_method("extract_images", method!(ConversionOptionsUpdate::extract_images, 0))?;
+
     class.define_method("max_image_size", method!(ConversionOptionsUpdate::max_image_size, 0))?;
+
     class.define_method("capture_svg", method!(ConversionOptionsUpdate::capture_svg, 0))?;
+
     class.define_method(
         "infer_dimensions",
         method!(ConversionOptionsUpdate::infer_dimensions, 0),
     )?;
+
     class.define_method("max_depth", method!(ConversionOptionsUpdate::max_depth, 0))?;
+
     class.define_method(
         "exclude_selectors",
         method!(ConversionOptionsUpdate::exclude_selectors, 0),
     )?;
 
+    class.define_method("tier_strategy", method!(ConversionOptionsUpdate::tier_strategy, 0))?;
+
     let class = module.define_class("PreprocessingOptions", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(PreprocessingOptions::new, -1))?;
+
     class.define_method("enabled", method!(PreprocessingOptions::enabled, 0))?;
+
     class.define_method("preset", method!(PreprocessingOptions::preset, 0))?;
+
     class.define_method("remove_navigation", method!(PreprocessingOptions::remove_navigation, 0))?;
+
     class.define_method("remove_forms", method!(PreprocessingOptions::remove_forms, 0))?;
 
     let class = module.define_class("PreprocessingOptionsUpdate", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(PreprocessingOptionsUpdate::new, -1))?;
+
     class.define_method("enabled", method!(PreprocessingOptionsUpdate::enabled, 0))?;
+
     class.define_method("preset", method!(PreprocessingOptionsUpdate::preset, 0))?;
+
     class.define_method(
         "remove_navigation",
         method!(PreprocessingOptionsUpdate::remove_navigation, 0),
     )?;
+
     class.define_method("remove_forms", method!(PreprocessingOptionsUpdate::remove_forms, 0))?;
 
+    let class = module.define_class("ImageDimensions", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ImageDimensions::new, -1))?;
+
+    class.define_method("width", method!(ImageDimensions::width, 0))?;
+
+    class.define_method("height", method!(ImageDimensions::height, 0))?;
+
     let class = module.define_class("DocumentStructure", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocumentStructure::new, -1))?;
+
     class.define_method("nodes", method!(DocumentStructure::nodes, 0))?;
+
     class.define_method("source_format", method!(DocumentStructure::source_format, 0))?;
 
     let class = module.define_class("DocumentNode", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocumentNode::new, -1))?;
+
     class.define_method("id", method!(DocumentNode::id, 0))?;
+
     class.define_method("content", method!(DocumentNode::content, 0))?;
+
     class.define_method("parent", method!(DocumentNode::parent, 0))?;
+
     class.define_method("children", method!(DocumentNode::children, 0))?;
+
     class.define_method("annotations", method!(DocumentNode::annotations, 0))?;
+
     class.define_method("attributes", method!(DocumentNode::attributes, 0))?;
 
     let class = module.define_class("TextAnnotation", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(TextAnnotation::new, -1))?;
+
     class.define_method("start", method!(TextAnnotation::start, 0))?;
+
     class.define_method("end", method!(TextAnnotation::end, 0))?;
+
     class.define_method("kind", method!(TextAnnotation::kind, 0))?;
 
+    let class = module.define_class("MetadataEntry", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(MetadataEntry::new, -1))?;
+
+    class.define_method("key", method!(MetadataEntry::key, 0))?;
+
+    class.define_method("value", method!(MetadataEntry::value, 0))?;
+
     let class = module.define_class("ConversionResult", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ConversionResult::new, -1))?;
+
     class.define_method("content", method!(ConversionResult::content, 0))?;
+
     class.define_method("document", method!(ConversionResult::document, 0))?;
+
     class.define_method("metadata", method!(ConversionResult::metadata, 0))?;
+
     class.define_method("tables", method!(ConversionResult::tables, 0))?;
-    class.define_method("images", method!(ConversionResult::images, 0))?;
+
     class.define_method("warnings", method!(ConversionResult::warnings, 0))?;
+
     class.define_method("to_s", method!(ConversionResult::to_s, 0))?;
 
     let class = module.define_class("TableGrid", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(TableGrid::new, -1))?;
+
     class.define_method("rows", method!(TableGrid::rows, 0))?;
+
     class.define_method("cols", method!(TableGrid::cols, 0))?;
+
     class.define_method("cells", method!(TableGrid::cells, 0))?;
 
     let class = module.define_class("GridCell", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(GridCell::new, -1))?;
+
     class.define_method("content", method!(GridCell::content, 0))?;
+
     class.define_method("row", method!(GridCell::row, 0))?;
+
     class.define_method("col", method!(GridCell::col, 0))?;
+
     class.define_method("row_span", method!(GridCell::row_span, 0))?;
+
     class.define_method("col_span", method!(GridCell::col_span, 0))?;
+
     class.define_method("is_header", method!(GridCell::is_header, 0))?;
+
     class.define_method("to_s", method!(GridCell::to_s, 0))?;
 
     let class = module.define_class("TableData", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(TableData::new, -1))?;
+
     class.define_method("grid", method!(TableData::grid, 0))?;
+
     class.define_method("markdown", method!(TableData::markdown, 0))?;
 
     let class = module.define_class("ProcessingWarning", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ProcessingWarning::new, -1))?;
+
     class.define_method("message", method!(ProcessingWarning::message, 0))?;
+
     class.define_method("kind", method!(ProcessingWarning::kind, 0))?;
 
+    let class = module.define_class("VisitorHandle", ruby.class_object())?;
+
     let class = module.define_class("NodeContext", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(NodeContext::new, -1))?;
+
     class.define_method("node_type", method!(NodeContext::node_type, 0))?;
+
     class.define_method("tag_name", method!(NodeContext::tag_name, 0))?;
-    class.define_method("attributes", method!(NodeContext::attributes, 0))?;
+
     class.define_method("depth", method!(NodeContext::depth, 0))?;
+
     class.define_method("index_in_parent", method!(NodeContext::index_in_parent, 0))?;
+
     class.define_method("parent_tag", method!(NodeContext::parent_tag, 0))?;
+
     class.define_method("is_inline", method!(NodeContext::is_inline, 0))?;
 
+    class.define_method("attributes", method!(NodeContext::attributes, 0))?;
+
+    class.define_method("into_owned", method!(NodeContext::into_owned, 0))?;
+
     module.define_module_function("convert", function!(convert, -1))?;
 
     Ok(())