html-to-markdown 3.12.0 → 3.12.2

data/ext/html_to_markdown_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:567d96a85a5e21b5625dc645c55076d5ccf724d0114a18f3c5180b56d49bead1
+// alef:hash:2a25867ec087a834fd64967be75675eaaa818c9513d0dc42ccfdfdf161523deb
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -148,177 +148,393 @@ impl ConversionOptions {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            heading_style: kwargs
-                .get(ruby.to_symbol("heading_style"))
-                .and_then(|v| HeadingStyle::try_convert(v).ok())
-                .unwrap_or(HeadingStyle::Atx),
-            list_indent_type: kwargs
-                .get(ruby.to_symbol("list_indent_type"))
-                .and_then(|v| ListIndentType::try_convert(v).ok())
-                .unwrap_or(ListIndentType::Spaces),
-            list_indent_width: kwargs
-                .get(ruby.to_symbol("list_indent_width"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or(2),
-            bullets: kwargs
-                .get(ruby.to_symbol("bullets"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("-*+".to_string()),
-            strong_em_symbol: kwargs
-                .get(ruby.to_symbol("strong_em_symbol"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("*".to_string()),
-            escape_asterisks: kwargs
-                .get(ruby.to_symbol("escape_asterisks"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            escape_underscores: kwargs
-                .get(ruby.to_symbol("escape_underscores"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            escape_misc: kwargs
-                .get(ruby.to_symbol("escape_misc"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            escape_ascii: kwargs
-                .get(ruby.to_symbol("escape_ascii"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            code_language: kwargs
-                .get(ruby.to_symbol("code_language"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("".to_string()),
-            autolinks: kwargs
-                .get(ruby.to_symbol("autolinks"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            default_title: kwargs
-                .get(ruby.to_symbol("default_title"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            br_in_tables: kwargs
-                .get(ruby.to_symbol("br_in_tables"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            compact_tables: kwargs
-                .get(ruby.to_symbol("compact_tables"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            highlight_style: kwargs
-                .get(ruby.to_symbol("highlight_style"))
-                .and_then(|v| HighlightStyle::try_convert(v).ok())
-                .unwrap_or(HighlightStyle::DoubleEqual),
-            extract_metadata: kwargs
-                .get(ruby.to_symbol("extract_metadata"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            whitespace_mode: kwargs
-                .get(ruby.to_symbol("whitespace_mode"))
-                .and_then(|v| WhitespaceMode::try_convert(v).ok())
-                .unwrap_or(WhitespaceMode::Normalized),
-            strip_newlines: kwargs
-                .get(ruby.to_symbol("strip_newlines"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            wrap: kwargs
-                .get(ruby.to_symbol("wrap"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            wrap_width: kwargs
-                .get(ruby.to_symbol("wrap_width"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or(80),
-            convert_as_inline: kwargs
-                .get(ruby.to_symbol("convert_as_inline"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            sub_symbol: kwargs
-                .get(ruby.to_symbol("sub_symbol"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("".to_string()),
-            sup_symbol: kwargs
-                .get(ruby.to_symbol("sup_symbol"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("".to_string()),
-            newline_style: kwargs
-                .get(ruby.to_symbol("newline_style"))
-                .and_then(|v| NewlineStyle::try_convert(v).ok())
-                .unwrap_or(NewlineStyle::Spaces),
-            code_block_style: kwargs
-                .get(ruby.to_symbol("code_block_style"))
-                .and_then(|v| CodeBlockStyle::try_convert(v).ok())
-                .unwrap_or(CodeBlockStyle::Backticks),
-            keep_inline_images_in: kwargs
-                .get(ruby.to_symbol("keep_inline_images_in"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            preprocessing: kwargs
-                .get(ruby.to_symbol("preprocessing"))
-                .and_then(|v| PreprocessingOptions::try_convert(v).ok())
-                .unwrap_or_default(),
-            encoding: kwargs
-                .get(ruby.to_symbol("encoding"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or("utf-8".to_string()),
-            debug: kwargs
-                .get(ruby.to_symbol("debug"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            strip_tags: kwargs
-                .get(ruby.to_symbol("strip_tags"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            preserve_tags: kwargs
-                .get(ruby.to_symbol("preserve_tags"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            skip_images: kwargs
-                .get(ruby.to_symbol("skip_images"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            url_escape_style: kwargs
-                .get(ruby.to_symbol("url_escape_style"))
-                .and_then(|v| UrlEscapeStyle::try_convert(v).ok())
-                .unwrap_or(UrlEscapeStyle::Angle),
-            link_style: kwargs
-                .get(ruby.to_symbol("link_style"))
-                .and_then(|v| LinkStyle::try_convert(v).ok())
-                .unwrap_or(LinkStyle::Inline),
-            output_format: kwargs
-                .get(ruby.to_symbol("output_format"))
-                .and_then(|v| OutputFormat::try_convert(v).ok())
-                .unwrap_or(OutputFormat::Markdown),
-            include_document_structure: kwargs
-                .get(ruby.to_symbol("include_document_structure"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            extract_images: kwargs
-                .get(ruby.to_symbol("extract_images"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            max_image_size: kwargs
-                .get(ruby.to_symbol("max_image_size"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or(5242880),
-            capture_svg: kwargs
-                .get(ruby.to_symbol("capture_svg"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            infer_dimensions: kwargs
-                .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(),
-            tier_strategy: kwargs
-                .get(ruby.to_symbol("tier_strategy"))
-                .and_then(|v| TierStrategy::try_convert(v).ok())
-                .unwrap_or(TierStrategy::Auto),
+            heading_style: match kwargs.get(ruby.to_symbol("heading_style")) {
+                Some(v) => HeadingStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `heading_style`: {}", e),
+                    )
+                })?,
+                None => HeadingStyle::Atx,
+            },
+            list_indent_type: match kwargs.get(ruby.to_symbol("list_indent_type")) {
+                Some(v) => ListIndentType::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `list_indent_type`: {}", e),
+                    )
+                })?,
+                None => ListIndentType::Spaces,
+            },
+            list_indent_width: match kwargs.get(ruby.to_symbol("list_indent_width")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `list_indent_width`: {}", e),
+                    )
+                })?,
+                None => 2,
+            },
+            bullets: match kwargs.get(ruby.to_symbol("bullets")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `bullets`: {}", e),
+                    )
+                })?,
+                None => "-*+".to_string(),
+            },
+            strong_em_symbol: match kwargs.get(ruby.to_symbol("strong_em_symbol")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strong_em_symbol`: {}", e),
+                    )
+                })?,
+                None => "*".to_string(),
+            },
+            escape_asterisks: match kwargs.get(ruby.to_symbol("escape_asterisks")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_asterisks`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            escape_underscores: match kwargs.get(ruby.to_symbol("escape_underscores")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_underscores`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            escape_misc: match kwargs.get(ruby.to_symbol("escape_misc")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_misc`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            escape_ascii: match kwargs.get(ruby.to_symbol("escape_ascii")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_ascii`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            code_language: match kwargs.get(ruby.to_symbol("code_language")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `code_language`: {}", e),
+                    )
+                })?,
+                None => "".to_string(),
+            },
+            autolinks: match kwargs.get(ruby.to_symbol("autolinks")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `autolinks`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            default_title: match kwargs.get(ruby.to_symbol("default_title")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `default_title`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            br_in_tables: match kwargs.get(ruby.to_symbol("br_in_tables")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `br_in_tables`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            compact_tables: match kwargs.get(ruby.to_symbol("compact_tables")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `compact_tables`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            highlight_style: match kwargs.get(ruby.to_symbol("highlight_style")) {
+                Some(v) => HighlightStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `highlight_style`: {}", e),
+                    )
+                })?,
+                None => HighlightStyle::DoubleEqual,
+            },
+            extract_metadata: match kwargs.get(ruby.to_symbol("extract_metadata")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_metadata`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            whitespace_mode: match kwargs.get(ruby.to_symbol("whitespace_mode")) {
+                Some(v) => WhitespaceMode::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `whitespace_mode`: {}", e),
+                    )
+                })?,
+                None => WhitespaceMode::Normalized,
+            },
+            strip_newlines: match kwargs.get(ruby.to_symbol("strip_newlines")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_newlines`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            wrap: match kwargs.get(ruby.to_symbol("wrap")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `wrap`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            wrap_width: match kwargs.get(ruby.to_symbol("wrap_width")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `wrap_width`: {}", e),
+                    )
+                })?,
+                None => 80,
+            },
+            convert_as_inline: match kwargs.get(ruby.to_symbol("convert_as_inline")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `convert_as_inline`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            sub_symbol: match kwargs.get(ruby.to_symbol("sub_symbol")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `sub_symbol`: {}", e),
+                    )
+                })?,
+                None => "".to_string(),
+            },
+            sup_symbol: match kwargs.get(ruby.to_symbol("sup_symbol")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `sup_symbol`: {}", e),
+                    )
+                })?,
+                None => "".to_string(),
+            },
+            newline_style: match kwargs.get(ruby.to_symbol("newline_style")) {
+                Some(v) => NewlineStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `newline_style`: {}", e),
+                    )
+                })?,
+                None => NewlineStyle::Spaces,
+            },
+            code_block_style: match kwargs.get(ruby.to_symbol("code_block_style")) {
+                Some(v) => CodeBlockStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `code_block_style`: {}", e),
+                    )
+                })?,
+                None => CodeBlockStyle::Backticks,
+            },
+            keep_inline_images_in: match kwargs.get(ruby.to_symbol("keep_inline_images_in")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `keep_inline_images_in`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            preprocessing: match kwargs.get(ruby.to_symbol("preprocessing")) {
+                Some(v) => PreprocessingOptions::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preprocessing`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            encoding: match kwargs.get(ruby.to_symbol("encoding")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `encoding`: {}", e),
+                    )
+                })?,
+                None => "utf-8".to_string(),
+            },
+            debug: match kwargs.get(ruby.to_symbol("debug")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `debug`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            strip_tags: match kwargs.get(ruby.to_symbol("strip_tags")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_tags`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            preserve_tags: match kwargs.get(ruby.to_symbol("preserve_tags")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preserve_tags`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            skip_images: match kwargs.get(ruby.to_symbol("skip_images")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `skip_images`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            url_escape_style: match kwargs.get(ruby.to_symbol("url_escape_style")) {
+                Some(v) => UrlEscapeStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `url_escape_style`: {}", e),
+                    )
+                })?,
+                None => UrlEscapeStyle::Angle,
+            },
+            link_style: match kwargs.get(ruby.to_symbol("link_style")) {
+                Some(v) => LinkStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `link_style`: {}", e),
+                    )
+                })?,
+                None => LinkStyle::Inline,
+            },
+            output_format: match kwargs.get(ruby.to_symbol("output_format")) {
+                Some(v) => OutputFormat::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `output_format`: {}", e),
+                    )
+                })?,
+                None => OutputFormat::Markdown,
+            },
+            include_document_structure: match kwargs.get(ruby.to_symbol("include_document_structure")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `include_document_structure`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            extract_images: match kwargs.get(ruby.to_symbol("extract_images")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_images`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            max_image_size: match kwargs.get(ruby.to_symbol("max_image_size")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_image_size`: {}", e),
+                    )
+                })?,
+                None => 5242880,
+            },
+            capture_svg: match kwargs.get(ruby.to_symbol("capture_svg")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `capture_svg`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            infer_dimensions: match kwargs.get(ruby.to_symbol("infer_dimensions")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `infer_dimensions`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            max_depth: match kwargs.get(ruby.to_symbol("max_depth")) {
+                Some(v) => Some(usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_depth`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            exclude_selectors: match kwargs.get(ruby.to_symbol("exclude_selectors")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `exclude_selectors`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            tier_strategy: match kwargs.get(ruby.to_symbol("tier_strategy")) {
+                Some(v) => TierStrategy::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tier_strategy`: {}", e),
+                    )
+                })?,
+                None => TierStrategy::Auto,
+            },
         })
     }
 
@@ -585,135 +801,393 @@ impl ConversionOptionsUpdate {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            heading_style: kwargs
-                .get(ruby.to_symbol("heading_style"))
-                .and_then(|v| HeadingStyle::try_convert(v).ok()),
-            list_indent_type: kwargs
-                .get(ruby.to_symbol("list_indent_type"))
-                .and_then(|v| ListIndentType::try_convert(v).ok()),
-            list_indent_width: kwargs
-                .get(ruby.to_symbol("list_indent_width"))
-                .and_then(|v| usize::try_convert(v).ok()),
-            bullets: kwargs
-                .get(ruby.to_symbol("bullets"))
-                .and_then(|v| String::try_convert(v).ok()),
-            strong_em_symbol: kwargs
-                .get(ruby.to_symbol("strong_em_symbol"))
-                .and_then(|v| String::try_convert(v).ok()),
-            escape_asterisks: kwargs
-                .get(ruby.to_symbol("escape_asterisks"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            escape_underscores: kwargs
-                .get(ruby.to_symbol("escape_underscores"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            escape_misc: kwargs
-                .get(ruby.to_symbol("escape_misc"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            escape_ascii: kwargs
-                .get(ruby.to_symbol("escape_ascii"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            code_language: kwargs
-                .get(ruby.to_symbol("code_language"))
-                .and_then(|v| String::try_convert(v).ok()),
-            autolinks: kwargs
-                .get(ruby.to_symbol("autolinks"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            default_title: kwargs
-                .get(ruby.to_symbol("default_title"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            br_in_tables: kwargs
-                .get(ruby.to_symbol("br_in_tables"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            compact_tables: kwargs
-                .get(ruby.to_symbol("compact_tables"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            highlight_style: kwargs
-                .get(ruby.to_symbol("highlight_style"))
-                .and_then(|v| HighlightStyle::try_convert(v).ok()),
-            extract_metadata: kwargs
-                .get(ruby.to_symbol("extract_metadata"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            whitespace_mode: kwargs
-                .get(ruby.to_symbol("whitespace_mode"))
-                .and_then(|v| WhitespaceMode::try_convert(v).ok()),
-            strip_newlines: kwargs
-                .get(ruby.to_symbol("strip_newlines"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            wrap: kwargs
-                .get(ruby.to_symbol("wrap"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            wrap_width: kwargs
-                .get(ruby.to_symbol("wrap_width"))
-                .and_then(|v| usize::try_convert(v).ok()),
-            convert_as_inline: kwargs
-                .get(ruby.to_symbol("convert_as_inline"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            sub_symbol: kwargs
-                .get(ruby.to_symbol("sub_symbol"))
-                .and_then(|v| String::try_convert(v).ok()),
-            sup_symbol: kwargs
-                .get(ruby.to_symbol("sup_symbol"))
-                .and_then(|v| String::try_convert(v).ok()),
-            newline_style: kwargs
-                .get(ruby.to_symbol("newline_style"))
-                .and_then(|v| NewlineStyle::try_convert(v).ok()),
-            code_block_style: kwargs
-                .get(ruby.to_symbol("code_block_style"))
-                .and_then(|v| CodeBlockStyle::try_convert(v).ok()),
-            keep_inline_images_in: kwargs
-                .get(ruby.to_symbol("keep_inline_images_in"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
-            preprocessing: kwargs
-                .get(ruby.to_symbol("preprocessing"))
-                .and_then(|v| PreprocessingOptionsUpdate::try_convert(v).ok()),
-            encoding: kwargs
-                .get(ruby.to_symbol("encoding"))
-                .and_then(|v| String::try_convert(v).ok()),
-            debug: kwargs
-                .get(ruby.to_symbol("debug"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            strip_tags: kwargs
-                .get(ruby.to_symbol("strip_tags"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
-            preserve_tags: kwargs
-                .get(ruby.to_symbol("preserve_tags"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
-            skip_images: kwargs
-                .get(ruby.to_symbol("skip_images"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            url_escape_style: kwargs
-                .get(ruby.to_symbol("url_escape_style"))
-                .and_then(|v| UrlEscapeStyle::try_convert(v).ok()),
-            link_style: kwargs
-                .get(ruby.to_symbol("link_style"))
-                .and_then(|v| LinkStyle::try_convert(v).ok()),
-            output_format: kwargs
-                .get(ruby.to_symbol("output_format"))
-                .and_then(|v| OutputFormat::try_convert(v).ok()),
-            include_document_structure: kwargs
-                .get(ruby.to_symbol("include_document_structure"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            extract_images: kwargs
-                .get(ruby.to_symbol("extract_images"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            max_image_size: kwargs
-                .get(ruby.to_symbol("max_image_size"))
-                .and_then(|v| u64::try_convert(v).ok()),
-            capture_svg: kwargs
-                .get(ruby.to_symbol("capture_svg"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            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()),
-            tier_strategy: kwargs
-                .get(ruby.to_symbol("tier_strategy"))
-                .and_then(|v| TierStrategy::try_convert(v).ok()),
+            heading_style: match kwargs.get(ruby.to_symbol("heading_style")) {
+                Some(v) => Some(HeadingStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `heading_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            list_indent_type: match kwargs.get(ruby.to_symbol("list_indent_type")) {
+                Some(v) => Some(ListIndentType::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `list_indent_type`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            list_indent_width: match kwargs.get(ruby.to_symbol("list_indent_width")) {
+                Some(v) => Some(usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `list_indent_width`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            bullets: match kwargs.get(ruby.to_symbol("bullets")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `bullets`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            strong_em_symbol: match kwargs.get(ruby.to_symbol("strong_em_symbol")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strong_em_symbol`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            escape_asterisks: match kwargs.get(ruby.to_symbol("escape_asterisks")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_asterisks`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            escape_underscores: match kwargs.get(ruby.to_symbol("escape_underscores")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_underscores`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            escape_misc: match kwargs.get(ruby.to_symbol("escape_misc")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_misc`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            escape_ascii: match kwargs.get(ruby.to_symbol("escape_ascii")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `escape_ascii`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            code_language: match kwargs.get(ruby.to_symbol("code_language")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `code_language`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            autolinks: match kwargs.get(ruby.to_symbol("autolinks")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `autolinks`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            default_title: match kwargs.get(ruby.to_symbol("default_title")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `default_title`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            br_in_tables: match kwargs.get(ruby.to_symbol("br_in_tables")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `br_in_tables`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            compact_tables: match kwargs.get(ruby.to_symbol("compact_tables")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `compact_tables`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            highlight_style: match kwargs.get(ruby.to_symbol("highlight_style")) {
+                Some(v) => Some(HighlightStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `highlight_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            extract_metadata: match kwargs.get(ruby.to_symbol("extract_metadata")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_metadata`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            whitespace_mode: match kwargs.get(ruby.to_symbol("whitespace_mode")) {
+                Some(v) => Some(WhitespaceMode::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `whitespace_mode`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            strip_newlines: match kwargs.get(ruby.to_symbol("strip_newlines")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_newlines`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            wrap: match kwargs.get(ruby.to_symbol("wrap")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `wrap`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            wrap_width: match kwargs.get(ruby.to_symbol("wrap_width")) {
+                Some(v) => Some(usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `wrap_width`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            convert_as_inline: match kwargs.get(ruby.to_symbol("convert_as_inline")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `convert_as_inline`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            sub_symbol: match kwargs.get(ruby.to_symbol("sub_symbol")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `sub_symbol`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            sup_symbol: match kwargs.get(ruby.to_symbol("sup_symbol")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `sup_symbol`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            newline_style: match kwargs.get(ruby.to_symbol("newline_style")) {
+                Some(v) => Some(NewlineStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `newline_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            code_block_style: match kwargs.get(ruby.to_symbol("code_block_style")) {
+                Some(v) => Some(CodeBlockStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `code_block_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            keep_inline_images_in: match kwargs.get(ruby.to_symbol("keep_inline_images_in")) {
+                Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `keep_inline_images_in`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            preprocessing: match kwargs.get(ruby.to_symbol("preprocessing")) {
+                Some(v) => Some(PreprocessingOptionsUpdate::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preprocessing`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            encoding: match kwargs.get(ruby.to_symbol("encoding")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `encoding`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            debug: match kwargs.get(ruby.to_symbol("debug")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `debug`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            strip_tags: match kwargs.get(ruby.to_symbol("strip_tags")) {
+                Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_tags`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            preserve_tags: match kwargs.get(ruby.to_symbol("preserve_tags")) {
+                Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preserve_tags`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            skip_images: match kwargs.get(ruby.to_symbol("skip_images")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `skip_images`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            url_escape_style: match kwargs.get(ruby.to_symbol("url_escape_style")) {
+                Some(v) => Some(UrlEscapeStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `url_escape_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            link_style: match kwargs.get(ruby.to_symbol("link_style")) {
+                Some(v) => Some(LinkStyle::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `link_style`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            output_format: match kwargs.get(ruby.to_symbol("output_format")) {
+                Some(v) => Some(OutputFormat::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `output_format`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            include_document_structure: match kwargs.get(ruby.to_symbol("include_document_structure")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `include_document_structure`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            extract_images: match kwargs.get(ruby.to_symbol("extract_images")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_images`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_image_size: match kwargs.get(ruby.to_symbol("max_image_size")) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_image_size`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            capture_svg: match kwargs.get(ruby.to_symbol("capture_svg")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `capture_svg`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            infer_dimensions: match kwargs.get(ruby.to_symbol("infer_dimensions")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `infer_dimensions`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_depth: match kwargs.get(ruby.to_symbol("max_depth")) {
+                Some(v) => Some(usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_depth`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            exclude_selectors: match kwargs.get(ruby.to_symbol("exclude_selectors")) {
+                Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `exclude_selectors`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            tier_strategy: match kwargs.get(ruby.to_symbol("tier_strategy")) {
+                Some(v) => Some(TierStrategy::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tier_strategy`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -896,6 +1370,7 @@ impl ConversionOptionsUpdate {
 pub struct ConversionResult {
     content: Option<String>,
     document: Option<DocumentStructure>,
+    #[cfg(feature = "metadata")]
     metadata: HtmlMetadata,
     tables: Vec<TableData>,
     warnings: Vec<ProcessingWarning>,
@@ -942,24 +1417,52 @@ impl ConversionResult {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            content: kwargs
-                .get(ruby.to_symbol("content"))
-                .and_then(|v| String::try_convert(v).ok()),
-            document: kwargs
-                .get(ruby.to_symbol("document"))
-                .and_then(|v| DocumentStructure::try_convert(v).ok()),
-            metadata: kwargs
-                .get(ruby.to_symbol("metadata"))
-                .and_then(|v| HtmlMetadata::try_convert(v).ok())
-                .unwrap_or_default(),
-            tables: kwargs
-                .get(ruby.to_symbol("tables"))
-                .and_then(|v| <Vec<TableData>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            warnings: kwargs
-                .get(ruby.to_symbol("warnings"))
-                .and_then(|v| <Vec<ProcessingWarning>>::try_convert(v).ok())
-                .unwrap_or_default(),
+            content: match kwargs.get(ruby.to_symbol("content")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `content`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            document: match kwargs.get(ruby.to_symbol("document")) {
+                Some(v) => Some(DocumentStructure::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `document`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            #[cfg(feature = "metadata")]
+            metadata: match kwargs.get(ruby.to_symbol("metadata")) {
+                Some(v) => HtmlMetadata::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `metadata`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            tables: match kwargs.get(ruby.to_symbol("tables")) {
+                Some(v) => <Vec<TableData>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tables`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            warnings: match kwargs.get(ruby.to_symbol("warnings")) {
+                Some(v) => <Vec<ProcessingWarning>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `warnings`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -971,6 +1474,7 @@ impl ConversionResult {
         self.document.clone()
     }
 
+    #[cfg(feature = "metadata")]
     fn metadata(&self) -> HtmlMetadata {
         self.metadata.clone()
     }
@@ -989,6 +1493,7 @@ impl ConversionResult {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentMetadata")]
@@ -1006,8 +1511,10 @@ pub struct DocumentMetadata {
     meta_tags: HashMap<String, String>,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for DocumentMetadata {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for DocumentMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&DocumentMetadata as magnus::TryConvert>::try_convert(val) {
@@ -1032,14 +1539,17 @@ impl magnus::TryConvert for DocumentMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for DocumentMetadata {}
 
+#[cfg(feature = "metadata")]
 impl Default for DocumentMetadata {
     fn default() -> Self {
         html_to_markdown_rs::metadata::DocumentMetadata::default().into()
     }
 }
 
+#[cfg(feature = "metadata")]
 impl DocumentMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1047,43 +1557,105 @@ impl DocumentMetadata {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            title: kwargs
-                .get(ruby.to_symbol("title"))
-                .and_then(|v| String::try_convert(v).ok()),
-            description: kwargs
-                .get(ruby.to_symbol("description"))
-                .and_then(|v| String::try_convert(v).ok()),
-            keywords: kwargs
-                .get(ruby.to_symbol("keywords"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            author: kwargs
-                .get(ruby.to_symbol("author"))
-                .and_then(|v| String::try_convert(v).ok()),
-            canonical_url: kwargs
-                .get(ruby.to_symbol("canonical_url"))
-                .and_then(|v| String::try_convert(v).ok()),
-            base_href: kwargs
-                .get(ruby.to_symbol("base_href"))
-                .and_then(|v| String::try_convert(v).ok()),
-            language: kwargs
-                .get(ruby.to_symbol("language"))
-                .and_then(|v| String::try_convert(v).ok()),
-            text_direction: kwargs
-                .get(ruby.to_symbol("text_direction"))
-                .and_then(|v| TextDirection::try_convert(v).ok()),
-            open_graph: kwargs
-                .get(ruby.to_symbol("open_graph"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            twitter_card: kwargs
-                .get(ruby.to_symbol("twitter_card"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            meta_tags: kwargs
-                .get(ruby.to_symbol("meta_tags"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
+            title: match kwargs.get(ruby.to_symbol("title")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `title`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            description: match kwargs.get(ruby.to_symbol("description")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `description`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            keywords: match kwargs.get(ruby.to_symbol("keywords")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `keywords`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            author: match kwargs.get(ruby.to_symbol("author")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `author`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            canonical_url: match kwargs.get(ruby.to_symbol("canonical_url")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `canonical_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            base_href: match kwargs.get(ruby.to_symbol("base_href")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `base_href`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            language: match kwargs.get(ruby.to_symbol("language")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `language`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            text_direction: match kwargs.get(ruby.to_symbol("text_direction")) {
+                Some(v) => Some(TextDirection::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `text_direction`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            open_graph: match kwargs.get(ruby.to_symbol("open_graph")) {
+                Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `open_graph`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            twitter_card: match kwargs.get(ruby.to_symbol("twitter_card")) {
+                Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `twitter_card`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            meta_tags: match kwargs.get(ruby.to_symbol("meta_tags")) {
+                Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `meta_tags`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -1132,7 +1704,7 @@ impl DocumentMetadata {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, serde::Serialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::DocumentNode")]
 pub struct DocumentNode {
     id: String,
@@ -1170,6 +1742,14 @@ impl magnus::TryConvert for DocumentNode {
 }
 
 unsafe impl TryConvertOwned for DocumentNode {}
+impl<'de> serde::Deserialize<'de> for DocumentNode {
+    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <html_to_markdown_rs::DocumentNode as serde::Deserialize>::deserialize(deserializer).map(Into::into)
+    }
+}
 
 impl DocumentNode {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
@@ -1178,33 +1758,65 @@ impl DocumentNode {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            id: kwargs
-                .get(ruby.to_symbol("id"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            content: kwargs
-                .get(ruby.to_symbol("content"))
-                .and_then(|v| NodeContent::try_convert(v).ok())
-                .ok_or_else(|| {
+            id: match kwargs.get(ruby.to_symbol("id")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `id`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            content: match kwargs.get(ruby.to_symbol("content")) {
+                Some(v) => NodeContent::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `content`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: content",
+                    ));
+                }
+            },
+            parent: match kwargs.get(ruby.to_symbol("parent")) {
+                Some(v) => Some(u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `parent`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            children: match kwargs.get(ruby.to_symbol("children")) {
+                Some(v) => <Vec<u32>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `children`: {}", e),
                     )
                 })?,
-            parent: kwargs
-                .get(ruby.to_symbol("parent"))
-                .and_then(|v| u32::try_convert(v).ok()),
-            children: kwargs
-                .get(ruby.to_symbol("children"))
-                .and_then(|v| <Vec<u32>>::try_convert(v).ok())
-                .unwrap_or(vec![]),
-            annotations: kwargs
-                .get(ruby.to_symbol("annotations"))
-                .and_then(|v| <Vec<TextAnnotation>>::try_convert(v).ok())
-                .unwrap_or(vec![]),
-            attributes: kwargs
-                .get(ruby.to_symbol("attributes"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok()),
+                None => vec![],
+            },
+            annotations: match kwargs.get(ruby.to_symbol("annotations")) {
+                Some(v) => <Vec<TextAnnotation>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `annotations`: {}", e),
+                    )
+                })?,
+                None => vec![],
+            },
+            attributes: match kwargs.get(ruby.to_symbol("attributes")) {
+                Some(v) => Some(<HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `attributes`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -1275,13 +1887,24 @@ impl DocumentStructure {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            nodes: kwargs
-                .get(ruby.to_symbol("nodes"))
-                .and_then(|v| <Vec<DocumentNode>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            source_format: kwargs
-                .get(ruby.to_symbol("source_format"))
-                .and_then(|v| String::try_convert(v).ok()),
+            nodes: match kwargs.get(ruby.to_symbol("nodes")) {
+                Some(v) => <Vec<DocumentNode>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `nodes`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            source_format: match kwargs.get(ruby.to_symbol("source_format")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `source_format`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -1294,7 +1917,7 @@ impl DocumentStructure {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, serde::Serialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::GridCell")]
 pub struct GridCell {
     content: String,
@@ -1332,6 +1955,14 @@ impl magnus::TryConvert for GridCell {
 }
 
 unsafe impl TryConvertOwned for GridCell {}
+impl<'de> serde::Deserialize<'de> for GridCell {
+    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <html_to_markdown_rs::GridCell as serde::Deserialize>::deserialize(deserializer).map(Into::into)
+    }
+}
 
 impl Default for GridCell {
     fn default() -> Self {
@@ -1353,30 +1984,60 @@ impl GridCell {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            content: kwargs
-                .get(ruby.to_symbol("content"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            row: kwargs
-                .get(ruby.to_symbol("row"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            col: kwargs
-                .get(ruby.to_symbol("col"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            row_span: kwargs
-                .get(ruby.to_symbol("row_span"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or(1),
-            col_span: kwargs
-                .get(ruby.to_symbol("col_span"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or(1),
-            is_header: kwargs
-                .get(ruby.to_symbol("is_header"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
+            content: match kwargs.get(ruby.to_symbol("content")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `content`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            row: match kwargs.get(ruby.to_symbol("row")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `row`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            col: match kwargs.get(ruby.to_symbol("col")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `col`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            row_span: match kwargs.get(ruby.to_symbol("row_span")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `row_span`: {}", e),
+                    )
+                })?,
+                None => 1,
+            },
+            col_span: match kwargs.get(ruby.to_symbol("col_span")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `col_span`: {}", e),
+                    )
+                })?,
+                None => 1,
+            },
+            is_header: match kwargs.get(ruby.to_symbol("is_header")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `is_header`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
         })
     }
 
@@ -1410,6 +2071,7 @@ impl GridCell {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HeaderMetadata")]
 pub struct HeaderMetadata {
@@ -1420,8 +2082,10 @@ pub struct HeaderMetadata {
     html_offset: usize,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for HeaderMetadata {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for HeaderMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&HeaderMetadata as magnus::TryConvert>::try_convert(val) {
@@ -1446,8 +2110,10 @@ impl magnus::TryConvert for HeaderMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for HeaderMetadata {}
 
+#[cfg(feature = "metadata")]
 impl HeaderMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1455,25 +2121,51 @@ impl HeaderMetadata {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            level: kwargs
-                .get(ruby.to_symbol("level"))
-                .and_then(|v| u8::try_convert(v).ok())
-                .unwrap_or_default(),
-            text: kwargs
-                .get(ruby.to_symbol("text"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            id: kwargs
-                .get(ruby.to_symbol("id"))
-                .and_then(|v| String::try_convert(v).ok()),
-            depth: kwargs
-                .get(ruby.to_symbol("depth"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or_default(),
-            html_offset: kwargs
-                .get(ruby.to_symbol("html_offset"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or_default(),
+            level: match kwargs.get(ruby.to_symbol("level")) {
+                Some(v) => u8::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `level`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            text: match kwargs.get(ruby.to_symbol("text")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `text`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            id: match kwargs.get(ruby.to_symbol("id")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `id`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            depth: match kwargs.get(ruby.to_symbol("depth")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `depth`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            html_offset: match kwargs.get(ruby.to_symbol("html_offset")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `html_offset`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -1513,19 +2205,27 @@ impl HeaderMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::HtmlMetadata")]
 pub struct HtmlMetadata {
+    #[cfg(feature = "metadata")]
     document: DocumentMetadata,
+    #[cfg(feature = "metadata")]
     headers: Vec<HeaderMetadata>,
+    #[cfg(feature = "metadata")]
     links: Vec<LinkMetadata>,
+    #[cfg(feature = "metadata")]
     images: Vec<ImageMetadata>,
+    #[cfg(feature = "metadata")]
     structured_data: Vec<StructuredData>,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for HtmlMetadata {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for HtmlMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&HtmlMetadata as magnus::TryConvert>::try_convert(val) {
@@ -1550,14 +2250,17 @@ impl magnus::TryConvert for HtmlMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for HtmlMetadata {}
 
+#[cfg(feature = "metadata")]
 impl Default for HtmlMetadata {
     fn default() -> Self {
         html_to_markdown_rs::metadata::HtmlMetadata::default().into()
     }
 }
 
+#[cfg(feature = "metadata")]
 impl HtmlMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1565,45 +2268,80 @@ impl HtmlMetadata {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            document: kwargs
-                .get(ruby.to_symbol("document"))
-                .and_then(|v| DocumentMetadata::try_convert(v).ok())
-                .unwrap_or_default(),
-            headers: kwargs
-                .get(ruby.to_symbol("headers"))
-                .and_then(|v| <Vec<HeaderMetadata>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            links: kwargs
-                .get(ruby.to_symbol("links"))
-                .and_then(|v| <Vec<LinkMetadata>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            images: kwargs
-                .get(ruby.to_symbol("images"))
-                .and_then(|v| <Vec<ImageMetadata>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            structured_data: kwargs
-                .get(ruby.to_symbol("structured_data"))
-                .and_then(|v| <Vec<StructuredData>>::try_convert(v).ok())
-                .unwrap_or_default(),
+            #[cfg(feature = "metadata")]
+            document: match kwargs.get(ruby.to_symbol("document")) {
+                Some(v) => DocumentMetadata::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `document`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            #[cfg(feature = "metadata")]
+            headers: match kwargs.get(ruby.to_symbol("headers")) {
+                Some(v) => <Vec<HeaderMetadata>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `headers`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            #[cfg(feature = "metadata")]
+            links: match kwargs.get(ruby.to_symbol("links")) {
+                Some(v) => <Vec<LinkMetadata>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `links`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            #[cfg(feature = "metadata")]
+            images: match kwargs.get(ruby.to_symbol("images")) {
+                Some(v) => <Vec<ImageMetadata>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `images`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            #[cfg(feature = "metadata")]
+            structured_data: match kwargs.get(ruby.to_symbol("structured_data")) {
+                Some(v) => <Vec<StructuredData>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `structured_data`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
+    #[cfg(feature = "metadata")]
     fn document(&self) -> DocumentMetadata {
         self.document.clone()
     }
 
+    #[cfg(feature = "metadata")]
     fn headers(&self) -> Vec<HeaderMetadata> {
         self.headers.clone()
     }
 
+    #[cfg(feature = "metadata")]
     fn links(&self) -> Vec<LinkMetadata> {
         self.links.clone()
     }
 
+    #[cfg(feature = "metadata")]
     fn images(&self) -> Vec<ImageMetadata> {
         self.images.clone()
     }
 
+    #[cfg(feature = "metadata")]
     fn structured_data(&self) -> Vec<StructuredData> {
         self.structured_data.clone()
     }
@@ -1651,14 +2389,24 @@ impl ImageDimensions {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            width: kwargs
-                .get(ruby.to_symbol("width"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            height: kwargs
-                .get(ruby.to_symbol("height"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
+            width: match kwargs.get(ruby.to_symbol("width")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `width`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            height: match kwargs.get(ruby.to_symbol("height")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `height`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -1671,6 +2419,7 @@ impl ImageDimensions {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::ImageMetadata")]
 pub struct ImageMetadata {
@@ -1682,8 +2431,10 @@ pub struct ImageMetadata {
     attributes: HashMap<String, String>,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for ImageMetadata {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for ImageMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&ImageMetadata as magnus::TryConvert>::try_convert(val) {
@@ -1708,8 +2459,10 @@ impl magnus::TryConvert for ImageMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for ImageMetadata {}
 
+#[cfg(feature = "metadata")]
 impl ImageMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1717,32 +2470,65 @@ impl ImageMetadata {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            src: kwargs
-                .get(ruby.to_symbol("src"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            alt: kwargs
-                .get(ruby.to_symbol("alt"))
-                .and_then(|v| String::try_convert(v).ok()),
-            title: kwargs
-                .get(ruby.to_symbol("title"))
-                .and_then(|v| String::try_convert(v).ok()),
-            dimensions: kwargs
-                .get(ruby.to_symbol("dimensions"))
-                .and_then(|v| ImageDimensions::try_convert(v).ok()),
-            image_type: kwargs
-                .get(ruby.to_symbol("image_type"))
-                .and_then(|v| ImageType::try_convert(v).ok())
-                .ok_or_else(|| {
+            src: match kwargs.get(ruby.to_symbol("src")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `src`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            alt: match kwargs.get(ruby.to_symbol("alt")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `alt`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            title: match kwargs.get(ruby.to_symbol("title")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `title`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            dimensions: match kwargs.get(ruby.to_symbol("dimensions")) {
+                Some(v) => Some(ImageDimensions::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `dimensions`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            image_type: match kwargs.get(ruby.to_symbol("image_type")) {
+                Some(v) => ImageType::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `image_type`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: image_type",
+                    ));
+                }
+            },
+            attributes: match kwargs.get(ruby.to_symbol("attributes")) {
+                Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `attributes`: {}", e),
                     )
                 })?,
-            attributes: kwargs
-                .get(ruby.to_symbol("attributes"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
+                None => Default::default(),
+            },
         })
     }
 
@@ -1771,6 +2557,7 @@ impl ImageMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::LinkMetadata")]
 pub struct LinkMetadata {
@@ -1782,8 +2569,10 @@ pub struct LinkMetadata {
     attributes: HashMap<String, String>,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for LinkMetadata {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for LinkMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&LinkMetadata as magnus::TryConvert>::try_convert(val) {
@@ -1808,8 +2597,10 @@ impl magnus::TryConvert for LinkMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for LinkMetadata {}
 
+#[cfg(feature = "metadata")]
 impl LinkMetadata {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1817,34 +2608,65 @@ impl LinkMetadata {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            href: kwargs
-                .get(ruby.to_symbol("href"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            text: kwargs
-                .get(ruby.to_symbol("text"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            title: kwargs
-                .get(ruby.to_symbol("title"))
-                .and_then(|v| String::try_convert(v).ok()),
-            link_type: kwargs
-                .get(ruby.to_symbol("link_type"))
-                .and_then(|v| LinkType::try_convert(v).ok())
-                .ok_or_else(|| {
+            href: match kwargs.get(ruby.to_symbol("href")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `href`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            text: match kwargs.get(ruby.to_symbol("text")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `text`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            title: match kwargs.get(ruby.to_symbol("title")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `title`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            link_type: match kwargs.get(ruby.to_symbol("link_type")) {
+                Some(v) => LinkType::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `link_type`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: link_type",
+                    ));
+                }
+            },
+            rel: match kwargs.get(ruby.to_symbol("rel")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `rel`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            attributes: match kwargs.get(ruby.to_symbol("attributes")) {
+                Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `attributes`: {}", e),
                     )
                 })?,
-            rel: kwargs
-                .get(ruby.to_symbol("rel"))
-                .and_then(|v| <Vec<String>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            attributes: kwargs
-                .get(ruby.to_symbol("attributes"))
-                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
-                .unwrap_or_default(),
+                None => Default::default(),
+            },
         })
     }
 
@@ -1915,14 +2737,24 @@ impl MetadataEntry {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            key: kwargs
-                .get(ruby.to_symbol("key"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            value: kwargs
-                .get(ruby.to_symbol("value"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
+            key: match kwargs.get(ruby.to_symbol("key")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `key`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            value: match kwargs.get(ruby.to_symbol("value")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `value`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -1935,6 +2767,7 @@ impl MetadataEntry {
     }
 }
 
+#[cfg(feature = "visitor")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::NodeContext")]
 pub struct NodeContext {
@@ -1946,8 +2779,10 @@ pub struct NodeContext {
     is_inline: bool,
 }
 
+#[cfg(feature = "visitor")]
 unsafe impl IntoValueFromNative for NodeContext {}
 
+#[cfg(feature = "visitor")]
 impl magnus::TryConvert for NodeContext {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&NodeContext as magnus::TryConvert>::try_convert(val) {
@@ -1972,8 +2807,10 @@ impl magnus::TryConvert for NodeContext {
     }
 }
 
+#[cfg(feature = "visitor")]
 unsafe impl TryConvertOwned for NodeContext {}
 
+#[cfg(feature = "visitor")]
 impl NodeContext {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1981,34 +2818,65 @@ impl NodeContext {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            node_type: kwargs
-                .get(ruby.to_symbol("node_type"))
-                .and_then(|v| NodeType::try_convert(v).ok())
-                .ok_or_else(|| {
+            node_type: match kwargs.get(ruby.to_symbol("node_type")) {
+                Some(v) => NodeType::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `node_type`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: node_type",
+                    ));
+                }
+            },
+            tag_name: match kwargs.get(ruby.to_symbol("tag_name")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tag_name`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            depth: match kwargs.get(ruby.to_symbol("depth")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `depth`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            index_in_parent: match kwargs.get(ruby.to_symbol("index_in_parent")) {
+                Some(v) => usize::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `index_in_parent`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            parent_tag: match kwargs.get(ruby.to_symbol("parent_tag")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `parent_tag`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            is_inline: match kwargs.get(ruby.to_symbol("is_inline")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `is_inline`: {}", e),
                     )
                 })?,
-            tag_name: kwargs
-                .get(ruby.to_symbol("tag_name"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            depth: kwargs
-                .get(ruby.to_symbol("depth"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or_default(),
-            index_in_parent: kwargs
-                .get(ruby.to_symbol("index_in_parent"))
-                .and_then(|v| usize::try_convert(v).ok())
-                .unwrap_or_default(),
-            parent_tag: kwargs
-                .get(ruby.to_symbol("parent_tag"))
-                .and_then(|v| String::try_convert(v).ok()),
-            is_inline: kwargs
-                .get(ruby.to_symbol("is_inline"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or_default(),
+                None => Default::default(),
+            },
         })
     }
 
@@ -2051,7 +2919,7 @@ impl NodeContext {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, serde::Serialize)]
 #[serde(default)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptions")]
 pub struct PreprocessingOptions {
@@ -2088,6 +2956,15 @@ impl magnus::TryConvert for PreprocessingOptions {
 }
 
 unsafe impl TryConvertOwned for PreprocessingOptions {}
+impl<'de> serde::Deserialize<'de> for PreprocessingOptions {
+    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <html_to_markdown_rs::options::PreprocessingOptions as serde::Deserialize>::deserialize(deserializer)
+            .map(Into::into)
+    }
+}
 
 impl Default for PreprocessingOptions {
     fn default() -> Self {
@@ -2102,22 +2979,42 @@ impl PreprocessingOptions {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            enabled: kwargs
-                .get(ruby.to_symbol("enabled"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            preset: kwargs
-                .get(ruby.to_symbol("preset"))
-                .and_then(|v| PreprocessingPreset::try_convert(v).ok())
-                .unwrap_or(PreprocessingPreset::Standard),
-            remove_navigation: kwargs
-                .get(ruby.to_symbol("remove_navigation"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            remove_forms: kwargs
-                .get(ruby.to_symbol("remove_forms"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
+            enabled: match kwargs.get(ruby.to_symbol("enabled")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `enabled`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            preset: match kwargs.get(ruby.to_symbol("preset")) {
+                Some(v) => PreprocessingPreset::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preset`: {}", e),
+                    )
+                })?,
+                None => PreprocessingPreset::Standard,
+            },
+            remove_navigation: match kwargs.get(ruby.to_symbol("remove_navigation")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `remove_navigation`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            remove_forms: match kwargs.get(ruby.to_symbol("remove_forms")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `remove_forms`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
         })
     }
 
@@ -2189,18 +3086,42 @@ impl PreprocessingOptionsUpdate {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            enabled: kwargs
-                .get(ruby.to_symbol("enabled"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            preset: kwargs
-                .get(ruby.to_symbol("preset"))
-                .and_then(|v| PreprocessingPreset::try_convert(v).ok()),
-            remove_navigation: kwargs
-                .get(ruby.to_symbol("remove_navigation"))
-                .and_then(|v| bool::try_convert(v).ok()),
-            remove_forms: kwargs
-                .get(ruby.to_symbol("remove_forms"))
-                .and_then(|v| bool::try_convert(v).ok()),
+            enabled: match kwargs.get(ruby.to_symbol("enabled")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `enabled`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            preset: match kwargs.get(ruby.to_symbol("preset")) {
+                Some(v) => Some(PreprocessingPreset::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `preset`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            remove_navigation: match kwargs.get(ruby.to_symbol("remove_navigation")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `remove_navigation`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            remove_forms: match kwargs.get(ruby.to_symbol("remove_forms")) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `remove_forms`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -2263,19 +3184,29 @@ impl ProcessingWarning {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            message: kwargs
-                .get(ruby.to_symbol("message"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            kind: kwargs
-                .get(ruby.to_symbol("kind"))
-                .and_then(|v| WarningKind::try_convert(v).ok())
-                .ok_or_else(|| {
+            message: match kwargs.get(ruby.to_symbol("message")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
                     magnus::Error::new(
-                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
-                        "missing required field: kind",
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `message`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            kind: match kwargs.get(ruby.to_symbol("kind")) {
+                Some(v) => WarningKind::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `kind`: {}", e),
                     )
                 })?,
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: kind",
+                    ));
+                }
+            },
         })
     }
 
@@ -2288,6 +3219,7 @@ impl ProcessingWarning {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::StructuredData")]
 pub struct StructuredData {
@@ -2296,8 +3228,10 @@ pub struct StructuredData {
     schema_type: Option<String>,
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl IntoValueFromNative for StructuredData {}
 
+#[cfg(feature = "metadata")]
 impl magnus::TryConvert for StructuredData {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&StructuredData as magnus::TryConvert>::try_convert(val) {
@@ -2322,8 +3256,10 @@ impl magnus::TryConvert for StructuredData {
     }
 }
 
+#[cfg(feature = "metadata")]
 unsafe impl TryConvertOwned for StructuredData {}
 
+#[cfg(feature = "metadata")]
 impl StructuredData {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -2331,22 +3267,38 @@ impl StructuredData {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            data_type: kwargs
-                .get(ruby.to_symbol("data_type"))
-                .and_then(|v| StructuredDataType::try_convert(v).ok())
-                .ok_or_else(|| {
+            data_type: match kwargs.get(ruby.to_symbol("data_type")) {
+                Some(v) => StructuredDataType::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `data_type`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: data_type",
+                    ));
+                }
+            },
+            raw_json: match kwargs.get(ruby.to_symbol("raw_json")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `raw_json`: {}", e),
                     )
                 })?,
-            raw_json: kwargs
-                .get(ruby.to_symbol("raw_json"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            schema_type: kwargs
-                .get(ruby.to_symbol("schema_type"))
-                .and_then(|v| String::try_convert(v).ok()),
+                None => Default::default(),
+            },
+            schema_type: match kwargs.get(ruby.to_symbol("schema_type")) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `schema_type`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -2405,19 +3357,29 @@ impl TableData {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            grid: kwargs
-                .get(ruby.to_symbol("grid"))
-                .and_then(|v| TableGrid::try_convert(v).ok())
-                .ok_or_else(|| {
+            grid: match kwargs.get(ruby.to_symbol("grid")) {
+                Some(v) => TableGrid::try_convert(v).map_err(|e| {
                     magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `grid`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
                         "missing required field: grid",
+                    ));
+                }
+            },
+            markdown: match kwargs.get(ruby.to_symbol("markdown")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `markdown`: {}", e),
                     )
                 })?,
-            markdown: kwargs
-                .get(ruby.to_symbol("markdown"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
+                None => Default::default(),
+            },
         })
     }
 
@@ -2480,18 +3442,33 @@ impl TableGrid {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            rows: kwargs
-                .get(ruby.to_symbol("rows"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            cols: kwargs
-                .get(ruby.to_symbol("cols"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            cells: kwargs
-                .get(ruby.to_symbol("cells"))
-                .and_then(|v| <Vec<GridCell>>::try_convert(v).ok())
-                .unwrap_or_default(),
+            rows: match kwargs.get(ruby.to_symbol("rows")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `rows`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            cols: match kwargs.get(ruby.to_symbol("cols")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `cols`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            cells: match kwargs.get(ruby.to_symbol("cells")) {
+                Some(v) => <Vec<GridCell>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `cells`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
         })
     }
 
@@ -2551,23 +3528,38 @@ impl TextAnnotation {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            start: kwargs
-                .get(ruby.to_symbol("start"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            end: kwargs
-                .get(ruby.to_symbol("end"))
-                .and_then(|v| u32::try_convert(v).ok())
-                .unwrap_or_default(),
-            kind: kwargs
-                .get(ruby.to_symbol("kind"))
-                .and_then(|v| AnnotationKind::try_convert(v).ok())
-                .ok_or_else(|| {
+            start: match kwargs.get(ruby.to_symbol("start")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
                     magnus::Error::new(
-                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
-                        "missing required field: kind",
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `start`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            end: match kwargs.get(ruby.to_symbol("end")) {
+                Some(v) => u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `end`: {}", e),
                     )
                 })?,
+                None => Default::default(),
+            },
+            kind: match kwargs.get(ruby.to_symbol("kind")) {
+                Some(v) => AnnotationKind::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `kind`: {}", e),
+                    )
+                })?,
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: kind",
+                    ));
+                }
+            },
         })
     }
 
@@ -2584,14 +3576,17 @@ impl TextAnnotation {
     }
 }
 
+#[cfg(feature = "visitor")]
 #[derive(Clone)]
 #[magnus::wrap(class = "HtmlToMarkdownRs::VisitorHandle")]
 pub struct VisitorHandle {
     inner: Arc<html_to_markdown_rs::VisitorHandle>,
 }
 
+#[cfg(feature = "visitor")]
 unsafe impl IntoValueFromNative for VisitorHandle {}
 
+#[cfg(feature = "visitor")]
 impl magnus::TryConvert for VisitorHandle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let r: &VisitorHandle = magnus::TryConvert::try_convert(val)?;
@@ -2599,8 +3594,10 @@ impl magnus::TryConvert for VisitorHandle {
     }
 }
 
+#[cfg(feature = "visitor")]
 unsafe impl TryConvertOwned for VisitorHandle {}
 
+#[cfg(feature = "visitor")]
 impl VisitorHandle {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -3910,7 +4907,7 @@ pub fn convert(args: &[magnus::Value]) -> Result<ConversionResult, Error> {
             } else if let Ok(opts_binding) = <&ConversionOptions as magnus::TryConvert>::try_convert(v) {
                 opts_binding.clone().into()
             } else {
-                let bridge = RbHtmlVisitorBridge::new(v);
+                let bridge = RbHtmlVisitorBridge::new(v, String::new())?;
                 let handle = std::sync::Arc::new(std::sync::Mutex::new(bridge)) as html_to_markdown_rs::VisitorHandle;
                 let mut opts = html_to_markdown_rs::ConversionOptions::default();
                 opts.visitor = Some(handle);
@@ -3958,8 +4955,9 @@ impl std::fmt::Debug for RbHtmlVisitorBridge {
 }
 
 impl RbHtmlVisitorBridge {
-    pub fn new(rb_obj: magnus::Value) -> Self {
-        Self { rb_obj }
+    pub fn new(rb_obj: magnus::Value, name: String) -> Result<Self, magnus::Error> {
+        let _ = name;
+        Ok(Self { rb_obj })
     }
 }
 
@@ -5774,6 +6772,7 @@ impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
         Self {
             content: val.content,
             document: val.document.map(Into::into),
+            #[cfg(feature = "metadata")]
             metadata: val.metadata.into(),
             tables: val.tables.into_iter().map(Into::into).collect(),
             warnings: val.warnings.into_iter().map(Into::into).collect(),
@@ -5788,6 +6787,7 @@ impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
         Self {
             content: val.content.map(|v| v.to_string()),
             document: val.document.map(Into::into),
+            #[cfg(feature = "metadata")]
             metadata: val.metadata.into(),
             tables: val.tables.into_iter().map(Into::into).collect(),
             warnings: val.warnings.into_iter().map(Into::into).collect(),
@@ -5795,6 +6795,7 @@ impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata {
@@ -5820,6 +6821,7 @@ impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata
     }
 }
 
+#[cfg(feature = "metadata")]
 #[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 {
@@ -5921,6 +6923,7 @@ impl From<html_to_markdown_rs::GridCell> for GridCell {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<HeaderMetadata> for html_to_markdown_rs::metadata::HeaderMetadata {
     fn from(val: HeaderMetadata) -> Self {
         Self {
@@ -5933,6 +6936,7 @@ impl From<HeaderMetadata> for html_to_markdown_rs::metadata::HeaderMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::redundant_closure)]
 impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
     fn from(val: html_to_markdown_rs::metadata::HeaderMetadata) -> Self {
@@ -5946,29 +6950,41 @@ impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::needless_update)]
 #[allow(clippy::useless_conversion)]
 impl From<HtmlMetadata> for html_to_markdown_rs::metadata::HtmlMetadata {
     fn from(val: HtmlMetadata) -> Self {
         Self {
+            #[cfg(feature = "metadata")]
             document: val.document.into(),
+            #[cfg(feature = "metadata")]
             headers: val.headers.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             links: val.links.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             images: val.images.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             structured_data: val.structured_data.into_iter().map(Into::into).collect(),
             ..Default::default()
         }
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::useless_conversion)]
 impl From<html_to_markdown_rs::metadata::HtmlMetadata> for HtmlMetadata {
     fn from(val: html_to_markdown_rs::metadata::HtmlMetadata) -> Self {
         Self {
+            #[cfg(feature = "metadata")]
             document: val.document.into(),
+            #[cfg(feature = "metadata")]
             headers: val.headers.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             links: val.links.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             images: val.images.into_iter().map(Into::into).collect(),
+            #[cfg(feature = "metadata")]
             structured_data: val.structured_data.into_iter().map(Into::into).collect(),
         }
     }
@@ -5992,6 +7008,7 @@ impl From<html_to_markdown_rs::ImageDimensions> for ImageDimensions {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
     fn from(val: ImageMetadata) -> Self {
@@ -6006,6 +7023,7 @@ impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[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 {
@@ -6020,6 +7038,7 @@ impl From<html_to_markdown_rs::metadata::ImageMetadata> for ImageMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
     fn from(val: LinkMetadata) -> Self {
@@ -6034,6 +7053,7 @@ impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[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 {
@@ -6066,6 +7086,7 @@ impl From<html_to_markdown_rs::MetadataEntry> for MetadataEntry {
     }
 }
 
+#[cfg(feature = "visitor")]
 #[allow(clippy::useless_conversion)]
 impl From<NodeContext> for html_to_markdown_rs::NodeContext<'_> {
     fn from(val: NodeContext) -> Self {
@@ -6081,6 +7102,7 @@ impl From<NodeContext> for html_to_markdown_rs::NodeContext<'_> {
     }
 }
 
+#[cfg(feature = "visitor")]
 #[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 {
@@ -6153,6 +7175,7 @@ impl From<html_to_markdown_rs::ProcessingWarning> for ProcessingWarning {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[allow(clippy::useless_conversion)]
 impl From<StructuredData> for html_to_markdown_rs::metadata::StructuredData {
     fn from(val: StructuredData) -> Self {
@@ -6164,6 +7187,7 @@ impl From<StructuredData> for html_to_markdown_rs::metadata::StructuredData {
     }
 }
 
+#[cfg(feature = "metadata")]
 #[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 {
@@ -6338,6 +7362,7 @@ impl From<html_to_markdown_rs::options::HighlightStyle> for HighlightStyle {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<ImageType> for html_to_markdown_rs::metadata::ImageType {
     fn from(val: ImageType) -> Self {
         match val {
@@ -6349,6 +7374,7 @@ impl From<ImageType> for html_to_markdown_rs::metadata::ImageType {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<html_to_markdown_rs::metadata::ImageType> for ImageType {
     fn from(val: html_to_markdown_rs::metadata::ImageType) -> Self {
         match val {
@@ -6378,6 +7404,7 @@ impl From<html_to_markdown_rs::options::LinkStyle> for LinkStyle {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<LinkType> for html_to_markdown_rs::metadata::LinkType {
     fn from(val: LinkType) -> Self {
         match val {
@@ -6391,6 +7418,7 @@ impl From<LinkType> for html_to_markdown_rs::metadata::LinkType {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<html_to_markdown_rs::metadata::LinkType> for LinkType {
     fn from(val: html_to_markdown_rs::metadata::LinkType) -> Self {
         match val {
@@ -6528,6 +7556,7 @@ impl From<html_to_markdown_rs::NodeContent> for NodeContent {
     }
 }
 
+#[cfg(feature = "visitor")]
 impl From<NodeType> for html_to_markdown_rs::NodeType {
     fn from(val: NodeType) -> Self {
         match val {
@@ -6623,6 +7652,7 @@ impl From<NodeType> for html_to_markdown_rs::NodeType {
     }
 }
 
+#[cfg(feature = "visitor")]
 impl From<html_to_markdown_rs::NodeType> for NodeType {
     fn from(val: html_to_markdown_rs::NodeType) -> Self {
         match val {
@@ -6758,6 +7788,7 @@ impl From<html_to_markdown_rs::options::PreprocessingPreset> for PreprocessingPr
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<StructuredDataType> for html_to_markdown_rs::metadata::StructuredDataType {
     fn from(val: StructuredDataType) -> Self {
         match val {
@@ -6768,6 +7799,7 @@ impl From<StructuredDataType> for html_to_markdown_rs::metadata::StructuredDataT
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<html_to_markdown_rs::metadata::StructuredDataType> for StructuredDataType {
     fn from(val: html_to_markdown_rs::metadata::StructuredDataType) -> Self {
         match val {
@@ -6778,6 +7810,7 @@ impl From<html_to_markdown_rs::metadata::StructuredDataType> for StructuredDataT
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<TextDirection> for html_to_markdown_rs::metadata::TextDirection {
     fn from(val: TextDirection) -> Self {
         match val {
@@ -6788,6 +7821,7 @@ impl From<TextDirection> for html_to_markdown_rs::metadata::TextDirection {
     }
 }
 
+#[cfg(feature = "metadata")]
 impl From<html_to_markdown_rs::metadata::TextDirection> for TextDirection {
     fn from(val: html_to_markdown_rs::metadata::TextDirection) -> Self {
         match val {
@@ -6838,6 +7872,7 @@ impl From<html_to_markdown_rs::options::UrlEscapeStyle> for UrlEscapeStyle {
     }
 }
 
+#[cfg(feature = "visitor")]
 impl From<html_to_markdown_rs::VisitResult> for VisitResult {
     fn from(val: html_to_markdown_rs::VisitResult) -> Self {
         match val {
@@ -7141,6 +8176,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("document", method!(ConversionResult::document, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("metadata", method!(ConversionResult::metadata, 0))?;
 
     class.define_method("tables", method!(ConversionResult::tables, 0))?;
@@ -7151,28 +8187,40 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("DocumentMetadata", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(DocumentMetadata::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("title", method!(DocumentMetadata::title, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("description", method!(DocumentMetadata::description, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("keywords", method!(DocumentMetadata::keywords, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("author", method!(DocumentMetadata::author, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("canonical_url", method!(DocumentMetadata::canonical_url, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("base_href", method!(DocumentMetadata::base_href, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("language", method!(DocumentMetadata::language, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("text_direction", method!(DocumentMetadata::text_direction, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("open_graph", method!(DocumentMetadata::open_graph, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("twitter_card", method!(DocumentMetadata::twitter_card, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("meta_tags", method!(DocumentMetadata::meta_tags, 0))?;
 
     let class = module.define_class("DocumentNode", ruby.class_object())?;
@@ -7219,32 +8267,45 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("HeaderMetadata", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(HeaderMetadata::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("level", method!(HeaderMetadata::level, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("text", method!(HeaderMetadata::text, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("id", method!(HeaderMetadata::id, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("depth", method!(HeaderMetadata::depth, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("html_offset", method!(HeaderMetadata::html_offset, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("is_valid", method!(HeaderMetadata::is_valid, 0))?;
 
     let class = module.define_class("HtmlMetadata", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(HtmlMetadata::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("document", method!(HtmlMetadata::document, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("headers", method!(HtmlMetadata::headers, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("links", method!(HtmlMetadata::links, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("images", method!(HtmlMetadata::images, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("structured_data", method!(HtmlMetadata::structured_data, 0))?;
 
     let class = module.define_class("ImageDimensions", ruby.class_object())?;
@@ -7257,34 +8318,48 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("ImageMetadata", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(ImageMetadata::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("src", method!(ImageMetadata::src, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("alt", method!(ImageMetadata::alt, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("title", method!(ImageMetadata::title, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("dimensions", method!(ImageMetadata::dimensions, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("image_type", method!(ImageMetadata::image_type, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("attributes", method!(ImageMetadata::attributes, 0))?;
 
     let class = module.define_class("LinkMetadata", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(LinkMetadata::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("href", method!(LinkMetadata::href, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("text", method!(LinkMetadata::text, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("title", method!(LinkMetadata::title, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("link_type", method!(LinkMetadata::link_type, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("rel", method!(LinkMetadata::rel, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("attributes", method!(LinkMetadata::attributes, 0))?;
 
     let class = module.define_class("MetadataEntry", ruby.class_object())?;
@@ -7297,22 +8372,31 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("NodeContext", ruby.class_object())?;
 
+    #[cfg(feature = "visitor")]
     class.define_singleton_method("new", function!(NodeContext::new, -1))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("node_type", method!(NodeContext::node_type, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("tag_name", method!(NodeContext::tag_name, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("depth", method!(NodeContext::depth, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("index_in_parent", method!(NodeContext::index_in_parent, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("parent_tag", method!(NodeContext::parent_tag, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("is_inline", method!(NodeContext::is_inline, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("attributes", method!(NodeContext::attributes, 0))?;
 
+    #[cfg(feature = "visitor")]
     class.define_method("into_owned", method!(NodeContext::into_owned, 0))?;
 
     let class = module.define_class("PreprocessingOptions", ruby.class_object())?;
@@ -7352,12 +8436,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("StructuredData", ruby.class_object())?;
 
+    #[cfg(feature = "metadata")]
     class.define_singleton_method("new", function!(StructuredData::new, -1))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("data_type", method!(StructuredData::data_type, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("raw_json", method!(StructuredData::raw_json, 0))?;
 
+    #[cfg(feature = "metadata")]
     class.define_method("schema_type", method!(StructuredData::schema_type, 0))?;
 
     let class = module.define_class("TableData", ruby.class_object())?;