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

data/ext/html_to_markdown_rb/src/lib.rs

@@ -1,6 +1,20 @@
 // This file is auto-generated by alef. DO NOT EDIT.
+// alef:hash:05410d54dbc3bf180f287036de010a1a0a1160595b540211d172b1cdd9bb6dff
 // Re-generate with: alef generate
-#![allow(dead_code)]
+#![allow(dead_code, unused_imports, unused_variables)]
+#![allow(
+    clippy::too_many_arguments,
+    clippy::let_unit_value,
+    clippy::needless_borrow,
+    clippy::map_identity,
+    clippy::just_underscores_and_digits,
+    clippy::unnecessary_cast,
+    clippy::unused_unit,
+    clippy::unwrap_or_default,
+    clippy::derivable_impls,
+    clippy::needless_borrows_for_generic_args,
+    clippy::unnecessary_fallible_conversions
+)]
 
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
 use std::collections::HashMap;
@@ -40,176 +54,9 @@ fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     }
 }
 
-#[derive(Clone, Debug)]
-#[magnus::wrap(class = "HtmlToMarkdownRs::MetadataConfig")]
-pub struct MetadataConfig {
-    pub extract_document: bool,
-    pub extract_headers: bool,
-    pub extract_links: bool,
-    pub extract_images: bool,
-    pub extract_structured_data: bool,
-    pub max_structured_data_size: usize,
-}
-
-unsafe impl IntoValueFromNative for MetadataConfig {}
-
-impl magnus::TryConvert for MetadataConfig {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &MetadataConfig = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
-    }
-}
-unsafe impl TryConvertOwned for MetadataConfig {}
-
-impl Default for MetadataConfig {
-    fn default() -> Self {
-        Self {
-            extract_document: Default::default(),
-            extract_headers: Default::default(),
-            extract_links: Default::default(),
-            extract_images: Default::default(),
-            extract_structured_data: Default::default(),
-            max_structured_data_size: Default::default(),
-        }
-    }
-}
-
-impl MetadataConfig {
-    fn new(
-        extract_document: Option<bool>,
-        extract_headers: Option<bool>,
-        extract_links: Option<bool>,
-        extract_images: Option<bool>,
-        extract_structured_data: Option<bool>,
-        max_structured_data_size: Option<usize>,
-    ) -> Self {
-        Self {
-            extract_document: extract_document.unwrap_or(true),
-            extract_headers: extract_headers.unwrap_or(true),
-            extract_links: extract_links.unwrap_or(true),
-            extract_images: extract_images.unwrap_or(true),
-            extract_structured_data: extract_structured_data.unwrap_or(true),
-            max_structured_data_size: max_structured_data_size.unwrap_or_default(),
-        }
-    }
-
-    fn extract_document(&self) -> bool {
-        self.extract_document
-    }
-
-    fn extract_headers(&self) -> bool {
-        self.extract_headers
-    }
-
-    fn extract_links(&self) -> bool {
-        self.extract_links
-    }
-
-    fn extract_images(&self) -> bool {
-        self.extract_images
-    }
-
-    fn extract_structured_data(&self) -> bool {
-        self.extract_structured_data
-    }
-
-    fn max_structured_data_size(&self) -> usize {
-        self.max_structured_data_size
-    }
-
-    fn any_enabled(&self) -> bool {
-        let core_self = html_to_markdown_rs::metadata::MetadataConfig {
-            extract_document: self.extract_document,
-            extract_headers: self.extract_headers,
-            extract_links: self.extract_links,
-            extract_images: self.extract_images,
-            extract_structured_data: self.extract_structured_data,
-            max_structured_data_size: self.max_structured_data_size,
-        };
-        core_self.any_enabled()
-    }
-}
-
-#[derive(Clone, Debug)]
-#[magnus::wrap(class = "HtmlToMarkdownRs::MetadataConfigUpdate")]
-pub struct MetadataConfigUpdate {
-    pub extract_document: Option<bool>,
-    pub extract_headers: Option<bool>,
-    pub extract_links: Option<bool>,
-    pub extract_images: Option<bool>,
-    pub extract_structured_data: Option<bool>,
-    pub max_structured_data_size: Option<usize>,
-}
-
-unsafe impl IntoValueFromNative for MetadataConfigUpdate {}
-
-impl magnus::TryConvert for MetadataConfigUpdate {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &MetadataConfigUpdate = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
-    }
-}
-unsafe impl TryConvertOwned for MetadataConfigUpdate {}
-
-impl Default for MetadataConfigUpdate {
-    fn default() -> Self {
-        Self {
-            extract_document: Default::default(),
-            extract_headers: Default::default(),
-            extract_links: Default::default(),
-            extract_images: Default::default(),
-            extract_structured_data: Default::default(),
-            max_structured_data_size: Default::default(),
-        }
-    }
-}
-
-impl MetadataConfigUpdate {
-    fn new(
-        extract_document: Option<bool>,
-        extract_headers: Option<bool>,
-        extract_links: Option<bool>,
-        extract_images: Option<bool>,
-        extract_structured_data: Option<bool>,
-        max_structured_data_size: Option<usize>,
-    ) -> Self {
-        Self {
-            extract_document,
-            extract_headers,
-            extract_links,
-            extract_images,
-            extract_structured_data,
-            max_structured_data_size,
-        }
-    }
-
-    fn extract_document(&self) -> Option<bool> {
-        self.extract_document
-    }
-
-    fn extract_headers(&self) -> Option<bool> {
-        self.extract_headers
-    }
-
-    fn extract_links(&self) -> Option<bool> {
-        self.extract_links
-    }
-
-    fn extract_images(&self) -> Option<bool> {
-        self.extract_images
-    }
-
-    fn extract_structured_data(&self) -> Option<bool> {
-        self.extract_structured_data
-    }
-
-    fn max_structured_data_size(&self) -> Option<usize> {
-        self.max_structured_data_size
-    }
-}
-
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentMetadata")]
+#[serde(default)]
 pub struct DocumentMetadata {
     pub title: Option<String>,
     pub description: Option<String>,
@@ -308,7 +155,7 @@ impl DocumentMetadata {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HeaderMetadata")]
 pub struct HeaderMetadata {
     pub level: u8,
@@ -371,7 +218,7 @@ impl HeaderMetadata {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::LinkMetadata")]
 pub struct LinkMetadata {
     pub href: String,
@@ -436,13 +283,13 @@ impl LinkMetadata {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ImageMetadata")]
 pub struct ImageMetadata {
     pub src: String,
     pub alt: Option<String>,
     pub title: Option<String>,
-    pub dimensions: Option<String>,
+    pub dimensions: Option<Vec<u32>>,
     pub image_type: ImageType,
     pub attributes: HashMap<String, String>,
 }
@@ -464,7 +311,7 @@ impl ImageMetadata {
         attributes: HashMap<String, String>,
         alt: Option<String>,
         title: Option<String>,
-        dimensions: Option<String>,
+        dimensions: Option<Vec<u32>>,
     ) -> Self {
         Self {
             src,
@@ -488,7 +335,7 @@ impl ImageMetadata {
         self.title.clone()
     }
 
-    fn dimensions(&self) -> Option<String> {
+    fn dimensions(&self) -> Option<Vec<u32>> {
         self.dimensions.clone()
     }
 
@@ -501,7 +348,7 @@ impl ImageMetadata {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::StructuredData")]
 pub struct StructuredData {
     pub data_type: StructuredDataType,
@@ -541,8 +388,9 @@ impl StructuredData {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HtmlMetadata")]
+#[serde(default)]
 pub struct HtmlMetadata {
     pub document: DocumentMetadata,
     pub headers: Vec<HeaderMetadata>,
@@ -599,8 +447,9 @@ impl HtmlMetadata {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptions")]
+#[serde(default)]
 pub struct ConversionOptions {
     pub heading_style: HeadingStyle,
     pub list_indent_type: ListIndentType,
@@ -640,6 +489,8 @@ pub struct ConversionOptions {
     pub max_image_size: u64,
     pub capture_svg: bool,
     pub infer_dimensions: bool,
+    pub max_depth: Option<usize>,
+    pub exclude_selectors: Vec<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -808,6 +659,13 @@ impl ConversionOptions {
                 .get(ruby.to_symbol("infer_dimensions"))
                 .and_then(|v| bool::try_convert(v).ok())
                 .unwrap_or(true),
+            max_depth: kwargs
+                .get(ruby.to_symbol("max_depth"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            exclude_selectors: kwargs
+                .get(ruby.to_symbol("exclude_selectors"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
         })
     }
 
@@ -962,6 +820,18 @@ impl ConversionOptions {
     fn infer_dimensions(&self) -> bool {
         self.infer_dimensions
     }
+
+    fn max_depth(&self) -> Option<usize> {
+        self.max_depth
+    }
+
+    fn exclude_selectors(&self) -> Vec<String> {
+        self.exclude_selectors.clone()
+    }
+
+    fn apply_update(&self, update: ConversionOptionsUpdate) -> () {
+        ()
+    }
 }
 
 #[derive(Clone)]
@@ -999,6 +869,12 @@ impl ConversionOptionsBuilder {
         }
     }
 
+    fn exclude_selectors(&self, selectors: Vec<String>) -> ConversionOptionsBuilder {
+        Self {
+            inner: Arc::new(self.inner.as_ref().clone().exclude_selectors(selectors)),
+        }
+    }
+
     fn preprocessing(&self, preprocessing: PreprocessingOptions) -> ConversionOptionsBuilder {
         Self {
             inner: Arc::new(self.inner.as_ref().clone().preprocessing(preprocessing.into())),
@@ -1010,8 +886,9 @@ impl ConversionOptionsBuilder {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptionsUpdate")]
+#[serde(default)]
 pub struct ConversionOptionsUpdate {
     pub heading_style: Option<HeadingStyle>,
     pub list_indent_type: Option<ListIndentType>,
@@ -1051,6 +928,8 @@ pub struct ConversionOptionsUpdate {
     pub max_image_size: Option<u64>,
     pub capture_svg: Option<bool>,
     pub infer_dimensions: Option<bool>,
+    pub max_depth: Option<usize>,
+    pub exclude_selectors: Option<Vec<String>>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptionsUpdate {}
@@ -1181,6 +1060,12 @@ impl ConversionOptionsUpdate {
             infer_dimensions: kwargs
                 .get(ruby.to_symbol("infer_dimensions"))
                 .and_then(|v| bool::try_convert(v).ok()),
+            max_depth: kwargs
+                .get(ruby.to_symbol("max_depth"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            exclude_selectors: kwargs
+                .get(ruby.to_symbol("exclude_selectors"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
         })
     }
 
@@ -1335,10 +1220,19 @@ impl ConversionOptionsUpdate {
     fn infer_dimensions(&self) -> Option<bool> {
         self.infer_dimensions
     }
+
+    fn max_depth(&self) -> Option<usize> {
+        self.max_depth.clone()
+    }
+
+    fn exclude_selectors(&self) -> Option<Vec<String>> {
+        self.exclude_selectors.clone()
+    }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptions")]
+#[serde(default)]
 pub struct PreprocessingOptions {
     pub enabled: bool,
     pub preset: PreprocessingPreset,
@@ -1386,10 +1280,15 @@ impl PreprocessingOptions {
     fn remove_forms(&self) -> bool {
         self.remove_forms
     }
+
+    fn apply_update(&self, update: PreprocessingOptionsUpdate) -> () {
+        ()
+    }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptionsUpdate")]
+#[serde(default)]
 pub struct PreprocessingOptionsUpdate {
     pub enabled: Option<bool>,
     pub preset: Option<PreprocessingPreset>,
@@ -1439,7 +1338,7 @@ impl PreprocessingOptionsUpdate {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentStructure")]
 pub struct DocumentStructure {
     pub nodes: Vec<DocumentNode>,
@@ -1470,7 +1369,7 @@ impl DocumentStructure {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentNode")]
 pub struct DocumentNode {
     pub id: String,
@@ -1535,7 +1434,7 @@ impl DocumentNode {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TextAnnotation")]
 pub struct TextAnnotation {
     pub start: u32,
@@ -1571,8 +1470,9 @@ impl TextAnnotation {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ConversionResult")]
+#[serde(default)]
 pub struct ConversionResult {
     pub content: Option<String>,
     pub document: Option<DocumentStructure>,
@@ -1636,7 +1536,7 @@ impl ConversionResult {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TableGrid")]
 #[serde(default)]
 pub struct TableGrid {
@@ -1677,7 +1577,7 @@ impl TableGrid {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::GridCell")]
 pub struct GridCell {
     pub content: String,
@@ -1735,7 +1635,7 @@ impl GridCell {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::TableData")]
 pub struct TableData {
     pub grid: TableGrid,
@@ -1766,7 +1666,7 @@ impl TableData {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ProcessingWarning")]
 pub struct ProcessingWarning {
     pub message: String,
@@ -1797,6 +1697,78 @@ impl ProcessingWarning {
     }
 }
 
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::NodeContext")]
+pub struct NodeContext {
+    pub node_type: NodeType,
+    pub tag_name: String,
+    pub attributes: HashMap<String, String>,
+    pub depth: usize,
+    pub index_in_parent: usize,
+    pub parent_tag: Option<String>,
+    pub is_inline: bool,
+}
+
+unsafe impl IntoValueFromNative for NodeContext {}
+
+impl magnus::TryConvert for NodeContext {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &NodeContext = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for NodeContext {}
+
+impl NodeContext {
+    fn new(
+        node_type: NodeType,
+        tag_name: String,
+        attributes: HashMap<String, String>,
+        depth: usize,
+        index_in_parent: usize,
+        is_inline: bool,
+        parent_tag: Option<String>,
+    ) -> Self {
+        Self {
+            node_type,
+            tag_name,
+            attributes,
+            depth,
+            index_in_parent,
+            parent_tag,
+            is_inline,
+        }
+    }
+
+    fn node_type(&self) -> NodeType {
+        self.node_type.clone()
+    }
+
+    fn tag_name(&self) -> String {
+        self.tag_name.clone()
+    }
+
+    fn attributes(&self) -> HashMap<String, String> {
+        self.attributes.clone()
+    }
+
+    fn depth(&self) -> usize {
+        self.depth
+    }
+
+    fn index_in_parent(&self) -> usize {
+        self.index_in_parent
+    }
+
+    fn parent_tag(&self) -> Option<String> {
+        self.parent_tag.clone()
+    }
+
+    fn is_inline(&self) -> bool {
+        self.is_inline
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum TextDirection {
     #[serde(rename = "ltr")]
@@ -2390,7 +2362,7 @@ pub enum NodeContent {
         content: String,
     },
     MetadataBlock {
-        entries: String,
+        entries: Vec<String>,
     },
     Group {
         label: Option<String>,
@@ -2475,6 +2447,7 @@ pub enum WarningKind {
     TruncatedInput,
     MalformedHtml,
     SanitizationApplied,
+    DepthLimitExceeded,
 }
 
 impl Default for WarningKind {
@@ -2491,6 +2464,7 @@ impl magnus::IntoValue for WarningKind {
             WarningKind::TruncatedInput => "truncated_input",
             WarningKind::MalformedHtml => "malformed_html",
             WarningKind::SanitizationApplied => "sanitization_applied",
+            WarningKind::DepthLimitExceeded => "depth_limit_exceeded",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2505,6 +2479,7 @@ impl magnus::TryConvert for WarningKind {
             "truncated_input" => Ok(WarningKind::TruncatedInput),
             "malformed_html" => Ok(WarningKind::MalformedHtml),
             "sanitization_applied" => Ok(WarningKind::SanitizationApplied),
+            "depth_limit_exceeded" => Ok(WarningKind::DepthLimitExceeded),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid WarningKind value: {other}"),
@@ -2516,65 +2491,1692 @@ impl magnus::TryConvert for WarningKind {
 unsafe impl IntoValueFromNative for WarningKind {}
 unsafe impl TryConvertOwned for WarningKind {}
 
-fn convert(html: String, options: Option<String>) -> Result<ConversionResult, Error> {
-    let options: Option<ConversionOptions> = options
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum NodeType {
+    Text,
+    Element,
+    Heading,
+    Paragraph,
+    Div,
+    Blockquote,
+    Pre,
+    Hr,
+    List,
+    ListItem,
+    DefinitionList,
+    DefinitionTerm,
+    DefinitionDescription,
+    Table,
+    TableRow,
+    TableCell,
+    TableHeader,
+    TableBody,
+    TableHead,
+    TableFoot,
+    Link,
+    Image,
+    Strong,
+    Em,
+    Code,
+    Strikethrough,
+    Underline,
+    Subscript,
+    Superscript,
+    Mark,
+    Small,
+    Br,
+    Span,
+    Article,
+    Section,
+    Nav,
+    Aside,
+    Header,
+    Footer,
+    Main,
+    Figure,
+    Figcaption,
+    Time,
+    Details,
+    Summary,
+    Form,
+    Input,
+    Select,
+    Option,
+    Button,
+    Textarea,
+    Label,
+    Fieldset,
+    Legend,
+    Audio,
+    Video,
+    Picture,
+    Source,
+    Iframe,
+    Svg,
+    Canvas,
+    Ruby,
+    Rt,
+    Rp,
+    Abbr,
+    Kbd,
+    Samp,
+    Var,
+    Cite,
+    Q,
+    Del,
+    Ins,
+    Data,
+    Meter,
+    Progress,
+    Output,
+    Template,
+    Slot,
+    Html,
+    Head,
+    Body,
+    Title,
+    Meta,
+    LinkTag,
+    Style,
+    Script,
+    Base,
+    Custom,
+}
+
+impl Default for NodeType {
+    fn default() -> Self {
+        Self::Text
+    }
+}
+
+impl magnus::IntoValue for NodeType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            NodeType::Text => "text",
+            NodeType::Element => "element",
+            NodeType::Heading => "heading",
+            NodeType::Paragraph => "paragraph",
+            NodeType::Div => "div",
+            NodeType::Blockquote => "blockquote",
+            NodeType::Pre => "pre",
+            NodeType::Hr => "hr",
+            NodeType::List => "list",
+            NodeType::ListItem => "list_item",
+            NodeType::DefinitionList => "definition_list",
+            NodeType::DefinitionTerm => "definition_term",
+            NodeType::DefinitionDescription => "definition_description",
+            NodeType::Table => "table",
+            NodeType::TableRow => "table_row",
+            NodeType::TableCell => "table_cell",
+            NodeType::TableHeader => "table_header",
+            NodeType::TableBody => "table_body",
+            NodeType::TableHead => "table_head",
+            NodeType::TableFoot => "table_foot",
+            NodeType::Link => "link",
+            NodeType::Image => "image",
+            NodeType::Strong => "strong",
+            NodeType::Em => "em",
+            NodeType::Code => "code",
+            NodeType::Strikethrough => "strikethrough",
+            NodeType::Underline => "underline",
+            NodeType::Subscript => "subscript",
+            NodeType::Superscript => "superscript",
+            NodeType::Mark => "mark",
+            NodeType::Small => "small",
+            NodeType::Br => "br",
+            NodeType::Span => "span",
+            NodeType::Article => "article",
+            NodeType::Section => "section",
+            NodeType::Nav => "nav",
+            NodeType::Aside => "aside",
+            NodeType::Header => "header",
+            NodeType::Footer => "footer",
+            NodeType::Main => "main",
+            NodeType::Figure => "figure",
+            NodeType::Figcaption => "figcaption",
+            NodeType::Time => "time",
+            NodeType::Details => "details",
+            NodeType::Summary => "summary",
+            NodeType::Form => "form",
+            NodeType::Input => "input",
+            NodeType::Select => "select",
+            NodeType::Option => "option",
+            NodeType::Button => "button",
+            NodeType::Textarea => "textarea",
+            NodeType::Label => "label",
+            NodeType::Fieldset => "fieldset",
+            NodeType::Legend => "legend",
+            NodeType::Audio => "audio",
+            NodeType::Video => "video",
+            NodeType::Picture => "picture",
+            NodeType::Source => "source",
+            NodeType::Iframe => "iframe",
+            NodeType::Svg => "svg",
+            NodeType::Canvas => "canvas",
+            NodeType::Ruby => "ruby",
+            NodeType::Rt => "rt",
+            NodeType::Rp => "rp",
+            NodeType::Abbr => "abbr",
+            NodeType::Kbd => "kbd",
+            NodeType::Samp => "samp",
+            NodeType::Var => "var",
+            NodeType::Cite => "cite",
+            NodeType::Q => "q",
+            NodeType::Del => "del",
+            NodeType::Ins => "ins",
+            NodeType::Data => "data",
+            NodeType::Meter => "meter",
+            NodeType::Progress => "progress",
+            NodeType::Output => "output",
+            NodeType::Template => "template",
+            NodeType::Slot => "slot",
+            NodeType::Html => "html",
+            NodeType::Head => "head",
+            NodeType::Body => "body",
+            NodeType::Title => "title",
+            NodeType::Meta => "meta",
+            NodeType::LinkTag => "link_tag",
+            NodeType::Style => "style",
+            NodeType::Script => "script",
+            NodeType::Base => "base",
+            NodeType::Custom => "custom",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for NodeType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        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),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid NodeType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for NodeType {}
+unsafe impl TryConvertOwned for NodeType {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum VisitResult {
+    Continue,
+    Custom { _0: String },
+    Skip,
+    PreserveHtml,
+    Error { _0: String },
+}
+
+impl Default for VisitResult {
+    fn default() -> Self {
+        Self::Continue
+    }
+}
+
+impl magnus::IntoValue for VisitResult {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        match serde_json::to_value(&self) {
+            Ok(v) => json_to_ruby(handle, v),
+            Err(_) => handle.qnil().into_value_with(handle),
+        }
+    }
+}
+
+impl magnus::TryConvert for VisitResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        serde_json::from_str(&s)
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for VisitResult {}
+unsafe impl TryConvertOwned for VisitResult {}
+
+#[allow(clippy::missing_errors_doc)]
+#[allow(unused_variables)]
+pub fn convert(
+    html: String,
+    options: Option<String>,
+    visitor: Option<magnus::Value>,
+) -> Result<ConversionResult, Error> {
+    let visitor: Option<html_to_markdown_rs::visitor::VisitorHandle> = match visitor {
+        Some(v) if !v.is_nil() => {
+            let bridge = RbHtmlVisitorBridge::new(v);
+            Some(std::rc::Rc::new(std::cell::RefCell::new(bridge)) as html_to_markdown_rs::visitor::VisitorHandle)
+        }
+        _ => None,
+    };
+    let options_core: Option<html_to_markdown_rs::ConversionOptions> = options
         .as_deref()
         .filter(|s| *s != "nil")
         .map(|s| {
-            let core: html_to_markdown_rs::ConversionOptions = serde_json::from_str(s).map_err(|e| {
-                magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string())
-            })?;
-            Ok::<_, magnus::Error>(core.into())
+            serde_json::from_str(s).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })
         })
         .transpose()?;
-    let result = html_to_markdown_rs::convert(&html, options.map(Into::into)).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
-    Ok(result.into())
+    html_to_markdown_rs::convert(&html, options_core, visitor)
+        .map(|val| val.into())
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })
 }
 
-impl From<MetadataConfig> for html_to_markdown_rs::metadata::MetadataConfig {
-    fn from(val: MetadataConfig) -> Self {
-        Self {
-            extract_document: val.extract_document,
-            extract_headers: val.extract_headers,
-            extract_links: val.extract_links,
-            extract_images: val.extract_images,
-            extract_structured_data: val.extract_structured_data,
-            max_structured_data_size: val.max_structured_data_size,
-        }
+fn nodecontext_to_rb_hash(ctx: &html_to_markdown_rs::visitor::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("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()),
+    )
+    .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
 }
 
-impl From<html_to_markdown_rs::metadata::MetadataConfig> for MetadataConfig {
-    fn from(val: html_to_markdown_rs::metadata::MetadataConfig) -> Self {
-        Self {
-            extract_document: val.extract_document,
-            extract_headers: val.extract_headers,
-            extract_links: val.extract_links,
-            extract_images: val.extract_images,
-            extract_structured_data: val.extract_structured_data,
-            max_structured_data_size: val.max_structured_data_size,
-        }
+pub struct RbHtmlVisitorBridge {
+    rb_obj: magnus::Value,
+}
+
+impl std::fmt::Debug for RbHtmlVisitorBridge {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "RbHtmlVisitorBridge")
     }
 }
 
-impl From<html_to_markdown_rs::metadata::MetadataConfigUpdate> for MetadataConfigUpdate {
-    fn from(val: html_to_markdown_rs::metadata::MetadataConfigUpdate) -> Self {
-        Self {
-            extract_document: val.extract_document,
-            extract_headers: val.extract_headers,
-            extract_links: val.extract_links,
-            extract_images: val.extract_images,
-            extract_structured_data: val.extract_structured_data,
-            max_structured_data_size: val.max_structured_data_size,
+impl RbHtmlVisitorBridge {
+    pub fn new(rb_obj: magnus::Value) -> Self {
+        Self { rb_obj }
+    }
+}
+
+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);
+        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),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    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_element_end",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_output)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    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_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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_link(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _href: &str,
+        _text: &str,
+        _title: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_link", 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_link",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_href)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_text)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _title {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_image(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _src: &str,
+        _alt: &str,
+        _title: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_image", 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_image",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_src)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_alt)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _title {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_heading(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _level: u32,
+        _text: &str,
+        _id: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_heading", 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_heading",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                _level,
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_text)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _id {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_code_block(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _lang: Option<&str>,
+        _code: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_code_block", 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_code_block",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _lang {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_code)
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_code_inline(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _code: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_code_inline", 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_code_inline",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_code)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_list_item(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _ordered: bool,
+        _marker: &str,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_list_item", 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_list_item",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                _ordered,
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_marker)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_text)
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_list_start(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _ordered: bool,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_list_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_list_start", (nodecontext_to_rb_hash(_ctx), _ordered));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_list_end(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _ordered: bool,
+        _output: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_list_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_list_end",
+            (nodecontext_to_rb_hash(_ctx), _ordered, {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_output)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_table_start(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_table_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_table_start", (nodecontext_to_rb_hash(_ctx),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_table_row(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _cells: &[String],
+        _is_header: bool,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_table_row", 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_table_row",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let arr = unsafe { magnus::Ruby::get_unchecked() }.ary_new_capa(_cells.len());
+                    for item in _cells {
+                        let _ = arr.push(item.to_string());
+                    }
+                    arr
+                },
+                _is_header,
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_table_end(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _output: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_table_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_table_end",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_output)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_blockquote(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _content: &str,
+        _depth: usize,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_blockquote", 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_blockquote",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_content)
+                },
+                _depth,
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_strong(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_strong", 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_strong",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_emphasis(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_emphasis", 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_emphasis",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_strikethrough(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_strikethrough", 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_strikethrough",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_underline(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_underline", 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_underline",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_subscript(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_subscript", 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_subscript",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_superscript(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_superscript", 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_superscript",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_mark(&mut self, _ctx: &html_to_markdown_rs::NodeContext, _text: &str) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_mark", 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_mark",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_line_break(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_line_break", 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_line_break", (nodecontext_to_rb_hash(_ctx),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_horizontal_rule(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_horizontal_rule", 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_horizontal_rule", (nodecontext_to_rb_hash(_ctx),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_custom_element(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _tag_name: &str,
+        _html: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_custom_element", 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_custom_element",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_tag_name)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_html)
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_definition_list_start(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self
+            .rb_obj
+            .respond_to("visit_definition_list_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_definition_list_start", (nodecontext_to_rb_hash(_ctx),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_definition_term(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_definition_term", 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_definition_term",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_definition_description(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self
+            .rb_obj
+            .respond_to("visit_definition_description", 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_definition_description",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_definition_list_end(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _output: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self
+            .rb_obj
+            .respond_to("visit_definition_list_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_definition_list_end",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_output)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_form(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _action: Option<&str>,
+        _method: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_form", 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_form",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _action {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _method {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_input(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _input_type: &str,
+        _name: Option<&str>,
+        _value: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_input", 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_input",
+            (
+                nodecontext_to_rb_hash(_ctx),
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    ruby.str_new(_input_type)
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _name {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+                {
+                    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                    match _value {
+                        Some(s) => ruby.str_new(s).as_value(),
+                        None => ruby.qnil().as_value(),
+                    }
+                },
+            ),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_button(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_button", 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_button",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_audio(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _src: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_audio", 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_audio",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                match _src {
+                    Some(s) => ruby.str_new(s).as_value(),
+                    None => ruby.qnil().as_value(),
+                }
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_video(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _src: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_video", 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_video",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                match _src {
+                    Some(s) => ruby.str_new(s).as_value(),
+                    None => ruby.qnil().as_value(),
+                }
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_iframe(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _src: Option<&str>,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_iframe", 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_iframe",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                match _src {
+                    Some(s) => ruby.str_new(s).as_value(),
+                    None => ruby.qnil().as_value(),
+                }
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_details(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _open: bool,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_details", 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_details", (nodecontext_to_rb_hash(_ctx), _open));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_summary(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_summary", 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_summary",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_figure_start(&mut self, _ctx: &html_to_markdown_rs::NodeContext) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_figure_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_figure_start", (nodecontext_to_rb_hash(_ctx),));
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_figcaption(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _text: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_figcaption", 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_figcaption",
+            (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) => {
+                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()),
+                }
+            }
+        }
+    }
+
+    fn visit_figure_end(
+        &mut self,
+        _ctx: &html_to_markdown_rs::NodeContext,
+        _output: &str,
+    ) -> html_to_markdown_rs::VisitResult {
+        let responds = self.rb_obj.respond_to("visit_figure_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_figure_end",
+            (nodecontext_to_rb_hash(_ctx), {
+                let ruby = unsafe { magnus::Ruby::get_unchecked() };
+                ruby.str_new(_output)
+            }),
+        );
+        match result {
+            Err(_) => html_to_markdown_rs::VisitResult::Continue,
+            Ok(val) => {
+                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()),
+                }
+            }
         }
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata {
     fn from(val: DocumentMetadata) -> Self {
         Self {
@@ -2593,6 +4195,7 @@ impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::DocumentMetadata> for DocumentMetadata {
     fn from(val: html_to_markdown_rs::metadata::DocumentMetadata) -> Self {
         Self {
@@ -2611,6 +4214,7 @@ impl From<html_to_markdown_rs::metadata::DocumentMetadata> for DocumentMetadata
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<HeaderMetadata> for html_to_markdown_rs::metadata::HeaderMetadata {
     fn from(val: HeaderMetadata) -> Self {
         Self {
@@ -2623,6 +4227,7 @@ impl From<HeaderMetadata> for html_to_markdown_rs::metadata::HeaderMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
     fn from(val: html_to_markdown_rs::metadata::HeaderMetadata) -> Self {
         Self {
@@ -2635,6 +4240,7 @@ impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
     fn from(val: LinkMetadata) -> Self {
         Self {
@@ -2648,6 +4254,7 @@ impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::LinkMetadata> for LinkMetadata {
     fn from(val: html_to_markdown_rs::metadata::LinkMetadata) -> Self {
         Self {
@@ -2661,6 +4268,7 @@ impl From<html_to_markdown_rs::metadata::LinkMetadata> for LinkMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
     fn from(val: ImageMetadata) -> Self {
         Self {
@@ -2674,19 +4282,24 @@ impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 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.as_ref().map(|v| format!("{:?}", v)),
+            dimensions: val.dimensions.map(|t| {
+                let arr: Vec<_> = [t.0, t.1].into_iter().map(|v| v as _).collect();
+                arr
+            }),
             image_type: val.image_type.into(),
             attributes: val.attributes.into_iter().collect(),
         }
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<StructuredData> for html_to_markdown_rs::metadata::StructuredData {
     fn from(val: StructuredData) -> Self {
         Self {
@@ -2697,6 +4310,7 @@ impl From<StructuredData> for html_to_markdown_rs::metadata::StructuredData {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::StructuredData> for StructuredData {
     fn from(val: html_to_markdown_rs::metadata::StructuredData) -> Self {
         Self {
@@ -2707,6 +4321,7 @@ impl From<html_to_markdown_rs::metadata::StructuredData> for StructuredData {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<HtmlMetadata> for html_to_markdown_rs::metadata::HtmlMetadata {
     fn from(val: HtmlMetadata) -> Self {
         Self {
@@ -2719,6 +4334,7 @@ impl From<HtmlMetadata> for html_to_markdown_rs::metadata::HtmlMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::HtmlMetadata> for HtmlMetadata {
     fn from(val: html_to_markdown_rs::metadata::HtmlMetadata) -> Self {
         Self {
@@ -2731,6 +4347,7 @@ impl From<html_to_markdown_rs::metadata::HtmlMetadata> for HtmlMetadata {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions {
     fn from(val: ConversionOptions) -> Self {
         Self {
@@ -2772,10 +4389,13 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             max_image_size: val.max_image_size,
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
+            max_depth: val.max_depth,
+            exclude_selectors: val.exclude_selectors,
         }
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions {
     fn from(val: html_to_markdown_rs::options::ConversionOptions) -> Self {
         Self {
@@ -2817,10 +4437,61 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             max_image_size: val.max_image_size,
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
+            max_depth: val.max_depth,
+            exclude_selectors: val.exclude_selectors,
         }
     }
 }
 
+#[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,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionOptionsUpdate {
     fn from(val: html_to_markdown_rs::options::ConversionOptionsUpdate) -> Self {
         Self {
@@ -2862,10 +4533,13 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             max_image_size: val.max_image_size,
             capture_svg: val.capture_svg,
             infer_dimensions: val.infer_dimensions,
+            max_depth: val.max_depth.flatten(),
+            exclude_selectors: val.exclude_selectors,
         }
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<PreprocessingOptions> for html_to_markdown_rs::options::PreprocessingOptions {
     fn from(val: PreprocessingOptions) -> Self {
         Self {
@@ -2877,6 +4551,7 @@ impl From<PreprocessingOptions> for html_to_markdown_rs::options::PreprocessingO
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::options::PreprocessingOptions> for PreprocessingOptions {
     fn from(val: html_to_markdown_rs::options::PreprocessingOptions) -> Self {
         Self {
@@ -2888,6 +4563,19 @@ 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 {
+        Self {
+            enabled: val.enabled,
+            preset: val.preset.map(Into::into),
+            remove_navigation: val.remove_navigation,
+            remove_forms: val.remove_forms,
+        }
+    }
+}
+
+#[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 {
         Self {
@@ -2899,6 +4587,7 @@ impl From<html_to_markdown_rs::options::PreprocessingOptionsUpdate> for Preproce
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DocumentStructure> for html_to_markdown_rs::DocumentStructure {
     fn from(val: DocumentStructure) -> Self {
         Self {
@@ -2908,6 +4597,7 @@ impl From<DocumentStructure> for html_to_markdown_rs::DocumentStructure {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::DocumentStructure> for DocumentStructure {
     fn from(val: html_to_markdown_rs::DocumentStructure) -> Self {
         Self {
@@ -2917,6 +4607,7 @@ impl From<html_to_markdown_rs::DocumentStructure> for DocumentStructure {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DocumentNode> for html_to_markdown_rs::DocumentNode {
     fn from(val: DocumentNode) -> Self {
         Self {
@@ -2930,6 +4621,7 @@ impl From<DocumentNode> for html_to_markdown_rs::DocumentNode {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::DocumentNode> for DocumentNode {
     fn from(val: html_to_markdown_rs::DocumentNode) -> Self {
         Self {
@@ -2943,6 +4635,7 @@ impl From<html_to_markdown_rs::DocumentNode> for DocumentNode {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<TextAnnotation> for html_to_markdown_rs::TextAnnotation {
     fn from(val: TextAnnotation) -> Self {
         Self {
@@ -2953,6 +4646,7 @@ impl From<TextAnnotation> for html_to_markdown_rs::TextAnnotation {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::TextAnnotation> for TextAnnotation {
     fn from(val: html_to_markdown_rs::TextAnnotation) -> Self {
         Self {
@@ -2964,6 +4658,7 @@ impl From<html_to_markdown_rs::TextAnnotation> for TextAnnotation {
 }
 
 #[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
     fn from(val: ConversionResult) -> Self {
         Self {
@@ -2978,6 +4673,7 @@ impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
     fn from(val: html_to_markdown_rs::ConversionResult) -> Self {
         Self {
@@ -2991,6 +4687,7 @@ impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<TableGrid> for html_to_markdown_rs::TableGrid {
     fn from(val: TableGrid) -> Self {
         Self {
@@ -3001,6 +4698,7 @@ impl From<TableGrid> for html_to_markdown_rs::TableGrid {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::TableGrid> for TableGrid {
     fn from(val: html_to_markdown_rs::TableGrid) -> Self {
         Self {
@@ -3011,6 +4709,7 @@ impl From<html_to_markdown_rs::TableGrid> for TableGrid {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<GridCell> for html_to_markdown_rs::GridCell {
     fn from(val: GridCell) -> Self {
         Self {
@@ -3024,6 +4723,7 @@ impl From<GridCell> for html_to_markdown_rs::GridCell {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::GridCell> for GridCell {
     fn from(val: html_to_markdown_rs::GridCell) -> Self {
         Self {
@@ -3037,6 +4737,7 @@ impl From<html_to_markdown_rs::GridCell> for GridCell {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<TableData> for html_to_markdown_rs::TableData {
     fn from(val: TableData) -> Self {
         Self {
@@ -3046,6 +4747,7 @@ impl From<TableData> for html_to_markdown_rs::TableData {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::TableData> for TableData {
     fn from(val: html_to_markdown_rs::TableData) -> Self {
         Self {
@@ -3055,6 +4757,7 @@ impl From<html_to_markdown_rs::TableData> for TableData {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ProcessingWarning> for html_to_markdown_rs::ProcessingWarning {
     fn from(val: ProcessingWarning) -> Self {
         Self {
@@ -3064,6 +4767,7 @@ impl From<ProcessingWarning> for html_to_markdown_rs::ProcessingWarning {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::ProcessingWarning> for ProcessingWarning {
     fn from(val: html_to_markdown_rs::ProcessingWarning) -> Self {
         Self {
@@ -3073,6 +4777,21 @@ impl From<html_to_markdown_rs::ProcessingWarning> for ProcessingWarning {
     }
 }
 
+#[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().collect(),
+            depth: val.depth,
+            index_in_parent: val.index_in_parent,
+            parent_tag: val.parent_tag,
+            is_inline: val.is_inline,
+        }
+    }
+}
+
 impl From<TextDirection> for html_to_markdown_rs::metadata::TextDirection {
     fn from(val: TextDirection) -> Self {
         match val {
@@ -3358,7 +5077,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: serde_json::from_str(&entries).unwrap_or_default(),
+                entries: entries.iter().filter_map(|s| serde_json::from_str(s).ok()).collect(),
             },
             NodeContent::Group {
                 label,
@@ -3398,7 +5117,7 @@ impl From<html_to_markdown_rs::NodeContent> for NodeContent {
             }
             html_to_markdown_rs::NodeContent::RawBlock { format, content } => Self::RawBlock { format, content },
             html_to_markdown_rs::NodeContent::MetadataBlock { entries } => Self::MetadataBlock {
-                entries: serde_json::to_string(&entries).unwrap_or_default(),
+                entries: entries.iter().map(|i| format!("{:?}", i)).collect(),
             },
             html_to_markdown_rs::NodeContent::Group {
                 label,
@@ -3453,6 +5172,7 @@ impl From<WarningKind> for html_to_markdown_rs::WarningKind {
             WarningKind::TruncatedInput => Self::TruncatedInput,
             WarningKind::MalformedHtml => Self::MalformedHtml,
             WarningKind::SanitizationApplied => Self::SanitizationApplied,
+            WarningKind::DepthLimitExceeded => Self::DepthLimitExceeded,
         }
     }
 }
@@ -3465,6 +5185,114 @@ impl From<html_to_markdown_rs::WarningKind> for WarningKind {
             html_to_markdown_rs::WarningKind::TruncatedInput => Self::TruncatedInput,
             html_to_markdown_rs::WarningKind::MalformedHtml => Self::MalformedHtml,
             html_to_markdown_rs::WarningKind::SanitizationApplied => Self::SanitizationApplied,
+            html_to_markdown_rs::WarningKind::DepthLimitExceeded => Self::DepthLimitExceeded,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::NodeType> for NodeType {
+    fn from(val: html_to_markdown_rs::NodeType) -> Self {
+        match val {
+            html_to_markdown_rs::NodeType::Text => Self::Text,
+            html_to_markdown_rs::NodeType::Element => Self::Element,
+            html_to_markdown_rs::NodeType::Heading => Self::Heading,
+            html_to_markdown_rs::NodeType::Paragraph => Self::Paragraph,
+            html_to_markdown_rs::NodeType::Div => Self::Div,
+            html_to_markdown_rs::NodeType::Blockquote => Self::Blockquote,
+            html_to_markdown_rs::NodeType::Pre => Self::Pre,
+            html_to_markdown_rs::NodeType::Hr => Self::Hr,
+            html_to_markdown_rs::NodeType::List => Self::List,
+            html_to_markdown_rs::NodeType::ListItem => Self::ListItem,
+            html_to_markdown_rs::NodeType::DefinitionList => Self::DefinitionList,
+            html_to_markdown_rs::NodeType::DefinitionTerm => Self::DefinitionTerm,
+            html_to_markdown_rs::NodeType::DefinitionDescription => Self::DefinitionDescription,
+            html_to_markdown_rs::NodeType::Table => Self::Table,
+            html_to_markdown_rs::NodeType::TableRow => Self::TableRow,
+            html_to_markdown_rs::NodeType::TableCell => Self::TableCell,
+            html_to_markdown_rs::NodeType::TableHeader => Self::TableHeader,
+            html_to_markdown_rs::NodeType::TableBody => Self::TableBody,
+            html_to_markdown_rs::NodeType::TableHead => Self::TableHead,
+            html_to_markdown_rs::NodeType::TableFoot => Self::TableFoot,
+            html_to_markdown_rs::NodeType::Link => Self::Link,
+            html_to_markdown_rs::NodeType::Image => Self::Image,
+            html_to_markdown_rs::NodeType::Strong => Self::Strong,
+            html_to_markdown_rs::NodeType::Em => Self::Em,
+            html_to_markdown_rs::NodeType::Code => Self::Code,
+            html_to_markdown_rs::NodeType::Strikethrough => Self::Strikethrough,
+            html_to_markdown_rs::NodeType::Underline => Self::Underline,
+            html_to_markdown_rs::NodeType::Subscript => Self::Subscript,
+            html_to_markdown_rs::NodeType::Superscript => Self::Superscript,
+            html_to_markdown_rs::NodeType::Mark => Self::Mark,
+            html_to_markdown_rs::NodeType::Small => Self::Small,
+            html_to_markdown_rs::NodeType::Br => Self::Br,
+            html_to_markdown_rs::NodeType::Span => Self::Span,
+            html_to_markdown_rs::NodeType::Article => Self::Article,
+            html_to_markdown_rs::NodeType::Section => Self::Section,
+            html_to_markdown_rs::NodeType::Nav => Self::Nav,
+            html_to_markdown_rs::NodeType::Aside => Self::Aside,
+            html_to_markdown_rs::NodeType::Header => Self::Header,
+            html_to_markdown_rs::NodeType::Footer => Self::Footer,
+            html_to_markdown_rs::NodeType::Main => Self::Main,
+            html_to_markdown_rs::NodeType::Figure => Self::Figure,
+            html_to_markdown_rs::NodeType::Figcaption => Self::Figcaption,
+            html_to_markdown_rs::NodeType::Time => Self::Time,
+            html_to_markdown_rs::NodeType::Details => Self::Details,
+            html_to_markdown_rs::NodeType::Summary => Self::Summary,
+            html_to_markdown_rs::NodeType::Form => Self::Form,
+            html_to_markdown_rs::NodeType::Input => Self::Input,
+            html_to_markdown_rs::NodeType::Select => Self::Select,
+            html_to_markdown_rs::NodeType::Option => Self::Option,
+            html_to_markdown_rs::NodeType::Button => Self::Button,
+            html_to_markdown_rs::NodeType::Textarea => Self::Textarea,
+            html_to_markdown_rs::NodeType::Label => Self::Label,
+            html_to_markdown_rs::NodeType::Fieldset => Self::Fieldset,
+            html_to_markdown_rs::NodeType::Legend => Self::Legend,
+            html_to_markdown_rs::NodeType::Audio => Self::Audio,
+            html_to_markdown_rs::NodeType::Video => Self::Video,
+            html_to_markdown_rs::NodeType::Picture => Self::Picture,
+            html_to_markdown_rs::NodeType::Source => Self::Source,
+            html_to_markdown_rs::NodeType::Iframe => Self::Iframe,
+            html_to_markdown_rs::NodeType::Svg => Self::Svg,
+            html_to_markdown_rs::NodeType::Canvas => Self::Canvas,
+            html_to_markdown_rs::NodeType::Ruby => Self::Ruby,
+            html_to_markdown_rs::NodeType::Rt => Self::Rt,
+            html_to_markdown_rs::NodeType::Rp => Self::Rp,
+            html_to_markdown_rs::NodeType::Abbr => Self::Abbr,
+            html_to_markdown_rs::NodeType::Kbd => Self::Kbd,
+            html_to_markdown_rs::NodeType::Samp => Self::Samp,
+            html_to_markdown_rs::NodeType::Var => Self::Var,
+            html_to_markdown_rs::NodeType::Cite => Self::Cite,
+            html_to_markdown_rs::NodeType::Q => Self::Q,
+            html_to_markdown_rs::NodeType::Del => Self::Del,
+            html_to_markdown_rs::NodeType::Ins => Self::Ins,
+            html_to_markdown_rs::NodeType::Data => Self::Data,
+            html_to_markdown_rs::NodeType::Meter => Self::Meter,
+            html_to_markdown_rs::NodeType::Progress => Self::Progress,
+            html_to_markdown_rs::NodeType::Output => Self::Output,
+            html_to_markdown_rs::NodeType::Template => Self::Template,
+            html_to_markdown_rs::NodeType::Slot => Self::Slot,
+            html_to_markdown_rs::NodeType::Html => Self::Html,
+            html_to_markdown_rs::NodeType::Head => Self::Head,
+            html_to_markdown_rs::NodeType::Body => Self::Body,
+            html_to_markdown_rs::NodeType::Title => Self::Title,
+            html_to_markdown_rs::NodeType::Meta => Self::Meta,
+            html_to_markdown_rs::NodeType::LinkTag => Self::LinkTag,
+            html_to_markdown_rs::NodeType::Style => Self::Style,
+            html_to_markdown_rs::NodeType::Script => Self::Script,
+            html_to_markdown_rs::NodeType::Base => Self::Base,
+            html_to_markdown_rs::NodeType::Custom => Self::Custom,
+        }
+    }
+}
+
+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::Skip => Self::Skip,
+            html_to_markdown_rs::VisitResult::PreserveHtml => Self::PreserveHtml,
+            html_to_markdown_rs::VisitResult::Error(_0) => Self::Error { _0 },
         }
     }
 }
@@ -3480,37 +5308,6 @@ fn conversion_error_to_magnus_err(e: html_to_markdown_rs::error::ConversionError
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("HtmlToMarkdownRs")?;
 
-    let class = module.define_class("MetadataConfig", ruby.class_object())?;
-    class.define_singleton_method("new", function!(MetadataConfig::new, 6))?;
-    class.define_method("extract_document", method!(MetadataConfig::extract_document, 0))?;
-    class.define_method("extract_headers", method!(MetadataConfig::extract_headers, 0))?;
-    class.define_method("extract_links", method!(MetadataConfig::extract_links, 0))?;
-    class.define_method("extract_images", method!(MetadataConfig::extract_images, 0))?;
-    class.define_method(
-        "extract_structured_data",
-        method!(MetadataConfig::extract_structured_data, 0),
-    )?;
-    class.define_method(
-        "max_structured_data_size",
-        method!(MetadataConfig::max_structured_data_size, 0),
-    )?;
-    class.define_method("any_enabled", method!(MetadataConfig::any_enabled, 0))?;
-
-    let class = module.define_class("MetadataConfigUpdate", ruby.class_object())?;
-    class.define_singleton_method("new", function!(MetadataConfigUpdate::new, 6))?;
-    class.define_method("extract_document", method!(MetadataConfigUpdate::extract_document, 0))?;
-    class.define_method("extract_headers", method!(MetadataConfigUpdate::extract_headers, 0))?;
-    class.define_method("extract_links", method!(MetadataConfigUpdate::extract_links, 0))?;
-    class.define_method("extract_images", method!(MetadataConfigUpdate::extract_images, 0))?;
-    class.define_method(
-        "extract_structured_data",
-        method!(MetadataConfigUpdate::extract_structured_data, 0),
-    )?;
-    class.define_method(
-        "max_structured_data_size",
-        method!(MetadataConfigUpdate::max_structured_data_size, 0),
-    )?;
-
     let class = module.define_class("DocumentMetadata", ruby.class_object())?;
     class.define_singleton_method("new", function!(DocumentMetadata::new, 11))?;
     class.define_method("title", method!(DocumentMetadata::title, 0))?;
@@ -3612,6 +5409,9 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     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("apply_update", method!(ConversionOptions::apply_update, 1))?;
 
     let class = module.define_class("ConversionOptionsBuilder", ruby.class_object())?;
     class.define_method("strip_tags", method!(ConversionOptionsBuilder::strip_tags, 1))?;
@@ -3620,6 +5420,10 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "keep_inline_images_in",
         method!(ConversionOptionsBuilder::keep_inline_images_in, 1),
     )?;
+    class.define_method(
+        "exclude_selectors",
+        method!(ConversionOptionsBuilder::exclude_selectors, 1),
+    )?;
     class.define_method("preprocessing", method!(ConversionOptionsBuilder::preprocessing, 1))?;
     class.define_method("build", method!(ConversionOptionsBuilder::build, 0))?;
 
@@ -3696,6 +5500,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "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),
+    )?;
 
     let class = module.define_class("PreprocessingOptions", ruby.class_object())?;
     class.define_singleton_method("new", function!(PreprocessingOptions::new, 4))?;
@@ -3703,6 +5512,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     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))?;
+    class.define_method("apply_update", method!(PreprocessingOptions::apply_update, 1))?;
 
     let class = module.define_class("PreprocessingOptionsUpdate", ruby.class_object())?;
     class.define_singleton_method("new", function!(PreprocessingOptionsUpdate::new, 4))?;
@@ -3768,7 +5578,17 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("message", method!(ProcessingWarning::message, 0))?;
     class.define_method("kind", method!(ProcessingWarning::kind, 0))?;
 
-    module.define_module_function("convert", function!(convert, 2))?;
+    let class = module.define_class("NodeContext", ruby.class_object())?;
+    class.define_singleton_method("new", function!(NodeContext::new, 7))?;
+    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))?;
+
+    module.define_module_function("convert", function!(convert, 3))?;
 
     Ok(())
 }