html-to-markdown 3.14.3 → 3.16.0

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:b89f28165748578716b78d7870c438b5394d9c847ec7718f9620057ca8fb0688
+// alef:hash:ef17e73c4a8ab3ab7874d1b469b3b0bfa02b61db141c8db6976ce5dd46217c8f
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -94,6 +94,7 @@ pub struct ConversionOptions {
     strip_tags: Vec<String>,
     preserve_tags: Vec<String>,
     skip_images: bool,
+    inline_data_media: InlineDataMedia,
     url_escape_style: UrlEscapeStyle,
     link_style: LinkStyle,
     output_format: OutputFormat,
@@ -105,6 +106,7 @@ pub struct ConversionOptions {
     max_depth: Option<usize>,
     exclude_selectors: Vec<String>,
     tier_strategy: TierStrategy,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -436,6 +438,15 @@ impl ConversionOptions {
                 })?,
                 None => false,
             },
+            inline_data_media: match kwargs.get(ruby.to_symbol("inline_data_media")) {
+                Some(v) => InlineDataMedia::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `inline_data_media`: {}", e),
+                    )
+                })?,
+                None => InlineDataMedia::Keep,
+            },
             url_escape_style: match kwargs.get(ruby.to_symbol("url_escape_style")) {
                 Some(v) => UrlEscapeStyle::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -535,6 +546,15 @@ impl ConversionOptions {
                 })?,
                 None => TierStrategy::Auto,
             },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).filter(|v| !v.is_nil()) {
+                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_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -666,6 +686,10 @@ impl ConversionOptions {
         self.skip_images
     }
 
+    fn inline_data_media(&self) -> InlineDataMedia {
+        self.inline_data_media.clone()
+    }
+
     fn url_escape_style(&self) -> UrlEscapeStyle {
         self.url_escape_style.clone()
     }
@@ -709,6 +733,10 @@ impl ConversionOptions {
     fn tier_strategy(&self) -> TierStrategy {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -747,6 +775,7 @@ pub struct ConversionOptionsUpdate {
     strip_tags: Option<Vec<String>>,
     preserve_tags: Option<Vec<String>>,
     skip_images: Option<bool>,
+    inline_data_media: Option<InlineDataMedia>,
     url_escape_style: Option<UrlEscapeStyle>,
     link_style: Option<LinkStyle>,
     output_format: Option<OutputFormat>,
@@ -758,6 +787,7 @@ pub struct ConversionOptionsUpdate {
     max_depth: Option<usize>,
     exclude_selectors: Option<Vec<String>>,
     tier_strategy: Option<TierStrategy>,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptionsUpdate {}
@@ -1092,6 +1122,15 @@ impl ConversionOptionsUpdate {
                 })?),
                 None => None,
             },
+            inline_data_media: match kwargs.get(ruby.to_symbol("inline_data_media")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(InlineDataMedia::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `inline_data_media`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             url_escape_style: match kwargs.get(ruby.to_symbol("url_escape_style")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(UrlEscapeStyle::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -1194,6 +1233,15 @@ impl ConversionOptionsUpdate {
                 })?),
                 None => None,
             },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).filter(|v| !v.is_nil()) {
+                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_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -1325,6 +1373,10 @@ impl ConversionOptionsUpdate {
         self.skip_images
     }
 
+    fn inline_data_media(&self) -> Option<InlineDataMedia> {
+        self.inline_data_media.clone()
+    }
+
     fn url_escape_style(&self) -> Option<UrlEscapeStyle> {
         self.url_escape_style.clone()
     }
@@ -1368,6 +1420,10 @@ impl ConversionOptionsUpdate {
     fn tier_strategy(&self) -> Option<TierStrategy> {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -3642,7 +3698,8 @@ impl magnus::IntoValue for AnnotationKind {
 
 impl magnus::TryConvert for AnnotationKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -3674,9 +3731,10 @@ impl magnus::TryConvert for AnnotationKind {
 
 unsafe impl IntoValueFromNative for AnnotationKind {}
 unsafe impl TryConvertOwned for AnnotationKind {}
+
 impl AnnotationKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum CodeBlockStyle {
     Indented,
     Backticks,
@@ -3702,7 +3760,14 @@ impl magnus::IntoValue for CodeBlockStyle {
 
 impl magnus::TryConvert for CodeBlockStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3721,7 +3786,7 @@ impl magnus::TryConvert for CodeBlockStyle {
 unsafe impl IntoValueFromNative for CodeBlockStyle {}
 unsafe impl TryConvertOwned for CodeBlockStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HeadingStyle {
     Underlined,
     Atx,
@@ -3747,7 +3812,14 @@ impl magnus::IntoValue for HeadingStyle {
 
 impl magnus::TryConvert for HeadingStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3766,7 +3838,7 @@ impl magnus::TryConvert for HeadingStyle {
 unsafe impl IntoValueFromNative for HeadingStyle {}
 unsafe impl TryConvertOwned for HeadingStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HighlightStyle {
     DoubleEqual,
     Html,
@@ -3794,7 +3866,14 @@ impl magnus::IntoValue for HighlightStyle {
 
 impl magnus::TryConvert for HighlightStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3814,7 +3893,7 @@ impl magnus::TryConvert for HighlightStyle {
 unsafe impl IntoValueFromNative for HighlightStyle {}
 unsafe impl TryConvertOwned for HighlightStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ImageType {
     DataUri,
@@ -3843,7 +3922,14 @@ impl magnus::IntoValue for ImageType {
 
 impl magnus::TryConvert for ImageType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3863,7 +3949,59 @@ impl magnus::TryConvert for ImageType {
 unsafe impl IntoValueFromNative for ImageType {}
 unsafe impl TryConvertOwned for ImageType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+pub enum InlineDataMedia {
+    Keep,
+    AltTextOnly,
+    DropElement,
+}
+
+impl Default for InlineDataMedia {
+    fn default() -> Self {
+        Self::Keep
+    }
+}
+
+impl magnus::IntoValue for InlineDataMedia {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            InlineDataMedia::Keep => "Keep",
+            InlineDataMedia::AltTextOnly => "AltTextOnly",
+            InlineDataMedia::DropElement => "DropElement",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for InlineDataMedia {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
+        match s.as_str() {
+            "Keep" | "keep" => Ok(InlineDataMedia::Keep),
+            "AltTextOnly" | "alt_text_only" => Ok(InlineDataMedia::AltTextOnly),
+            "DropElement" | "drop_element" => Ok(InlineDataMedia::DropElement),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid InlineDataMedia value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for InlineDataMedia {}
+unsafe impl TryConvertOwned for InlineDataMedia {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum LinkStyle {
     Inline,
     Reference,
@@ -3887,7 +4025,14 @@ impl magnus::IntoValue for LinkStyle {
 
 impl magnus::TryConvert for LinkStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3905,7 +4050,7 @@ impl magnus::TryConvert for LinkStyle {
 unsafe impl IntoValueFromNative for LinkStyle {}
 unsafe impl TryConvertOwned for LinkStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LinkType {
     Anchor,
@@ -3938,7 +4083,14 @@ impl magnus::IntoValue for LinkType {
 
 impl magnus::TryConvert for LinkType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -3960,7 +4112,7 @@ impl magnus::TryConvert for LinkType {
 unsafe impl IntoValueFromNative for LinkType {}
 unsafe impl TryConvertOwned for LinkType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ListIndentType {
     Spaces,
     Tabs,
@@ -3984,7 +4136,14 @@ impl magnus::IntoValue for ListIndentType {
 
 impl magnus::TryConvert for ListIndentType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4002,7 +4161,7 @@ impl magnus::TryConvert for ListIndentType {
 unsafe impl IntoValueFromNative for ListIndentType {}
 unsafe impl TryConvertOwned for ListIndentType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum NewlineStyle {
     Spaces,
     Backslash,
@@ -4026,7 +4185,14 @@ impl magnus::IntoValue for NewlineStyle {
 
 impl magnus::TryConvert for NewlineStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4113,7 +4279,8 @@ impl magnus::IntoValue for NodeContent {
 
 impl magnus::TryConvert for NodeContent {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -4145,9 +4312,10 @@ impl magnus::TryConvert for NodeContent {
 
 unsafe impl IntoValueFromNative for NodeContent {}
 unsafe impl TryConvertOwned for NodeContent {}
+
 impl NodeContent {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum NodeType {
     Text,
     Element,
@@ -4343,7 +4511,14 @@ impl magnus::IntoValue for NodeType {
 
 impl magnus::TryConvert for NodeType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4447,7 +4622,7 @@ impl magnus::TryConvert for NodeType {
 unsafe impl IntoValueFromNative for NodeType {}
 unsafe impl TryConvertOwned for NodeType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum OutputFormat {
     Markdown,
     Djot,
@@ -4473,7 +4648,14 @@ impl magnus::IntoValue for OutputFormat {
 
 impl magnus::TryConvert for OutputFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4492,7 +4674,7 @@ impl magnus::TryConvert for OutputFormat {
 unsafe impl IntoValueFromNative for OutputFormat {}
 unsafe impl TryConvertOwned for OutputFormat {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PreprocessingPreset {
     Minimal,
     Standard,
@@ -4518,7 +4700,14 @@ impl magnus::IntoValue for PreprocessingPreset {
 
 impl magnus::TryConvert for PreprocessingPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4537,7 +4726,7 @@ impl magnus::TryConvert for PreprocessingPreset {
 unsafe impl IntoValueFromNative for PreprocessingPreset {}
 unsafe impl TryConvertOwned for PreprocessingPreset {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum StructuredDataType {
     #[serde(rename = "json_ld")]
@@ -4566,7 +4755,14 @@ impl magnus::IntoValue for StructuredDataType {
 
 impl magnus::TryConvert for StructuredDataType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4585,7 +4781,7 @@ impl magnus::TryConvert for StructuredDataType {
 unsafe impl IntoValueFromNative for StructuredDataType {}
 unsafe impl TryConvertOwned for StructuredDataType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum TextDirection {
     #[serde(rename = "ltr")]
     LeftToRight,
@@ -4614,7 +4810,14 @@ impl magnus::IntoValue for TextDirection {
 
 impl magnus::TryConvert for TextDirection {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4633,7 +4836,7 @@ impl magnus::TryConvert for TextDirection {
 unsafe impl IntoValueFromNative for TextDirection {}
 unsafe impl TryConvertOwned for TextDirection {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TierStrategy {
     Auto,
@@ -4660,7 +4863,14 @@ impl magnus::IntoValue for TierStrategy {
 
 impl magnus::TryConvert for TierStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4679,7 +4889,7 @@ impl magnus::TryConvert for TierStrategy {
 unsafe impl IntoValueFromNative for TierStrategy {}
 unsafe impl TryConvertOwned for TierStrategy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum UrlEscapeStyle {
     Angle,
     Percent,
@@ -4703,7 +4913,14 @@ impl magnus::IntoValue for UrlEscapeStyle {
 
 impl magnus::TryConvert for UrlEscapeStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4749,7 +4966,8 @@ impl magnus::IntoValue for VisitResult {
 
 impl magnus::TryConvert for VisitResult {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -4781,6 +4999,7 @@ impl magnus::TryConvert for VisitResult {
 
 unsafe impl IntoValueFromNative for VisitResult {}
 unsafe impl TryConvertOwned for VisitResult {}
+
 impl VisitResult {
     pub fn custom(&self) -> Option<&String> {
         match self {
@@ -4796,7 +5015,7 @@ impl VisitResult {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum WarningKind {
     ImageExtractionFailed,
@@ -4829,7 +5048,14 @@ impl magnus::IntoValue for WarningKind {
 
 impl magnus::TryConvert for WarningKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -4851,7 +5077,7 @@ impl magnus::TryConvert for WarningKind {
 unsafe impl IntoValueFromNative for WarningKind {}
 unsafe impl TryConvertOwned for WarningKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum WhitespaceMode {
     Normalized,
     Strict,
@@ -4875,7 +5101,14 @@ impl magnus::IntoValue for WhitespaceMode {
 
 impl magnus::TryConvert for WhitespaceMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -6664,6 +6897,7 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             strip_tags: val.strip_tags.into_iter().collect(),
             preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            inline_data_media: val.inline_data_media.into(),
             url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
@@ -6675,12 +6909,13 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url,
             ..Default::default()
         }
     }
 }
 
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions {
     fn from(val: html_to_markdown_rs::options::ConversionOptions) -> Self {
         Self {
@@ -6716,6 +6951,7 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             strip_tags: val.strip_tags.into_iter().collect(),
             preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            inline_data_media: val.inline_data_media.into(),
             url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
@@ -6727,6 +6963,7 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url.map(|v| v.to_string()),
         }
     }
 }
@@ -6767,6 +7004,7 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             strip_tags: val.strip_tags.map(|v| v.into_iter().collect()),
             preserve_tags: val.preserve_tags.map(|v| v.into_iter().collect()),
             skip_images: val.skip_images,
+            inline_data_media: val.inline_data_media.map(Into::into),
             url_escape_style: val.url_escape_style.map(Into::into),
             link_style: val.link_style.map(Into::into),
             output_format: val.output_format.map(Into::into),
@@ -6778,6 +7016,7 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             max_depth: val.max_depth.flatten(),
             exclude_selectors: val.exclude_selectors.map(|v| v.into_iter().collect()),
             tier_strategy: val.tier_strategy.map(Into::into),
+            base_url: val.base_url.flatten().map(|v| v.to_string()),
         }
     }
 }
@@ -7403,6 +7642,26 @@ impl From<html_to_markdown_rs::metadata::ImageType> for ImageType {
     }
 }
 
+impl From<InlineDataMedia> for html_to_markdown_rs::options::InlineDataMedia {
+    fn from(val: InlineDataMedia) -> Self {
+        match val {
+            InlineDataMedia::Keep => Self::Keep,
+            InlineDataMedia::AltTextOnly => Self::AltTextOnly,
+            InlineDataMedia::DropElement => Self::DropElement,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::InlineDataMedia> for InlineDataMedia {
+    fn from(val: html_to_markdown_rs::options::InlineDataMedia) -> Self {
+        match val {
+            html_to_markdown_rs::options::InlineDataMedia::Keep => Self::Keep,
+            html_to_markdown_rs::options::InlineDataMedia::AltTextOnly => Self::AltTextOnly,
+            html_to_markdown_rs::options::InlineDataMedia::DropElement => Self::DropElement,
+        }
+    }
+}
+
 impl From<LinkStyle> for html_to_markdown_rs::options::LinkStyle {
     fn from(val: LinkStyle) -> Self {
         match val {
@@ -7889,6 +8148,19 @@ impl From<html_to_markdown_rs::options::UrlEscapeStyle> for UrlEscapeStyle {
     }
 }
 
+#[cfg(feature = "visitor")]
+impl From<VisitResult> for html_to_markdown_rs::VisitResult {
+    fn from(val: VisitResult) -> Self {
+        match val {
+            VisitResult::Continue => Self::Continue,
+            VisitResult::Custom(_0) => Self::Custom(_0),
+            VisitResult::Skip => Self::Skip,
+            VisitResult::PreserveHtml => Self::PreserveHtml,
+            VisitResult::Error(_0) => Self::Error(_0),
+        }
+    }
+}
+
 #[cfg(feature = "visitor")]
 impl From<html_to_markdown_rs::VisitResult> for VisitResult {
     fn from(val: html_to_markdown_rs::VisitResult) -> Self {
@@ -8031,6 +8303,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("skip_images", method!(ConversionOptions::skip_images, 0))?;
 
+    class.define_method("inline_data_media", method!(ConversionOptions::inline_data_media, 0))?;
+
     class.define_method("url_escape_style", method!(ConversionOptions::url_escape_style, 0))?;
 
     class.define_method("link_style", method!(ConversionOptions::link_style, 0))?;
@@ -8056,6 +8330,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tier_strategy", method!(ConversionOptions::tier_strategy, 0))?;
 
+    class.define_method("base_url", method!(ConversionOptions::base_url, 0))?;
+
     let class = module.define_class("ConversionOptionsUpdate", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ConversionOptionsUpdate::new, -1))?;
@@ -8151,6 +8427,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("skip_images", method!(ConversionOptionsUpdate::skip_images, 0))?;
 
+    class.define_method(
+        "inline_data_media",
+        method!(ConversionOptionsUpdate::inline_data_media, 0),
+    )?;
+
     class.define_method(
         "url_escape_style",
         method!(ConversionOptionsUpdate::url_escape_style, 0),
@@ -8185,6 +8466,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tier_strategy", method!(ConversionOptionsUpdate::tier_strategy, 0))?;
 
+    class.define_method("base_url", method!(ConversionOptionsUpdate::base_url, 0))?;
+
     let class = module.define_class("ConversionResult", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ConversionResult::new, -1))?;