html-to-markdown 3.11.3 → 3.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 447e59bfe07f836896259e01a17eaf3a326cef730a010403de8e1e6735aba1df
-  data.tar.gz: 017aebcbf2e862ad92bbdbc632275568048acab0532e7861cc94a068b02ef412
+  metadata.gz: 725f95c084c2927a971291f61acc278f9527f003c1526b0ab8296a2976b61a4f
+  data.tar.gz: 9a1bfb2d18068023fc403d3ab98a215136928de7313c98addc36b07eac41cfa2
 SHA512:
-  metadata.gz: 711550a702d49f4f5689fbc4e39f8e572b98a6fb7f7d01f3a269a8bd25c74072dd5f4ba826a543d35e216f3466b3f55ff54a0fac1403bb7aaa03ddebd34bde52
-  data.tar.gz: b6ee6612af506c3750956f94e0b16eefc63f3f7785fab7b554f829e34eccf485014279c9bc16f6affd536576f949d3967e1d78893f1b2ec65f2bd779ba9436e3
+  metadata.gz: f345c49b07ae565e5fbdcbc9ef717ad2b925d8dde399b0cd2a2136abe1f276947d9714a14243aba87ca1ad2df4c30a4d097b30c124453ae7850b39d1df15bdb9
+  data.tar.gz: 1b5d3c8553eafe15c8f78feb575817ad6089b31ba6bd5b5e2cb821024f99bc2cb390a4c8ff07f0faf91935ee29740eca9bce2d03cf728cf4ef859a2dbd0c9c7d

data/ext/html_to_markdown_rb/Cargo.lock

@@ -220,7 +220,7 @@ checksum = "c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5"
 
 [[package]]
 name = "html-to-markdown-rb"
-version = "3.11.3"
+version = "3.11.4"
 dependencies = [
  "html-to-markdown-rs",
  "magnus",
@@ -230,7 +230,7 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-rs"
-version = "3.11.3"
+version = "3.11.4"
 dependencies = [
  "ahash",
  "astral-tl",

data/ext/html_to_markdown_rb/Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "html-to-markdown-rb"
-version = "3.11.3"
+version = "3.11.4"
 edition = "2024"
 license = "MIT"
 [workspace]

data/ext/html_to_markdown_rb/native/Cargo.lock

@@ -231,7 +231,7 @@ checksum = "c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5"
 
 [[package]]
 name = "html-to-markdown-rb"
-version = "3.11.3"
+version = "3.11.4"
 dependencies = [
  "async-trait",
  "html-to-markdown-rs",
@@ -245,9 +245,9 @@ dependencies = [
 
 [[package]]
 name = "html-to-markdown-rs"
-version = "3.11.3"
+version = "3.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "187d8352a854d055faf1e6574bd14d8c3e429a1c1a73462793155ce63a845fb4"
+checksum = "6331a4c21bc99309e5863092660c08505c426eb1158e0472013487ecff85412b"
 dependencies = [
  "ahash",
  "astral-tl",
@@ -624,9 +624,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",

data/ext/html_to_markdown_rb/native/Cargo.toml

@@ -1,11 +1,11 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:3614fdee5f37403e9532afc6f2778ed2152452357c8d86df4222e6bc4d6f6f24
+# alef:hash:06c8275faa8db108254aad522dcfcb86aa7d3c7209c0aec1e0b2d31b7e3fead9
 # To regenerate: alef generate
 # To verify freshness: alef verify
 
 [package]
 name = "html-to-markdown-rb"
-version = "3.11.3"
+version = "3.11.4"
 edition = "2024"
 license = "MIT"
 description = "High-performance HTML to Markdown converter"
@@ -30,7 +30,7 @@ visitor = ["html-to-markdown-rs/visitor"]
 
 [dependencies]
 async-trait = "0.1"
-html-to-markdown-rs = { version = "3.11.3", features = ["serde", "metadata", "visitor", "inline-images", "testkit"] }
+html-to-markdown-rs = { version = "3.11.4", features = ["serde", "metadata", "visitor", "inline-images", "testkit"] }
 magnus = "0.8"
 rb-sys = ">=0.9, <0.9.128"
 serde = { version = "1", features = ["derive"] }

data/ext/html_to_markdown_rb/native/extconf.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:0327a758be5bdf792bfbfe00fabafa0521b9b859671b2c15f04fafd77d8ec92f
+# alef:hash:c13c87de19810ef6f27d80e6a007ea57b79b0566cea4e2e4e835b459d757e036
 # To regenerate: alef generate
 # To verify freshness: alef verify
 

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:f83407e5f086cd80e200a7c9fb3b913b47675e2ef66228f1198b91cdb6213596
+// alef:hash:8567b1374b02f8c55dcc16b8f3ee9b74e21d22fe4a19cda88f345b87da27a730
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -2647,8 +2647,8 @@ impl Default for TextDirection {
 impl magnus::IntoValue for TextDirection {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            TextDirection::LeftToRight => "left_to_right",
-            TextDirection::RightToLeft => "right_to_left",
+            TextDirection::LeftToRight => "ltr",
+            TextDirection::RightToLeft => "rtl",
             TextDirection::Auto => "auto",
         };
         handle.to_symbol(sym).into_value_with(handle)
@@ -2658,11 +2658,12 @@ impl magnus::IntoValue for TextDirection {
 impl magnus::TryConvert for TextDirection {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "left_to_right" | "LeftToRight" => Ok(TextDirection::LeftToRight),
-            "right_to_left" | "RightToLeft" => Ok(TextDirection::RightToLeft),
+            "ltr" | "left_to_right" | "LeftToRight" => Ok(TextDirection::LeftToRight),
+            "rtl" | "right_to_left" | "RightToLeft" => Ok(TextDirection::RightToLeft),
             "auto" | "Auto" => Ok(TextDirection::Auto),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
@@ -2709,8 +2710,9 @@ impl magnus::IntoValue for LinkType {
 impl magnus::TryConvert for LinkType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
             "anchor" | "Anchor" => Ok(LinkType::Anchor),
             "internal" | "Internal" => Ok(LinkType::Internal),
@@ -2759,8 +2761,9 @@ impl magnus::IntoValue for ImageType {
 impl magnus::TryConvert for ImageType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
             "data_uri" | "DataUri" => Ok(ImageType::DataUri),
             "inline_svg" | "InlineSvg" => Ok(ImageType::InlineSvg),
@@ -2798,7 +2801,7 @@ impl magnus::IntoValue for StructuredDataType {
         let sym = match self {
             StructuredDataType::JsonLd => "json_ld",
             StructuredDataType::Microdata => "microdata",
-            StructuredDataType::RDFa => "rd_fa",
+            StructuredDataType::RDFa => "rdfa",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2807,12 +2810,13 @@ impl magnus::IntoValue for StructuredDataType {
 impl magnus::TryConvert for StructuredDataType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
             "json_ld" | "JsonLd" => Ok(StructuredDataType::JsonLd),
             "microdata" | "Microdata" => Ok(StructuredDataType::Microdata),
-            "rd_fa" | "RDFa" => Ok(StructuredDataType::RDFa),
+            "rdfa" | "rd_fa" | "RDFa" => Ok(StructuredDataType::RDFa),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid StructuredDataType value: {other}"),
@@ -2852,8 +2856,9 @@ 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)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
             "auto" | "Auto" => Ok(TierStrategy::Auto),
             "tier2" | "Tier2" => Ok(TierStrategy::Tier2),
@@ -2885,9 +2890,9 @@ impl Default for PreprocessingPreset {
 impl magnus::IntoValue for PreprocessingPreset {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            PreprocessingPreset::Minimal => "minimal",
-            PreprocessingPreset::Standard => "standard",
-            PreprocessingPreset::Aggressive => "aggressive",
+            PreprocessingPreset::Minimal => "Minimal",
+            PreprocessingPreset::Standard => "Standard",
+            PreprocessingPreset::Aggressive => "Aggressive",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2896,12 +2901,13 @@ impl magnus::IntoValue for PreprocessingPreset {
 impl magnus::TryConvert for PreprocessingPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "minimal" | "Minimal" => Ok(PreprocessingPreset::Minimal),
-            "standard" | "Standard" => Ok(PreprocessingPreset::Standard),
-            "aggressive" | "Aggressive" => Ok(PreprocessingPreset::Aggressive),
+            "Minimal" | "minimal" => Ok(PreprocessingPreset::Minimal),
+            "Standard" | "standard" => Ok(PreprocessingPreset::Standard),
+            "Aggressive" | "aggressive" => Ok(PreprocessingPreset::Aggressive),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid PreprocessingPreset value: {other}"),
@@ -2929,9 +2935,9 @@ impl Default for HeadingStyle {
 impl magnus::IntoValue for HeadingStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            HeadingStyle::Underlined => "underlined",
-            HeadingStyle::Atx => "atx",
-            HeadingStyle::AtxClosed => "atx_closed",
+            HeadingStyle::Underlined => "Underlined",
+            HeadingStyle::Atx => "Atx",
+            HeadingStyle::AtxClosed => "AtxClosed",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2940,12 +2946,13 @@ impl magnus::IntoValue for HeadingStyle {
 impl magnus::TryConvert for HeadingStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "underlined" | "Underlined" => Ok(HeadingStyle::Underlined),
-            "atx" | "Atx" => Ok(HeadingStyle::Atx),
-            "atx_closed" | "AtxClosed" => Ok(HeadingStyle::AtxClosed),
+            "Underlined" | "underlined" => Ok(HeadingStyle::Underlined),
+            "Atx" | "atx" => Ok(HeadingStyle::Atx),
+            "AtxClosed" | "atx_closed" => Ok(HeadingStyle::AtxClosed),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid HeadingStyle value: {other}"),
@@ -2972,8 +2979,8 @@ impl Default for ListIndentType {
 impl magnus::IntoValue for ListIndentType {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            ListIndentType::Spaces => "spaces",
-            ListIndentType::Tabs => "tabs",
+            ListIndentType::Spaces => "Spaces",
+            ListIndentType::Tabs => "Tabs",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -2982,11 +2989,12 @@ impl magnus::IntoValue for ListIndentType {
 impl magnus::TryConvert for ListIndentType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "spaces" | "Spaces" => Ok(ListIndentType::Spaces),
-            "tabs" | "Tabs" => Ok(ListIndentType::Tabs),
+            "Spaces" | "spaces" => Ok(ListIndentType::Spaces),
+            "Tabs" | "tabs" => Ok(ListIndentType::Tabs),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ListIndentType value: {other}"),
@@ -3013,8 +3021,8 @@ impl Default for WhitespaceMode {
 impl magnus::IntoValue for WhitespaceMode {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            WhitespaceMode::Normalized => "normalized",
-            WhitespaceMode::Strict => "strict",
+            WhitespaceMode::Normalized => "Normalized",
+            WhitespaceMode::Strict => "Strict",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3023,11 +3031,12 @@ impl magnus::IntoValue for WhitespaceMode {
 impl magnus::TryConvert for WhitespaceMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "normalized" | "Normalized" => Ok(WhitespaceMode::Normalized),
-            "strict" | "Strict" => Ok(WhitespaceMode::Strict),
+            "Normalized" | "normalized" => Ok(WhitespaceMode::Normalized),
+            "Strict" | "strict" => Ok(WhitespaceMode::Strict),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid WhitespaceMode value: {other}"),
@@ -3054,8 +3063,8 @@ impl Default for NewlineStyle {
 impl magnus::IntoValue for NewlineStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            NewlineStyle::Spaces => "spaces",
-            NewlineStyle::Backslash => "backslash",
+            NewlineStyle::Spaces => "Spaces",
+            NewlineStyle::Backslash => "Backslash",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3064,11 +3073,12 @@ impl magnus::IntoValue for NewlineStyle {
 impl magnus::TryConvert for NewlineStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "spaces" | "Spaces" => Ok(NewlineStyle::Spaces),
-            "backslash" | "Backslash" => Ok(NewlineStyle::Backslash),
+            "Spaces" | "spaces" => Ok(NewlineStyle::Spaces),
+            "Backslash" | "backslash" => Ok(NewlineStyle::Backslash),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid NewlineStyle value: {other}"),
@@ -3096,9 +3106,9 @@ impl Default for CodeBlockStyle {
 impl magnus::IntoValue for CodeBlockStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            CodeBlockStyle::Indented => "indented",
-            CodeBlockStyle::Backticks => "backticks",
-            CodeBlockStyle::Tildes => "tildes",
+            CodeBlockStyle::Indented => "Indented",
+            CodeBlockStyle::Backticks => "Backticks",
+            CodeBlockStyle::Tildes => "Tildes",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3107,12 +3117,13 @@ impl magnus::IntoValue for CodeBlockStyle {
 impl magnus::TryConvert for CodeBlockStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "indented" | "Indented" => Ok(CodeBlockStyle::Indented),
-            "backticks" | "Backticks" => Ok(CodeBlockStyle::Backticks),
-            "tildes" | "Tildes" => Ok(CodeBlockStyle::Tildes),
+            "Indented" | "indented" => Ok(CodeBlockStyle::Indented),
+            "Backticks" | "backticks" => Ok(CodeBlockStyle::Backticks),
+            "Tildes" | "tildes" => Ok(CodeBlockStyle::Tildes),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid CodeBlockStyle value: {other}"),
@@ -3141,10 +3152,10 @@ impl Default for HighlightStyle {
 impl magnus::IntoValue for HighlightStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            HighlightStyle::DoubleEqual => "double_equal",
-            HighlightStyle::Html => "html",
-            HighlightStyle::Bold => "bold",
-            HighlightStyle::None => "none",
+            HighlightStyle::DoubleEqual => "DoubleEqual",
+            HighlightStyle::Html => "Html",
+            HighlightStyle::Bold => "Bold",
+            HighlightStyle::None => "None",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3153,13 +3164,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)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "double_equal" | "DoubleEqual" => Ok(HighlightStyle::DoubleEqual),
-            "html" | "Html" => Ok(HighlightStyle::Html),
-            "bold" | "Bold" => Ok(HighlightStyle::Bold),
-            "none" | "None" => Ok(HighlightStyle::None),
+            "DoubleEqual" | "double_equal" => Ok(HighlightStyle::DoubleEqual),
+            "Html" | "html" => Ok(HighlightStyle::Html),
+            "Bold" | "bold" => Ok(HighlightStyle::Bold),
+            "None" | "none" => Ok(HighlightStyle::None),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid HighlightStyle value: {other}"),
@@ -3186,8 +3198,8 @@ impl Default for LinkStyle {
 impl magnus::IntoValue for LinkStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            LinkStyle::Inline => "inline",
-            LinkStyle::Reference => "reference",
+            LinkStyle::Inline => "Inline",
+            LinkStyle::Reference => "Reference",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3196,11 +3208,12 @@ impl magnus::IntoValue for LinkStyle {
 impl magnus::TryConvert for LinkStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "inline" | "Inline" => Ok(LinkStyle::Inline),
-            "reference" | "Reference" => Ok(LinkStyle::Reference),
+            "Inline" | "inline" => Ok(LinkStyle::Inline),
+            "Reference" | "reference" => Ok(LinkStyle::Reference),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid LinkStyle value: {other}"),
@@ -3227,8 +3240,8 @@ impl Default for UrlEscapeStyle {
 impl magnus::IntoValue for UrlEscapeStyle {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            UrlEscapeStyle::Angle => "angle",
-            UrlEscapeStyle::Percent => "percent",
+            UrlEscapeStyle::Angle => "Angle",
+            UrlEscapeStyle::Percent => "Percent",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3237,11 +3250,12 @@ 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)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "angle" | "Angle" => Ok(UrlEscapeStyle::Angle),
-            "percent" | "Percent" => Ok(UrlEscapeStyle::Percent),
+            "Angle" | "angle" => Ok(UrlEscapeStyle::Angle),
+            "Percent" | "percent" => Ok(UrlEscapeStyle::Percent),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid UrlEscapeStyle value: {other}"),
@@ -3269,9 +3283,9 @@ impl Default for OutputFormat {
 impl magnus::IntoValue for OutputFormat {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            OutputFormat::Markdown => "markdown",
-            OutputFormat::Djot => "djot",
-            OutputFormat::Plain => "plain",
+            OutputFormat::Markdown => "Markdown",
+            OutputFormat::Djot => "Djot",
+            OutputFormat::Plain => "Plain",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3280,12 +3294,13 @@ 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)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "markdown" | "Markdown" => Ok(OutputFormat::Markdown),
-            "djot" | "Djot" => Ok(OutputFormat::Djot),
-            "plain" | "Plain" => Ok(OutputFormat::Plain),
+            "Markdown" | "markdown" => Ok(OutputFormat::Markdown),
+            "Djot" | "djot" => Ok(OutputFormat::Djot),
+            "Plain" | "plain" => Ok(OutputFormat::Plain),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid OutputFormat value: {other}"),
@@ -3500,8 +3515,9 @@ impl magnus::IntoValue for WarningKind {
 impl magnus::TryConvert for WarningKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
             "image_extraction_failed" | "ImageExtractionFailed" => Ok(WarningKind::ImageExtractionFailed),
             "encoding_fallback" | "EncodingFallback" => Ok(WarningKind::EncodingFallback),
@@ -3621,94 +3637,94 @@ impl Default for NodeType {
 impl magnus::IntoValue for NodeType {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            NodeType::Text => "text",
-            NodeType::Element => "element",
-            NodeType::Heading => "heading",
-            NodeType::Paragraph => "paragraph",
-            NodeType::Div => "div",
-            NodeType::Blockquote => "blockquote",
-            NodeType::Pre => "pre",
-            NodeType::Hr => "hr",
-            NodeType::List => "list",
-            NodeType::ListItem => "list_item",
-            NodeType::DefinitionList => "definition_list",
-            NodeType::DefinitionTerm => "definition_term",
-            NodeType::DefinitionDescription => "definition_description",
-            NodeType::Table => "table",
-            NodeType::TableRow => "table_row",
-            NodeType::TableCell => "table_cell",
-            NodeType::TableHeader => "table_header",
-            NodeType::TableBody => "table_body",
-            NodeType::TableHead => "table_head",
-            NodeType::TableFoot => "table_foot",
-            NodeType::Link => "link",
-            NodeType::Image => "image",
-            NodeType::Strong => "strong",
-            NodeType::Em => "em",
-            NodeType::Code => "code",
-            NodeType::Strikethrough => "strikethrough",
-            NodeType::Underline => "underline",
-            NodeType::Subscript => "subscript",
-            NodeType::Superscript => "superscript",
-            NodeType::Mark => "mark",
-            NodeType::Small => "small",
-            NodeType::Br => "br",
-            NodeType::Span => "span",
-            NodeType::Article => "article",
-            NodeType::Section => "section",
-            NodeType::Nav => "nav",
-            NodeType::Aside => "aside",
-            NodeType::Header => "header",
-            NodeType::Footer => "footer",
-            NodeType::Main => "main",
-            NodeType::Figure => "figure",
-            NodeType::Figcaption => "figcaption",
-            NodeType::Time => "time",
-            NodeType::Details => "details",
-            NodeType::Summary => "summary",
-            NodeType::Form => "form",
-            NodeType::Input => "input",
-            NodeType::Select => "select",
-            NodeType::Option => "option",
-            NodeType::Button => "button",
-            NodeType::Textarea => "textarea",
-            NodeType::Label => "label",
-            NodeType::Fieldset => "fieldset",
-            NodeType::Legend => "legend",
-            NodeType::Audio => "audio",
-            NodeType::Video => "video",
-            NodeType::Picture => "picture",
-            NodeType::Source => "source",
-            NodeType::Iframe => "iframe",
-            NodeType::Svg => "svg",
-            NodeType::Canvas => "canvas",
-            NodeType::Ruby => "ruby",
-            NodeType::Rt => "rt",
-            NodeType::Rp => "rp",
-            NodeType::Abbr => "abbr",
-            NodeType::Kbd => "kbd",
-            NodeType::Samp => "samp",
-            NodeType::Var => "var",
-            NodeType::Cite => "cite",
-            NodeType::Q => "q",
-            NodeType::Del => "del",
-            NodeType::Ins => "ins",
-            NodeType::Data => "data",
-            NodeType::Meter => "meter",
-            NodeType::Progress => "progress",
-            NodeType::Output => "output",
-            NodeType::Template => "template",
-            NodeType::Slot => "slot",
-            NodeType::Html => "html",
-            NodeType::Head => "head",
-            NodeType::Body => "body",
-            NodeType::Title => "title",
-            NodeType::Meta => "meta",
-            NodeType::LinkTag => "link_tag",
-            NodeType::Style => "style",
-            NodeType::Script => "script",
-            NodeType::Base => "base",
-            NodeType::Custom => "custom",
+            NodeType::Text => "Text",
+            NodeType::Element => "Element",
+            NodeType::Heading => "Heading",
+            NodeType::Paragraph => "Paragraph",
+            NodeType::Div => "Div",
+            NodeType::Blockquote => "Blockquote",
+            NodeType::Pre => "Pre",
+            NodeType::Hr => "Hr",
+            NodeType::List => "List",
+            NodeType::ListItem => "ListItem",
+            NodeType::DefinitionList => "DefinitionList",
+            NodeType::DefinitionTerm => "DefinitionTerm",
+            NodeType::DefinitionDescription => "DefinitionDescription",
+            NodeType::Table => "Table",
+            NodeType::TableRow => "TableRow",
+            NodeType::TableCell => "TableCell",
+            NodeType::TableHeader => "TableHeader",
+            NodeType::TableBody => "TableBody",
+            NodeType::TableHead => "TableHead",
+            NodeType::TableFoot => "TableFoot",
+            NodeType::Link => "Link",
+            NodeType::Image => "Image",
+            NodeType::Strong => "Strong",
+            NodeType::Em => "Em",
+            NodeType::Code => "Code",
+            NodeType::Strikethrough => "Strikethrough",
+            NodeType::Underline => "Underline",
+            NodeType::Subscript => "Subscript",
+            NodeType::Superscript => "Superscript",
+            NodeType::Mark => "Mark",
+            NodeType::Small => "Small",
+            NodeType::Br => "Br",
+            NodeType::Span => "Span",
+            NodeType::Article => "Article",
+            NodeType::Section => "Section",
+            NodeType::Nav => "Nav",
+            NodeType::Aside => "Aside",
+            NodeType::Header => "Header",
+            NodeType::Footer => "Footer",
+            NodeType::Main => "Main",
+            NodeType::Figure => "Figure",
+            NodeType::Figcaption => "Figcaption",
+            NodeType::Time => "Time",
+            NodeType::Details => "Details",
+            NodeType::Summary => "Summary",
+            NodeType::Form => "Form",
+            NodeType::Input => "Input",
+            NodeType::Select => "Select",
+            NodeType::Option => "Option",
+            NodeType::Button => "Button",
+            NodeType::Textarea => "Textarea",
+            NodeType::Label => "Label",
+            NodeType::Fieldset => "Fieldset",
+            NodeType::Legend => "Legend",
+            NodeType::Audio => "Audio",
+            NodeType::Video => "Video",
+            NodeType::Picture => "Picture",
+            NodeType::Source => "Source",
+            NodeType::Iframe => "Iframe",
+            NodeType::Svg => "Svg",
+            NodeType::Canvas => "Canvas",
+            NodeType::Ruby => "Ruby",
+            NodeType::Rt => "Rt",
+            NodeType::Rp => "Rp",
+            NodeType::Abbr => "Abbr",
+            NodeType::Kbd => "Kbd",
+            NodeType::Samp => "Samp",
+            NodeType::Var => "Var",
+            NodeType::Cite => "Cite",
+            NodeType::Q => "Q",
+            NodeType::Del => "Del",
+            NodeType::Ins => "Ins",
+            NodeType::Data => "Data",
+            NodeType::Meter => "Meter",
+            NodeType::Progress => "Progress",
+            NodeType::Output => "Output",
+            NodeType::Template => "Template",
+            NodeType::Slot => "Slot",
+            NodeType::Html => "Html",
+            NodeType::Head => "Head",
+            NodeType::Body => "Body",
+            NodeType::Title => "Title",
+            NodeType::Meta => "Meta",
+            NodeType::LinkTag => "LinkTag",
+            NodeType::Style => "Style",
+            NodeType::Script => "Script",
+            NodeType::Base => "Base",
+            NodeType::Custom => "Custom",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -3717,97 +3733,98 @@ impl magnus::IntoValue for NodeType {
 impl magnus::TryConvert for NodeType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
-        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
-        // and a lowercase fallback so fixtures written in any of those styles work.
+        // 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() {
-            "text" | "Text" => Ok(NodeType::Text),
-            "element" | "Element" => Ok(NodeType::Element),
-            "heading" | "Heading" => Ok(NodeType::Heading),
-            "paragraph" | "Paragraph" => Ok(NodeType::Paragraph),
-            "div" | "Div" => Ok(NodeType::Div),
-            "blockquote" | "Blockquote" => Ok(NodeType::Blockquote),
-            "pre" | "Pre" => Ok(NodeType::Pre),
-            "hr" | "Hr" => Ok(NodeType::Hr),
-            "list" | "List" => Ok(NodeType::List),
-            "list_item" | "ListItem" => Ok(NodeType::ListItem),
-            "definition_list" | "DefinitionList" => Ok(NodeType::DefinitionList),
-            "definition_term" | "DefinitionTerm" => Ok(NodeType::DefinitionTerm),
-            "definition_description" | "DefinitionDescription" => Ok(NodeType::DefinitionDescription),
-            "table" | "Table" => Ok(NodeType::Table),
-            "table_row" | "TableRow" => Ok(NodeType::TableRow),
-            "table_cell" | "TableCell" => Ok(NodeType::TableCell),
-            "table_header" | "TableHeader" => Ok(NodeType::TableHeader),
-            "table_body" | "TableBody" => Ok(NodeType::TableBody),
-            "table_head" | "TableHead" => Ok(NodeType::TableHead),
-            "table_foot" | "TableFoot" => Ok(NodeType::TableFoot),
-            "link" | "Link" => Ok(NodeType::Link),
-            "image" | "Image" => Ok(NodeType::Image),
-            "strong" | "Strong" => Ok(NodeType::Strong),
-            "em" | "Em" => Ok(NodeType::Em),
-            "code" | "Code" => Ok(NodeType::Code),
-            "strikethrough" | "Strikethrough" => Ok(NodeType::Strikethrough),
-            "underline" | "Underline" => Ok(NodeType::Underline),
-            "subscript" | "Subscript" => Ok(NodeType::Subscript),
-            "superscript" | "Superscript" => Ok(NodeType::Superscript),
-            "mark" | "Mark" => Ok(NodeType::Mark),
-            "small" | "Small" => Ok(NodeType::Small),
-            "br" | "Br" => Ok(NodeType::Br),
-            "span" | "Span" => Ok(NodeType::Span),
-            "article" | "Article" => Ok(NodeType::Article),
-            "section" | "Section" => Ok(NodeType::Section),
-            "nav" | "Nav" => Ok(NodeType::Nav),
-            "aside" | "Aside" => Ok(NodeType::Aside),
-            "header" | "Header" => Ok(NodeType::Header),
-            "footer" | "Footer" => Ok(NodeType::Footer),
-            "main" | "Main" => Ok(NodeType::Main),
-            "figure" | "Figure" => Ok(NodeType::Figure),
-            "figcaption" | "Figcaption" => Ok(NodeType::Figcaption),
-            "time" | "Time" => Ok(NodeType::Time),
-            "details" | "Details" => Ok(NodeType::Details),
-            "summary" | "Summary" => Ok(NodeType::Summary),
-            "form" | "Form" => Ok(NodeType::Form),
-            "input" | "Input" => Ok(NodeType::Input),
-            "select" | "Select" => Ok(NodeType::Select),
-            "option" | "Option" => Ok(NodeType::Option),
-            "button" | "Button" => Ok(NodeType::Button),
-            "textarea" | "Textarea" => Ok(NodeType::Textarea),
-            "label" | "Label" => Ok(NodeType::Label),
-            "fieldset" | "Fieldset" => Ok(NodeType::Fieldset),
-            "legend" | "Legend" => Ok(NodeType::Legend),
-            "audio" | "Audio" => Ok(NodeType::Audio),
-            "video" | "Video" => Ok(NodeType::Video),
-            "picture" | "Picture" => Ok(NodeType::Picture),
-            "source" | "Source" => Ok(NodeType::Source),
-            "iframe" | "Iframe" => Ok(NodeType::Iframe),
-            "svg" | "Svg" => Ok(NodeType::Svg),
-            "canvas" | "Canvas" => Ok(NodeType::Canvas),
-            "ruby" | "Ruby" => Ok(NodeType::Ruby),
-            "rt" | "Rt" => Ok(NodeType::Rt),
-            "rp" | "Rp" => Ok(NodeType::Rp),
-            "abbr" | "Abbr" => Ok(NodeType::Abbr),
-            "kbd" | "Kbd" => Ok(NodeType::Kbd),
-            "samp" | "Samp" => Ok(NodeType::Samp),
-            "var" | "Var" => Ok(NodeType::Var),
-            "cite" | "Cite" => Ok(NodeType::Cite),
-            "q" | "Q" => Ok(NodeType::Q),
-            "del" | "Del" => Ok(NodeType::Del),
-            "ins" | "Ins" => Ok(NodeType::Ins),
-            "data" | "Data" => Ok(NodeType::Data),
-            "meter" | "Meter" => Ok(NodeType::Meter),
-            "progress" | "Progress" => Ok(NodeType::Progress),
-            "output" | "Output" => Ok(NodeType::Output),
-            "template" | "Template" => Ok(NodeType::Template),
-            "slot" | "Slot" => Ok(NodeType::Slot),
-            "html" | "Html" => Ok(NodeType::Html),
-            "head" | "Head" => Ok(NodeType::Head),
-            "body" | "Body" => Ok(NodeType::Body),
-            "title" | "Title" => Ok(NodeType::Title),
-            "meta" | "Meta" => Ok(NodeType::Meta),
-            "link_tag" | "LinkTag" => Ok(NodeType::LinkTag),
-            "style" | "Style" => Ok(NodeType::Style),
-            "script" | "Script" => Ok(NodeType::Script),
-            "base" | "Base" => Ok(NodeType::Base),
-            "custom" | "Custom" => Ok(NodeType::Custom),
+            "Text" | "text" => Ok(NodeType::Text),
+            "Element" | "element" => Ok(NodeType::Element),
+            "Heading" | "heading" => Ok(NodeType::Heading),
+            "Paragraph" | "paragraph" => Ok(NodeType::Paragraph),
+            "Div" | "div" => Ok(NodeType::Div),
+            "Blockquote" | "blockquote" => Ok(NodeType::Blockquote),
+            "Pre" | "pre" => Ok(NodeType::Pre),
+            "Hr" | "hr" => Ok(NodeType::Hr),
+            "List" | "list" => Ok(NodeType::List),
+            "ListItem" | "list_item" => Ok(NodeType::ListItem),
+            "DefinitionList" | "definition_list" => Ok(NodeType::DefinitionList),
+            "DefinitionTerm" | "definition_term" => Ok(NodeType::DefinitionTerm),
+            "DefinitionDescription" | "definition_description" => Ok(NodeType::DefinitionDescription),
+            "Table" | "table" => Ok(NodeType::Table),
+            "TableRow" | "table_row" => Ok(NodeType::TableRow),
+            "TableCell" | "table_cell" => Ok(NodeType::TableCell),
+            "TableHeader" | "table_header" => Ok(NodeType::TableHeader),
+            "TableBody" | "table_body" => Ok(NodeType::TableBody),
+            "TableHead" | "table_head" => Ok(NodeType::TableHead),
+            "TableFoot" | "table_foot" => Ok(NodeType::TableFoot),
+            "Link" | "link" => Ok(NodeType::Link),
+            "Image" | "image" => Ok(NodeType::Image),
+            "Strong" | "strong" => Ok(NodeType::Strong),
+            "Em" | "em" => Ok(NodeType::Em),
+            "Code" | "code" => Ok(NodeType::Code),
+            "Strikethrough" | "strikethrough" => Ok(NodeType::Strikethrough),
+            "Underline" | "underline" => Ok(NodeType::Underline),
+            "Subscript" | "subscript" => Ok(NodeType::Subscript),
+            "Superscript" | "superscript" => Ok(NodeType::Superscript),
+            "Mark" | "mark" => Ok(NodeType::Mark),
+            "Small" | "small" => Ok(NodeType::Small),
+            "Br" | "br" => Ok(NodeType::Br),
+            "Span" | "span" => Ok(NodeType::Span),
+            "Article" | "article" => Ok(NodeType::Article),
+            "Section" | "section" => Ok(NodeType::Section),
+            "Nav" | "nav" => Ok(NodeType::Nav),
+            "Aside" | "aside" => Ok(NodeType::Aside),
+            "Header" | "header" => Ok(NodeType::Header),
+            "Footer" | "footer" => Ok(NodeType::Footer),
+            "Main" | "main" => Ok(NodeType::Main),
+            "Figure" | "figure" => Ok(NodeType::Figure),
+            "Figcaption" | "figcaption" => Ok(NodeType::Figcaption),
+            "Time" | "time" => Ok(NodeType::Time),
+            "Details" | "details" => Ok(NodeType::Details),
+            "Summary" | "summary" => Ok(NodeType::Summary),
+            "Form" | "form" => Ok(NodeType::Form),
+            "Input" | "input" => Ok(NodeType::Input),
+            "Select" | "select" => Ok(NodeType::Select),
+            "Option" | "option" => Ok(NodeType::Option),
+            "Button" | "button" => Ok(NodeType::Button),
+            "Textarea" | "textarea" => Ok(NodeType::Textarea),
+            "Label" | "label" => Ok(NodeType::Label),
+            "Fieldset" | "fieldset" => Ok(NodeType::Fieldset),
+            "Legend" | "legend" => Ok(NodeType::Legend),
+            "Audio" | "audio" => Ok(NodeType::Audio),
+            "Video" | "video" => Ok(NodeType::Video),
+            "Picture" | "picture" => Ok(NodeType::Picture),
+            "Source" | "source" => Ok(NodeType::Source),
+            "Iframe" | "iframe" => Ok(NodeType::Iframe),
+            "Svg" | "svg" => Ok(NodeType::Svg),
+            "Canvas" | "canvas" => Ok(NodeType::Canvas),
+            "Ruby" | "ruby" => Ok(NodeType::Ruby),
+            "Rt" | "rt" => Ok(NodeType::Rt),
+            "Rp" | "rp" => Ok(NodeType::Rp),
+            "Abbr" | "abbr" => Ok(NodeType::Abbr),
+            "Kbd" | "kbd" => Ok(NodeType::Kbd),
+            "Samp" | "samp" => Ok(NodeType::Samp),
+            "Var" | "var" => Ok(NodeType::Var),
+            "Cite" | "cite" => Ok(NodeType::Cite),
+            "Q" | "q" => Ok(NodeType::Q),
+            "Del" | "del" => Ok(NodeType::Del),
+            "Ins" | "ins" => Ok(NodeType::Ins),
+            "Data" | "data" => Ok(NodeType::Data),
+            "Meter" | "meter" => Ok(NodeType::Meter),
+            "Progress" | "progress" => Ok(NodeType::Progress),
+            "Output" | "output" => Ok(NodeType::Output),
+            "Template" | "template" => Ok(NodeType::Template),
+            "Slot" | "slot" => Ok(NodeType::Slot),
+            "Html" | "html" => Ok(NodeType::Html),
+            "Head" | "head" => Ok(NodeType::Head),
+            "Body" | "body" => Ok(NodeType::Body),
+            "Title" | "title" => Ok(NodeType::Title),
+            "Meta" | "meta" => Ok(NodeType::Meta),
+            "LinkTag" | "link_tag" => Ok(NodeType::LinkTag),
+            "Style" | "style" => Ok(NodeType::Style),
+            "Script" | "script" => Ok(NodeType::Script),
+            "Base" | "base" => Ok(NodeType::Base),
+            "Custom" | "custom" => Ok(NodeType::Custom),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid NodeType value: {other}"),

data/lib/html_to_markdown/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:6ad3ba5d90989a04f847de4763503bc48dcb0fbf9d384f6499744f6b9d51ec48
+# alef:hash:d679b59088594adaffae8541ddda37761d2ea48733185dc6d5b1a45f82cf2d54
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true

data/lib/html_to_markdown/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:22cc656495ad800c6db992f60fdc222581bfe33b5339d6487ae2f9aa4575cc1d
+# alef:hash:c9d820a0f5c8db11ca96985c39dce0e8a31ed8a0ab0ad0e738734a2555dc3a6f
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true
 
 module HtmlToMarkdown
   ## The version string for this package.
-  VERSION = "3.11.3"
+  VERSION = "3.11.4"
 end

data/lib/html_to_markdown.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:f6c8b3e246143c90a4f96e2d9f51ba3fe8b20c1d4bc92f97ca7a9a39805fb4f5
+# alef:hash:8416d126100cec6c753e064aad4c3585c5aa55cd3666f930627f52717f8b3cd2
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true

data/sig/types.rbs

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:2f70b49a07b891575c2a80aab0cdf844848ac79b282b530c3d5da91eabad5e9b
+# alef:hash:f3a3421ae776c3ce9950a5a7b9e56d5732b7a5d34f283c57b21dac9e54e47606
 # To regenerate: alef generate
 # To verify freshness: alef verify
 
@@ -292,7 +292,7 @@ module HtmlToMarkdown
   end
 
   class TextDirection
-    type value = :left_to_right | :right_to_left | :auto
+    type value = :ltr | :rtl | :auto
   end
 
   class LinkType
@@ -304,7 +304,7 @@ module HtmlToMarkdown
   end
 
   class StructuredDataType
-    type value = :json_ld | :microdata | :rd_fa
+    type value = :json_ld | :microdata | :rdfa
   end
 
   class TierStrategy
@@ -312,43 +312,43 @@ module HtmlToMarkdown
   end
 
   class PreprocessingPreset
-    type value = :minimal | :standard | :aggressive
+    type value = :Minimal | :Standard | :Aggressive
   end
 
   class HeadingStyle
-    type value = :underlined | :atx | :atx_closed
+    type value = :Underlined | :Atx | :AtxClosed
   end
 
   class ListIndentType
-    type value = :spaces | :tabs
+    type value = :Spaces | :Tabs
   end
 
   class WhitespaceMode
-    type value = :normalized | :strict
+    type value = :Normalized | :Strict
   end
 
   class NewlineStyle
-    type value = :spaces | :backslash
+    type value = :Spaces | :Backslash
   end
 
   class CodeBlockStyle
-    type value = :indented | :backticks | :tildes
+    type value = :Indented | :Backticks | :Tildes
   end
 
   class HighlightStyle
-    type value = :double_equal | :html | :bold | :none
+    type value = :DoubleEqual | :Html | :Bold | :None
   end
 
   class LinkStyle
-    type value = :inline | :reference
+    type value = :Inline | :Reference
   end
 
   class UrlEscapeStyle
-    type value = :angle | :percent
+    type value = :Angle | :Percent
   end
 
   class OutputFormat
-    type value = :markdown | :djot | :plain
+    type value = :Markdown | :Djot | :Plain
   end
 
   class NodeContent
@@ -362,7 +362,7 @@ module HtmlToMarkdown
   end
 
   class NodeType
-    type value = :text | :element | :heading | :paragraph | :div | :blockquote | :pre | :hr | :list | :list_item | :definition_list | :definition_term | :definition_description | :table | :table_row | :table_cell | :table_header | :table_body | :table_head | :table_foot | :link | :image | :strong | :em | :code | :strikethrough | :underline | :subscript | :superscript | :mark | :small | :br | :span | :article | :section | :nav | :aside | :header | :footer | :main | :figure | :figcaption | :time | :details | :summary | :form | :input | :select | :option | :button | :textarea | :label | :fieldset | :legend | :audio | :video | :picture | :source | :iframe | :svg | :canvas | :ruby | :rt | :rp | :abbr | :kbd | :samp | :var | :cite | :q | :del | :ins | :data | :meter | :progress | :output | :template | :slot | :html | :head | :body | :title | :meta | :link_tag | :style | :script | :base | :custom
+    type value = :Text | :Element | :Heading | :Paragraph | :Div | :Blockquote | :Pre | :Hr | :List | :ListItem | :DefinitionList | :DefinitionTerm | :DefinitionDescription | :Table | :TableRow | :TableCell | :TableHeader | :TableBody | :TableHead | :TableFoot | :Link | :Image | :Strong | :Em | :Code | :Strikethrough | :Underline | :Subscript | :Superscript | :Mark | :Small | :Br | :Span | :Article | :Section | :Nav | :Aside | :Header | :Footer | :Main | :Figure | :Figcaption | :Time | :Details | :Summary | :Form | :Input | :Select | :Option | :Button | :Textarea | :Label | :Fieldset | :Legend | :Audio | :Video | :Picture | :Source | :Iframe | :Svg | :Canvas | :Ruby | :Rt | :Rp | :Abbr | :Kbd | :Samp | :Var | :Cite | :Q | :Del | :Ins | :Data | :Meter | :Progress | :Output | :Template | :Slot | :Html | :Head | :Body | :Title | :Meta | :LinkTag | :Style | :Script | :Base | :Custom
   end
 
   class VisitResult

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: html-to-markdown
 version: !ruby/object:Gem::Version
-  version: 3.11.3
+  version: 3.11.4
 platform: ruby
 authors:
 - Na'aman Hirschfeld <naaman@xberg.io>
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-21 00:00:00.000000000 Z
+date: 2026-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys