html-to-markdown 3.4.0.pre.rc.43 → 3.4.0.pre.rc.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbdc63a4ae6c531b1f62401f4dbe888a5a042027fdae86be4901149b84f225af
-  data.tar.gz: 58a3d43a0ccc07529a099abd7886ab2a535e14c2c8463e6b456467a0636c2ecc
+  metadata.gz: d5a2e4bc34ff80125912031e6e942772c52769430f5520f8ab312222cdf099cb
+  data.tar.gz: e3985c9fa10a4507043670283f7965c2a04a92eb6073f917e48f1514b4dac428
 SHA512:
-  metadata.gz: 9ff16a6849e06e4946d87c8c4539dd477334f01cfeb9a723bd3204d6abc45c731fec908cdaaaed3a34eb9d7cb61eef94f4bb5d1a713d1039649b9a84fb060189
-  data.tar.gz: 5c77c5220ddb924cabca0977f77240ee6366ef46b630a18bcfb1d101b200f2384920594a569141fdcd24bf56f5a231b71821e8d985c046910f0119c413fdbf78
+  metadata.gz: 4a179c7450759417b24669b8bda93462f707af97183634740a687205b7a16b2ce5169daa1369f402b17a3e9ae07a124603a6c2d3ce3f7dc5c2b1832fd42559f8
+  data.tar.gz: b56307b497e4794a1dc08b9dee9d5fd61dc0df09fa9ea40a819b7b39b8b89daa658798c0b909c2030ab9472b4b72186319f4a73a2cb6fbb194f274e783943a04

data/ext/html_to_markdown_rb/Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "html-to-markdown-rb"
-version = "3.4.0-rc.43"
+version = "3.4.0-rc.44"
 edition = "2024"
 license = "MIT"
 [workspace]

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:3a1a61f25eb3b8540cdf6763b0699998f046528df3a1bd9ae0f96d6c1efae442
+// alef:hash:bbf4dbc4dd189a338ff88a6816fc1b65d7c952b6a87f2a76367ebcc321db930a
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -100,32 +100,50 @@ impl magnus::TryConvert for DocumentMetadata {
 unsafe impl TryConvertOwned for DocumentMetadata {}
 
 impl DocumentMetadata {
-    fn new(
-        keywords: Vec<String>,
-        open_graph: HashMap<String, String>,
-        twitter_card: HashMap<String, String>,
-        meta_tags: HashMap<String, String>,
-        title: Option<String>,
-        description: Option<String>,
-        author: Option<String>,
-        canonical_url: Option<String>,
-        base_href: Option<String>,
-        language: Option<String>,
-        text_direction: Option<TextDirection>,
-    ) -> Self {
-        Self {
-            title,
-            description,
-            keywords,
-            author,
-            canonical_url,
-            base_href,
-            language,
-            text_direction,
-            open_graph,
-            twitter_card,
-            meta_tags,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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(),
+        })
     }
 
     fn title(&self) -> Option<String> {
@@ -212,14 +230,32 @@ impl magnus::TryConvert for HeaderMetadata {
 unsafe impl TryConvertOwned for HeaderMetadata {}
 
 impl HeaderMetadata {
-    fn new(level: u8, text: String, depth: usize, html_offset: usize, id: Option<String>) -> Self {
-        Self {
-            level,
-            text,
-            id,
-            depth,
-            html_offset,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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(),
+        })
     }
 
     fn level(&self) -> u8 {
@@ -298,22 +334,36 @@ impl magnus::TryConvert for LinkMetadata {
 unsafe impl TryConvertOwned for LinkMetadata {}
 
 impl LinkMetadata {
-    fn new(
-        href: String,
-        text: String,
-        link_type: LinkType,
-        rel: Vec<String>,
-        attributes: HashMap<String, String>,
-        title: Option<String>,
-    ) -> Self {
-        Self {
-            href,
-            text,
-            title,
-            link_type,
-            rel,
-            attributes,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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())
+                .unwrap_or(LinkType::default()),
+            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(),
+        })
     }
 
     fn href(&self) -> String {
@@ -381,22 +431,34 @@ impl magnus::TryConvert for ImageMetadata {
 unsafe impl TryConvertOwned for ImageMetadata {}
 
 impl ImageMetadata {
-    fn new(
-        src: String,
-        image_type: ImageType,
-        attributes: HashMap<String, String>,
-        alt: Option<String>,
-        title: Option<String>,
-        dimensions: Option<Vec<u32>>,
-    ) -> Self {
-        Self {
-            src,
-            alt,
-            title,
-            dimensions,
-            image_type,
-            attributes,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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| <Vec<u32>>::try_convert(v).ok()),
+            image_type: kwargs
+                .get(ruby.to_symbol("image_type"))
+                .and_then(|v| ImageType::try_convert(v).ok())
+                .unwrap_or(ImageType::default()),
+            attributes: kwargs
+                .get(ruby.to_symbol("attributes"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn src(&self) -> String {
@@ -461,12 +523,24 @@ impl magnus::TryConvert for StructuredData {
 unsafe impl TryConvertOwned for StructuredData {}
 
 impl StructuredData {
-    fn new(data_type: StructuredDataType, raw_json: String, schema_type: Option<String>) -> Self {
-        Self {
-            data_type,
-            raw_json,
-            schema_type,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            data_type: kwargs
+                .get(ruby.to_symbol("data_type"))
+                .and_then(|v| StructuredDataType::try_convert(v).ok())
+                .unwrap_or(StructuredDataType::default()),
+            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()),
+        })
     }
 
     fn data_type(&self) -> StructuredDataType {
@@ -522,20 +596,33 @@ impl magnus::TryConvert for HtmlMetadata {
 unsafe impl TryConvertOwned for HtmlMetadata {}
 
 impl HtmlMetadata {
-    fn new(
-        document: DocumentMetadata,
-        headers: Vec<HeaderMetadata>,
-        links: Vec<LinkMetadata>,
-        images: Vec<ImageMetadata>,
-        structured_data: Vec<StructuredData>,
-    ) -> Self {
-        Self {
-            document,
-            headers,
-            links,
-            images,
-            structured_data,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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(),
+        })
     }
 
     fn document(&self) -> DocumentMetadata {
@@ -1372,13 +1459,29 @@ impl magnus::TryConvert for PreprocessingOptions {
 unsafe impl TryConvertOwned for PreprocessingOptions {}
 
 impl PreprocessingOptions {
-    fn new(enabled: bool, preset: PreprocessingPreset, remove_navigation: bool, remove_forms: bool) -> Self {
-        Self {
-            enabled,
-            preset,
-            remove_navigation,
-            remove_forms,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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_default(),
+            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),
+        })
     }
 
     fn enabled(&self) -> bool {
@@ -1442,18 +1545,25 @@ impl magnus::TryConvert for PreprocessingOptionsUpdate {
 unsafe impl TryConvertOwned for PreprocessingOptionsUpdate {}
 
 impl PreprocessingOptionsUpdate {
-    fn new(
-        enabled: Option<bool>,
-        preset: Option<PreprocessingPreset>,
-        remove_navigation: Option<bool>,
-        remove_forms: Option<bool>,
-    ) -> Self {
-        Self {
-            enabled,
-            preset,
-            remove_navigation,
-            remove_forms,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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()),
+        })
     }
 
     fn enabled(&self) -> Option<bool> {
@@ -1509,8 +1619,20 @@ impl magnus::TryConvert for DocumentStructure {
 unsafe impl TryConvertOwned for DocumentStructure {}
 
 impl DocumentStructure {
-    fn new(nodes: Vec<DocumentNode>, source_format: Option<String>) -> Self {
-        Self { nodes, source_format }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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()),
+        })
     }
 
     fn nodes(&self) -> Vec<DocumentNode> {
@@ -1562,22 +1684,35 @@ impl magnus::TryConvert for DocumentNode {
 unsafe impl TryConvertOwned for DocumentNode {}
 
 impl DocumentNode {
-    fn new(
-        id: String,
-        content: NodeContent,
-        children: Vec<u32>,
-        annotations: Vec<TextAnnotation>,
-        parent: Option<u32>,
-        attributes: Option<HashMap<String, String>>,
-    ) -> Self {
-        Self {
-            id,
-            content,
-            parent,
-            children,
-            annotations,
-            attributes,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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())
+                .unwrap_or(NodeContent::default()),
+            parent: kwargs
+                .get(ruby.to_symbol("parent"))
+                .and_then(|v| u32::try_convert(v).ok()),
+            children: kwargs
+                .get(ruby.to_symbol("children"))
+                .and_then(|v| <Vec<u32>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            annotations: kwargs
+                .get(ruby.to_symbol("annotations"))
+                .and_then(|v| <Vec<TextAnnotation>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            attributes: kwargs
+                .get(ruby.to_symbol("attributes"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok()),
+        })
     }
 
     fn id(&self) -> String {
@@ -1642,8 +1777,25 @@ impl magnus::TryConvert for TextAnnotation {
 unsafe impl TryConvertOwned for TextAnnotation {}
 
 impl TextAnnotation {
-    fn new(start: u32, end: u32, kind: AnnotationKind) -> Self {
-        Self { start, end, kind }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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())
+                .unwrap_or(AnnotationKind::default()),
+        })
     }
 
     fn start(&self) -> u32 {
@@ -1700,22 +1852,35 @@ impl magnus::TryConvert for ConversionResult {
 unsafe impl TryConvertOwned for ConversionResult {}
 
 impl ConversionResult {
-    fn new(
-        metadata: HtmlMetadata,
-        tables: Vec<TableData>,
-        images: Vec<String>,
-        warnings: Vec<ProcessingWarning>,
-        content: Option<String>,
-        document: Option<DocumentStructure>,
-    ) -> Self {
-        Self {
-            content,
-            document,
-            metadata,
-            tables,
-            images,
-            warnings,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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(),
+            images: kwargs
+                .get(ruby.to_symbol("images"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            warnings: kwargs
+                .get(ruby.to_symbol("warnings"))
+                .and_then(|v| <Vec<ProcessingWarning>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn content(&self) -> Option<String> {
@@ -1786,8 +1951,25 @@ impl magnus::TryConvert for TableGrid {
 unsafe impl TryConvertOwned for TableGrid {}
 
 impl TableGrid {
-    fn new(rows: u32, cols: u32, cells: Vec<GridCell>) -> Self {
-        Self { rows, cols, cells }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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(),
+        })
     }
 
     fn rows(&self) -> u32 {
@@ -1843,15 +2025,37 @@ impl magnus::TryConvert for GridCell {
 unsafe impl TryConvertOwned for GridCell {}
 
 impl GridCell {
-    fn new(content: String, row: u32, col: u32, row_span: u32, col_span: u32, is_header: bool) -> Self {
-        Self {
-            content,
-            row,
-            col,
-            row_span,
-            col_span,
-            is_header,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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_default(),
+            col_span: kwargs
+                .get(ruby.to_symbol("col_span"))
+                .and_then(|v| u32::try_convert(v).ok())
+                .unwrap_or_default(),
+            is_header: kwargs
+                .get(ruby.to_symbol("is_header"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn content(&self) -> String {
@@ -1920,8 +2124,21 @@ impl magnus::TryConvert for TableData {
 unsafe impl TryConvertOwned for TableData {}
 
 impl TableData {
-    fn new(grid: TableGrid, markdown: String) -> Self {
-        Self { grid, markdown }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            grid: kwargs
+                .get(ruby.to_symbol("grid"))
+                .and_then(|v| TableGrid::try_convert(v).ok())
+                .unwrap_or(TableGrid::default()),
+            markdown: kwargs
+                .get(ruby.to_symbol("markdown"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
     }
 
     fn grid(&self) -> TableGrid {
@@ -1969,8 +2186,21 @@ impl magnus::TryConvert for ProcessingWarning {
 unsafe impl TryConvertOwned for ProcessingWarning {}
 
 impl ProcessingWarning {
-    fn new(message: String, kind: WarningKind) -> Self {
-        Self { message, kind }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            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())
+                .unwrap_or(WarningKind::default()),
+        })
     }
 
     fn message(&self) -> String {
@@ -2023,24 +2253,40 @@ impl magnus::TryConvert for NodeContext {
 unsafe impl TryConvertOwned for NodeContext {}
 
 impl NodeContext {
-    fn new(
-        node_type: NodeType,
-        tag_name: String,
-        attributes: HashMap<String, String>,
-        depth: usize,
-        index_in_parent: usize,
-        is_inline: bool,
-        parent_tag: Option<String>,
-    ) -> Self {
-        Self {
-            node_type,
-            tag_name,
-            attributes,
-            depth,
-            index_in_parent,
-            parent_tag,
-            is_inline,
-        }
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            node_type: kwargs
+                .get(ruby.to_symbol("node_type"))
+                .and_then(|v| NodeType::try_convert(v).ok())
+                .unwrap_or(NodeType::default()),
+            tag_name: kwargs
+                .get(ruby.to_symbol("tag_name"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            attributes: kwargs
+                .get(ruby.to_symbol("attributes"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            depth: kwargs
+                .get(ruby.to_symbol("depth"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .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(),
+        })
     }
 
     fn node_type(&self) -> NodeType {
@@ -2118,6 +2364,7 @@ unsafe impl IntoValueFromNative for TextDirection {}
 unsafe impl TryConvertOwned for TextDirection {}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum LinkType {
     Anchor,
     Internal,
@@ -2169,6 +2416,7 @@ unsafe impl IntoValueFromNative for LinkType {}
 unsafe impl TryConvertOwned for LinkType {}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum ImageType {
     DataUri,
     InlineSvg,
@@ -2214,6 +2462,7 @@ unsafe impl IntoValueFromNative for ImageType {}
 unsafe impl TryConvertOwned for ImageType {}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum StructuredDataType {
     #[serde(rename = "json_ld")]
     JsonLd,
@@ -2628,6 +2877,7 @@ unsafe impl TryConvertOwned for OutputFormat {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "node_type")]
+#[serde(rename_all = "snake_case")]
 pub enum NodeContent {
     Heading {
         level: u8,
@@ -2695,48 +2945,29 @@ impl magnus::IntoValue for NodeContent {
 impl magnus::TryConvert for NodeContent {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
 
 unsafe impl IntoValueFromNative for NodeContent {}
 unsafe impl TryConvertOwned for NodeContent {}
-impl NodeContent {
-    fn paragraph(&self) -> Option<String> {
-        match self {
-            Self::Paragraph { text } => Some(text.clone()),
-            _ => None,
-        }
-    }
-    fn list(&self) -> Option<bool> {
-        match self {
-            Self::List { ordered } => Some(ordered.clone()),
-            _ => None,
-        }
-    }
-    fn list_item(&self) -> Option<String> {
-        match self {
-            Self::ListItem { text } => Some(text.clone()),
-            _ => None,
-        }
-    }
-    fn table(&self) -> Option<TableGrid> {
-        match self {
-            Self::Table { grid } => Some(grid.clone()),
-            _ => None,
-        }
-    }
-    fn metadata_block(&self) -> Option<Vec<String>> {
-        match self {
-            Self::MetadataBlock { entries } => Some(entries.clone()),
-            _ => None,
-        }
-    }
-}
+impl NodeContent {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "annotation_type")]
+#[serde(rename_all = "snake_case")]
 pub enum AnnotationKind {
     Bold,
     Italic,
@@ -2767,7 +2998,18 @@ impl magnus::IntoValue for AnnotationKind {
 impl magnus::TryConvert for AnnotationKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
@@ -2777,6 +3019,7 @@ unsafe impl TryConvertOwned for AnnotationKind {}
 impl AnnotationKind {}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum WarningKind {
     ImageExtractionFailed,
     EncodingFallback,
@@ -3151,27 +3394,24 @@ impl magnus::IntoValue for VisitResult {
 impl magnus::TryConvert for VisitResult {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
         serde_json::from_str(&s)
+            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&s) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
     }
 }
 
 unsafe impl IntoValueFromNative for VisitResult {}
 unsafe impl TryConvertOwned for VisitResult {}
-impl VisitResult {
-    fn custom(&self) -> Option<String> {
-        match self {
-            Self::Custom { _0 } => Some(_0.clone()),
-            _ => None,
-        }
-    }
-    fn error(&self) -> Option<String> {
-        match self {
-            Self::Error { _0 } => Some(_0.clone()),
-            _ => None,
-        }
-    }
-}
 
 #[allow(clippy::missing_errors_doc)]
 #[allow(unused_variables)]
@@ -5912,7 +6152,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("HtmlToMarkdownRs")?;
 
     let class = module.define_class("DocumentMetadata", ruby.class_object())?;
-    class.define_singleton_method("new", function!(DocumentMetadata::new, 11))?;
+    class.define_singleton_method("new", function!(DocumentMetadata::new, -1))?;
     class.define_method("title", method!(DocumentMetadata::title, 0))?;
     class.define_method("description", method!(DocumentMetadata::description, 0))?;
     class.define_method("keywords", method!(DocumentMetadata::keywords, 0))?;
@@ -5926,7 +6166,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("meta_tags", method!(DocumentMetadata::meta_tags, 0))?;
 
     let class = module.define_class("HeaderMetadata", ruby.class_object())?;
-    class.define_singleton_method("new", function!(HeaderMetadata::new, 5))?;
+    class.define_singleton_method("new", function!(HeaderMetadata::new, -1))?;
     class.define_method("level", method!(HeaderMetadata::level, 0))?;
     class.define_method("text", method!(HeaderMetadata::text, 0))?;
     class.define_method("id", method!(HeaderMetadata::id, 0))?;
@@ -5935,7 +6175,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("is_valid", method!(HeaderMetadata::is_valid, 0))?;
 
     let class = module.define_class("LinkMetadata", ruby.class_object())?;
-    class.define_singleton_method("new", function!(LinkMetadata::new, 6))?;
+    class.define_singleton_method("new", function!(LinkMetadata::new, -1))?;
     class.define_method("href", method!(LinkMetadata::href, 0))?;
     class.define_method("text", method!(LinkMetadata::text, 0))?;
     class.define_method("title", method!(LinkMetadata::title, 0))?;
@@ -5944,7 +6184,7 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("attributes", method!(LinkMetadata::attributes, 0))?;
 
     let class = module.define_class("ImageMetadata", ruby.class_object())?;
-    class.define_singleton_method("new", function!(ImageMetadata::new, 6))?;
+    class.define_singleton_method("new", function!(ImageMetadata::new, -1))?;
     class.define_method("src", method!(ImageMetadata::src, 0))?;
     class.define_method("alt", method!(ImageMetadata::alt, 0))?;
     class.define_method("title", method!(ImageMetadata::title, 0))?;
@@ -5953,13 +6193,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("attributes", method!(ImageMetadata::attributes, 0))?;
 
     let class = module.define_class("StructuredData", ruby.class_object())?;
-    class.define_singleton_method("new", function!(StructuredData::new, 3))?;
+    class.define_singleton_method("new", function!(StructuredData::new, -1))?;
     class.define_method("data_type", method!(StructuredData::data_type, 0))?;
     class.define_method("raw_json", method!(StructuredData::raw_json, 0))?;
     class.define_method("schema_type", method!(StructuredData::schema_type, 0))?;
 
     let class = module.define_class("HtmlMetadata", ruby.class_object())?;
-    class.define_singleton_method("new", function!(HtmlMetadata::new, 5))?;
+    class.define_singleton_method("new", function!(HtmlMetadata::new, -1))?;
     class.define_method("document", method!(HtmlMetadata::document, 0))?;
     class.define_method("headers", method!(HtmlMetadata::headers, 0))?;
     class.define_method("links", method!(HtmlMetadata::links, 0))?;
@@ -6095,14 +6335,14 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     )?;
 
     let class = module.define_class("PreprocessingOptions", ruby.class_object())?;
-    class.define_singleton_method("new", function!(PreprocessingOptions::new, 4))?;
+    class.define_singleton_method("new", function!(PreprocessingOptions::new, -1))?;
     class.define_method("enabled", method!(PreprocessingOptions::enabled, 0))?;
     class.define_method("preset", method!(PreprocessingOptions::preset, 0))?;
     class.define_method("remove_navigation", method!(PreprocessingOptions::remove_navigation, 0))?;
     class.define_method("remove_forms", method!(PreprocessingOptions::remove_forms, 0))?;
 
     let class = module.define_class("PreprocessingOptionsUpdate", ruby.class_object())?;
-    class.define_singleton_method("new", function!(PreprocessingOptionsUpdate::new, 4))?;
+    class.define_singleton_method("new", function!(PreprocessingOptionsUpdate::new, -1))?;
     class.define_method("enabled", method!(PreprocessingOptionsUpdate::enabled, 0))?;
     class.define_method("preset", method!(PreprocessingOptionsUpdate::preset, 0))?;
     class.define_method(
@@ -6112,12 +6352,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("remove_forms", method!(PreprocessingOptionsUpdate::remove_forms, 0))?;
 
     let class = module.define_class("DocumentStructure", ruby.class_object())?;
-    class.define_singleton_method("new", function!(DocumentStructure::new, 2))?;
+    class.define_singleton_method("new", function!(DocumentStructure::new, -1))?;
     class.define_method("nodes", method!(DocumentStructure::nodes, 0))?;
     class.define_method("source_format", method!(DocumentStructure::source_format, 0))?;
 
     let class = module.define_class("DocumentNode", ruby.class_object())?;
-    class.define_singleton_method("new", function!(DocumentNode::new, 6))?;
+    class.define_singleton_method("new", function!(DocumentNode::new, -1))?;
     class.define_method("id", method!(DocumentNode::id, 0))?;
     class.define_method("content", method!(DocumentNode::content, 0))?;
     class.define_method("parent", method!(DocumentNode::parent, 0))?;
@@ -6126,13 +6366,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("attributes", method!(DocumentNode::attributes, 0))?;
 
     let class = module.define_class("TextAnnotation", ruby.class_object())?;
-    class.define_singleton_method("new", function!(TextAnnotation::new, 3))?;
+    class.define_singleton_method("new", function!(TextAnnotation::new, -1))?;
     class.define_method("start", method!(TextAnnotation::start, 0))?;
     class.define_method("end", method!(TextAnnotation::end, 0))?;
     class.define_method("kind", method!(TextAnnotation::kind, 0))?;
 
     let class = module.define_class("ConversionResult", ruby.class_object())?;
-    class.define_singleton_method("new", function!(ConversionResult::new, 6))?;
+    class.define_singleton_method("new", function!(ConversionResult::new, -1))?;
     class.define_method("content", method!(ConversionResult::content, 0))?;
     class.define_method("document", method!(ConversionResult::document, 0))?;
     class.define_method("metadata", method!(ConversionResult::metadata, 0))?;
@@ -6142,13 +6382,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("to_s", method!(ConversionResult::to_s, 0))?;
 
     let class = module.define_class("TableGrid", ruby.class_object())?;
-    class.define_singleton_method("new", function!(TableGrid::new, 3))?;
+    class.define_singleton_method("new", function!(TableGrid::new, -1))?;
     class.define_method("rows", method!(TableGrid::rows, 0))?;
     class.define_method("cols", method!(TableGrid::cols, 0))?;
     class.define_method("cells", method!(TableGrid::cells, 0))?;
 
     let class = module.define_class("GridCell", ruby.class_object())?;
-    class.define_singleton_method("new", function!(GridCell::new, 6))?;
+    class.define_singleton_method("new", function!(GridCell::new, -1))?;
     class.define_method("content", method!(GridCell::content, 0))?;
     class.define_method("row", method!(GridCell::row, 0))?;
     class.define_method("col", method!(GridCell::col, 0))?;
@@ -6158,17 +6398,17 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("to_s", method!(GridCell::to_s, 0))?;
 
     let class = module.define_class("TableData", ruby.class_object())?;
-    class.define_singleton_method("new", function!(TableData::new, 2))?;
+    class.define_singleton_method("new", function!(TableData::new, -1))?;
     class.define_method("grid", method!(TableData::grid, 0))?;
     class.define_method("markdown", method!(TableData::markdown, 0))?;
 
     let class = module.define_class("ProcessingWarning", ruby.class_object())?;
-    class.define_singleton_method("new", function!(ProcessingWarning::new, 2))?;
+    class.define_singleton_method("new", function!(ProcessingWarning::new, -1))?;
     class.define_method("message", method!(ProcessingWarning::message, 0))?;
     class.define_method("kind", method!(ProcessingWarning::kind, 0))?;
 
     let class = module.define_class("NodeContext", ruby.class_object())?;
-    class.define_singleton_method("new", function!(NodeContext::new, 7))?;
+    class.define_singleton_method("new", function!(NodeContext::new, -1))?;
     class.define_method("node_type", method!(NodeContext::node_type, 0))?;
     class.define_method("tag_name", method!(NodeContext::tag_name, 0))?;
     class.define_method("attributes", method!(NodeContext::attributes, 0))?;

data/lib/html_to_markdown/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:cc45dd331b1ce70dafcc656c39fd0b0dd3457b2beaa8b4be0b9243d0e205a361
+# alef:hash:1bd3c99db21c2ca078644f1e220656297c784bcca532f13d3b7efed3f45dbb0b
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
@@ -18,3 +18,38 @@ module HtmlToMarkdown
     const_set(c, HtmlToMarkdownRs.const_get(c)) unless const_defined?(c)
   end
 end
+
+# Add accessor methods to Hash-based internally-tagged enum instances
+class Hash
+  # Support internally-tagged enum accessors like format.excel, format.email, etc.
+  # Also support direct field access like format.sheet_count
+  def method_missing(method_name, *args, &)
+    # Try symbol key first (how Magnus converts JSON keys)
+    return self[method_name] if key?(method_name)
+
+    # Try string key
+    return self[method_name.to_s] if key?(method_name.to_s)
+
+    # Check if this hash has a 'format_type' field (indicating an internally-tagged enum)
+    format_type = self[:format_type] || self['format_type']
+    return super unless format_type
+
+    # If the method name matches the format_type (snake_case), extract and return the variant's wrapped data
+    # Internally-tagged enums store variant data in the '_0' field (from alef's struct variant conversion)
+    # This allows format.excel to return the ExcelMetadata hash with sheet_count, sheet_names, etc.
+    snake_case_method = method_name.to_s.downcase
+    return self[:_0] || self['_0'] || self if snake_case_method == format_type.to_s.downcase
+
+    super
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    return true if key?(method_name) || key?(method_name.to_s)
+
+    format_type = self[:format_type] || self['format_type']
+    return false unless format_type
+
+    snake_case_method = method_name.to_s.downcase
+    snake_case_method == format_type.to_s.downcase || super
+  end
+end

data/lib/html_to_markdown/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:0f94527b64db68a5f23ef7f6f5a002fb4129c500d20cc9c076bc8fa24d80a4c7
+# alef:hash:4ce3ba64cbea5c72b082111f57a04e219e555fda52859a9673edcec555031706
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # Issues & docs: https://github.com/kreuzberg-dev/alef
 # frozen_string_literal: true
 
 module HtmlToMarkdown
-  VERSION = '3.4.0.pre.rc.43'
+  VERSION = '3.4.0.pre.rc.44'
 end

data/vendor/Cargo.toml

@@ -3,7 +3,7 @@ members = ["html-to-markdown-rs"]
 resolver = "2"
 
 [workspace.package]
-version = "3.4.0-rc.43"
+version = "3.4.0-rc.44"
 edition = "2024"
 rust-version = "1.85"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]

data/vendor/html-to-markdown-rs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "html-to-markdown-rs"
-version = "3.4.0-rc.43"
+version = "3.4.0-rc.44"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
 license = "MIT"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: html-to-markdown
 version: !ruby/object:Gem::Version
-  version: 3.4.0.pre.rc.43
+  version: 3.4.0.pre.rc.44
 platform: ruby
 authors:
 - Kreuzberg Team