kreuzberg 4.2.6 → 4.2.7

data/vendor/kreuzberg/src/extractors/email.rs

@@ -5,7 +5,9 @@ use crate::core::config::ExtractionConfig;
 use crate::extractors::SyncExtractor;
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::{EmailMetadata, ExtractionResult, Metadata};
+use ahash::AHashMap;
 use async_trait::async_trait;
+use std::borrow::Cow;
 #[cfg(feature = "tokio-runtime")]
 use std::path::Path;
 
@@ -66,14 +68,14 @@ impl SyncExtractor for EmailExtractor {
             attachments: attachment_names,
         };
 
-        let mut additional = std::collections::HashMap::new();
+        let mut additional = AHashMap::new();
         for (key, value) in &email_result.metadata {
-            additional.insert(key.clone(), serde_json::json!(value));
+            additional.insert(Cow::Owned(key.clone()), serde_json::json!(value));
         }
 
         Ok(ExtractionResult {
             content: text,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 format: Some(crate::types::FormatMetadata::Email(email_metadata)),
                 subject: email_result.subject.clone(),

data/vendor/kreuzberg/src/extractors/epub/metadata.rs

@@ -27,24 +27,24 @@ pub(super) fn extract_metadata(opf_xml: &str) -> Result<(OepbMetadata, BTreeMap<
 
     let (epub_metadata, _) = parse_opf(opf_xml)?;
 
-    if let Some(identifier) = epub_metadata.identifier.clone() {
-        additional_metadata.insert("identifier".to_string(), serde_json::json!(identifier));
+    if let Some(ref identifier) = epub_metadata.identifier {
+        additional_metadata.insert("identifier".to_string(), serde_json::json!(identifier.clone()));
     }
 
-    if let Some(publisher) = epub_metadata.publisher.clone() {
-        additional_metadata.insert("publisher".to_string(), serde_json::json!(publisher));
+    if let Some(ref publisher) = epub_metadata.publisher {
+        additional_metadata.insert("publisher".to_string(), serde_json::json!(publisher.clone()));
     }
 
-    if let Some(subject) = epub_metadata.subject.clone() {
-        additional_metadata.insert("subject".to_string(), serde_json::json!(subject));
+    if let Some(ref subject) = epub_metadata.subject {
+        additional_metadata.insert("subject".to_string(), serde_json::json!(subject.clone()));
     }
 
-    if let Some(description) = epub_metadata.description.clone() {
-        additional_metadata.insert("description".to_string(), serde_json::json!(description));
+    if let Some(ref description) = epub_metadata.description {
+        additional_metadata.insert("description".to_string(), serde_json::json!(description.clone()));
     }
 
-    if let Some(rights) = epub_metadata.rights.clone() {
-        additional_metadata.insert("rights".to_string(), serde_json::json!(rights));
+    if let Some(ref rights) = epub_metadata.rights {
+        additional_metadata.insert("rights".to_string(), serde_json::json!(rights.clone()));
     }
 
     Ok((epub_metadata, additional_metadata))

data/vendor/kreuzberg/src/extractors/epub/mod.rs

@@ -19,7 +19,9 @@ use crate::Result;
 use crate::core::config::ExtractionConfig;
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::{ExtractionResult, Metadata};
+use ahash::AHashMap;
 use async_trait::async_trait;
+use std::borrow::Cow;
 use std::io::Cursor;
 use zip::ZipArchive;
 
@@ -112,12 +114,14 @@ impl DocumentExtractor for EpubExtractor {
         let extracted_content = extract_content(&mut archive, &opf_path, &manifest_dir)?;
 
         let (epub_metadata, additional_metadata) = extract_metadata(&opf_xml)?;
-        let metadata_map: std::collections::HashMap<String, serde_json::Value> =
-            additional_metadata.into_iter().collect();
+        let metadata_map: AHashMap<Cow<'static, str>, serde_json::Value> = additional_metadata
+            .into_iter()
+            .map(|(k, v)| (Cow::Owned(k), v))
+            .collect();
 
         Ok(ExtractionResult {
             content: extracted_content,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 title: epub_metadata.title,
                 authors: epub_metadata.creator.map(|c| vec![c]),

data/vendor/kreuzberg/src/extractors/excel.rs

@@ -4,7 +4,9 @@ use crate::Result;
 use crate::core::config::ExtractionConfig;
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::{ExcelMetadata, ExtractionResult, Metadata, Table};
+use ahash::AHashMap;
 use async_trait::async_trait;
+use std::borrow::Cow;
 use std::path::Path;
 
 /// Excel spreadsheet extractor using calamine.
@@ -120,16 +122,16 @@ impl DocumentExtractor for ExcelExtractor {
             sheet_names,
         };
 
-        let mut additional = std::collections::HashMap::new();
+        let mut additional = AHashMap::new();
         for (key, value) in &workbook.metadata {
             if key != "sheet_count" && key != "sheet_names" {
-                additional.insert(key.clone(), serde_json::json!(value));
+                additional.insert(Cow::Owned(key.clone()), serde_json::json!(value));
             }
         }
 
         Ok(ExtractionResult {
             content: markdown,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 format: Some(crate::types::FormatMetadata::Excel(excel_metadata)),
                 additional,
@@ -166,16 +168,16 @@ impl DocumentExtractor for ExcelExtractor {
             sheet_names,
         };
 
-        let mut additional = std::collections::HashMap::new();
+        let mut additional = AHashMap::new();
         for (key, value) in &workbook.metadata {
             if key != "sheet_count" && key != "sheet_names" {
-                additional.insert(key.clone(), serde_json::json!(value));
+                additional.insert(Cow::Owned(key.clone()), serde_json::json!(value));
             }
         }
 
         Ok(ExtractionResult {
             content: markdown,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 format: Some(crate::types::FormatMetadata::Excel(excel_metadata)),
                 additional,

data/vendor/kreuzberg/src/extractors/fictionbook.rs

@@ -434,7 +434,7 @@ impl DocumentExtractor for FictionBookExtractor {
 
         Ok(ExtractionResult {
             content: extracted_content,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata,
             tables: vec![],
             detected_languages: None,

data/vendor/kreuzberg/src/extractors/frontmatter_utils.rs

@@ -9,6 +9,7 @@
 use crate::types::Metadata;
 
 use serde_yaml_ng::Value as YamlValue;
+use std::borrow::Cow;
 
 /// Extract YAML frontmatter from document content.
 ///
@@ -126,12 +127,12 @@ pub fn extract_metadata_from_yaml(yaml: &YamlValue) -> Metadata {
 
     // Title
     if let Some(title) = yaml.get("title").and_then(|v| v.as_str()) {
-        metadata.additional.insert("title".to_string(), title.into());
+        metadata.additional.insert(Cow::Borrowed("title"), title.into());
     }
 
     // Author
     if let Some(author) = yaml.get("author").and_then(|v| v.as_str()) {
-        metadata.additional.insert("author".to_string(), author.into());
+        metadata.additional.insert(Cow::Borrowed("author"), author.into());
     }
 
     // Date (map to created_at)
@@ -143,11 +144,13 @@ pub fn extract_metadata_from_yaml(yaml: &YamlValue) -> Metadata {
     if let Some(keywords) = yaml.get("keywords") {
         match keywords {
             YamlValue::String(s) => {
-                metadata.additional.insert("keywords".to_string(), s.clone().into());
+                metadata.additional.insert(Cow::Borrowed("keywords"), s.clone().into());
             }
             YamlValue::Sequence(seq) => {
                 let keywords_str = seq.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(", ");
-                metadata.additional.insert("keywords".to_string(), keywords_str.into());
+                metadata
+                    .additional
+                    .insert(Cow::Borrowed("keywords"), keywords_str.into());
             }
             _ => {}
         }
@@ -160,7 +163,9 @@ pub fn extract_metadata_from_yaml(yaml: &YamlValue) -> Metadata {
 
     // Abstract
     if let Some(abstract_text) = yaml.get("abstract").and_then(|v| v.as_str()) {
-        metadata.additional.insert("abstract".to_string(), abstract_text.into());
+        metadata
+            .additional
+            .insert(Cow::Borrowed("abstract"), abstract_text.into());
     }
 
     // Subject (overrides description if both present)
@@ -170,18 +175,18 @@ pub fn extract_metadata_from_yaml(yaml: &YamlValue) -> Metadata {
 
     // Category
     if let Some(category) = yaml.get("category").and_then(|v| v.as_str()) {
-        metadata.additional.insert("category".to_string(), category.into());
+        metadata.additional.insert(Cow::Borrowed("category"), category.into());
     }
 
     // Tags (support both string and array)
     if let Some(tags) = yaml.get("tags") {
         match tags {
             YamlValue::String(s) => {
-                metadata.additional.insert("tags".to_string(), s.clone().into());
+                metadata.additional.insert(Cow::Borrowed("tags"), s.clone().into());
             }
             YamlValue::Sequence(seq) => {
                 let tags_str = seq.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(", ");
-                metadata.additional.insert("tags".to_string(), tags_str.into());
+                metadata.additional.insert(Cow::Borrowed("tags"), tags_str.into());
             }
             _ => {}
         }
@@ -189,12 +194,12 @@ pub fn extract_metadata_from_yaml(yaml: &YamlValue) -> Metadata {
 
     // Language
     if let Some(language) = yaml.get("language").and_then(|v| v.as_str()) {
-        metadata.additional.insert("language".to_string(), language.into());
+        metadata.additional.insert(Cow::Borrowed("language"), language.into());
     }
 
     // Version
     if let Some(version) = yaml.get("version").and_then(|v| v.as_str()) {
-        metadata.additional.insert("version".to_string(), version.into());
+        metadata.additional.insert(Cow::Borrowed("version"), version.into());
     }
 
     metadata

data/vendor/kreuzberg/src/extractors/html.rs

@@ -219,7 +219,7 @@ impl SyncExtractor for HtmlExtractor {
 
         Ok(ExtractionResult {
             content: content_text,
-            mime_type: result_mime_type.to_string(),
+            mime_type: result_mime_type.to_string().into(),
             metadata: Metadata {
                 format: html_metadata.map(|m| crate::types::FormatMetadata::Html(Box::new(m))),
                 ..Default::default()

data/vendor/kreuzberg/src/extractors/image.rs

@@ -128,7 +128,7 @@ impl DocumentExtractor for ImageExtractor {
                 let mut ocr_result = self.extract_with_ocr(content, mime_type, config).await?;
 
                 ocr_result.metadata.format = Some(crate::types::FormatMetadata::Image(image_metadata));
-                ocr_result.mime_type = mime_type.to_string();
+                ocr_result.mime_type = mime_type.to_string().into();
 
                 return Ok(ocr_result);
             }
@@ -141,7 +141,7 @@ impl DocumentExtractor for ImageExtractor {
 
                 return Ok(ExtractionResult {
                     content: content_text,
-                    mime_type: mime_type.to_string(),
+                    mime_type: mime_type.to_string().into(),
                     metadata: Metadata {
                         format: Some(crate::types::FormatMetadata::Image(image_metadata)),
                         ..Default::default()
@@ -161,7 +161,7 @@ impl DocumentExtractor for ImageExtractor {
                 "Image: {} {}x{}",
                 extraction_metadata.format, extraction_metadata.width, extraction_metadata.height
             ),
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 format: Some(crate::types::FormatMetadata::Image(image_metadata)),
                 ..Default::default()

data/vendor/kreuzberg/src/extractors/jats/mod.rs

@@ -159,7 +159,7 @@ impl DocumentExtractor for JatsExtractor {
 
         Ok(ExtractionResult {
             content: extracted_content,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata,
             tables,
             detected_languages: None,

data/vendor/kreuzberg/src/extractors/jupyter.rs

@@ -18,11 +18,13 @@ use crate::plugins::{DocumentExtractor, Plugin};
 #[cfg(feature = "office")]
 use crate::types::{ExtractionResult, Metadata};
 #[cfg(feature = "office")]
+use ahash::AHashMap;
+#[cfg(feature = "office")]
 use async_trait::async_trait;
 #[cfg(feature = "office")]
 use serde_json::{Value, json};
 #[cfg(feature = "office")]
-use std::collections::HashMap;
+use std::borrow::Cow;
 
 /// Jupyter Notebook extractor.
 ///
@@ -42,32 +44,32 @@ impl JupyterExtractor {
     }
 
     /// Extract content from a Jupyter notebook.
-    fn extract_notebook(content: &[u8]) -> Result<(String, HashMap<String, Value>)> {
+    fn extract_notebook(content: &[u8]) -> Result<(String, AHashMap<Cow<'static, str>, Value>)> {
         let notebook: Value = serde_json::from_slice(content)
             .map_err(|e| crate::KreuzbergError::parsing(format!("Failed to parse JSON: {}", e)))?;
 
         let mut extracted_content = String::new();
-        let mut metadata = HashMap::new();
+        let mut metadata = AHashMap::new();
 
         if let Some(notebook_metadata) = notebook.get("metadata").and_then(|m| m.as_object()) {
             if let Some(kernelspec) = notebook_metadata.get("kernelspec")
                 && let Some(name) = kernelspec.get("name").and_then(|n| n.as_str())
             {
                 extracted_content.push_str(&format!("Kernelspec: {}\n", name));
-                metadata.insert("kernelspec".to_string(), kernelspec.clone());
+                metadata.insert(Cow::Borrowed("kernelspec"), kernelspec.clone());
             }
 
             if let Some(language_info) = notebook_metadata.get("language_info")
                 && let Some(name) = language_info.get("name").and_then(|n| n.as_str())
             {
                 extracted_content.push_str(&format!("Language: {}\n", name));
-                metadata.insert("language_info".to_string(), language_info.clone());
+                metadata.insert(Cow::Borrowed("language_info"), language_info.clone());
             }
         }
 
         if let Some(nbformat) = notebook.get("nbformat") {
             extracted_content.push_str(&format!("NBFormat: {}\n", nbformat));
-            metadata.insert("nbformat".to_string(), nbformat.clone());
+            metadata.insert(Cow::Borrowed("nbformat"), nbformat.clone());
         }
 
         extracted_content.push('\n');
@@ -86,7 +88,7 @@ impl JupyterExtractor {
         cell: &Value,
         cell_idx: usize,
         content: &mut String,
-        _metadata: &mut HashMap<String, Value>,
+        _metadata: &mut AHashMap<Cow<'static, str>, Value>,
     ) -> Result<()> {
         let cell_type = cell.get("cell_type").and_then(|t| t.as_str()).unwrap_or("unknown");
 
@@ -324,14 +326,14 @@ impl DocumentExtractor for JupyterExtractor {
     ) -> Result<ExtractionResult> {
         let (extracted_content, additional_metadata) = Self::extract_notebook(content)?;
 
-        let mut metadata_additional = HashMap::new();
+        let mut metadata_additional = AHashMap::new();
         for (key, value) in additional_metadata {
             metadata_additional.insert(key, json!(value));
         }
 
         Ok(ExtractionResult {
             content: extracted_content,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 additional: metadata_additional,
                 ..Default::default()

data/vendor/kreuzberg/src/extractors/latex/metadata.rs

@@ -5,6 +5,7 @@
 
 use super::utilities::extract_braced;
 use crate::types::Metadata;
+use std::borrow::Cow;
 
 /// Extracts metadata from a LaTeX line.
 ///
@@ -13,15 +14,15 @@ use crate::types::Metadata;
 pub fn extract_metadata_from_line(line: &str, metadata: &mut Metadata) {
     if line.starts_with("\\title{") {
         if let Some(title) = extract_braced(line, "title") {
-            metadata.additional.insert("title".to_string(), title.into());
+            metadata.additional.insert(Cow::Borrowed("title"), title.into());
         }
     } else if line.starts_with("\\author{") {
         if let Some(author) = extract_braced(line, "author") {
-            metadata.additional.insert("author".to_string(), author.into());
+            metadata.additional.insert(Cow::Borrowed("author"), author.into());
         }
     } else if line.starts_with("\\date{")
         && let Some(date) = extract_braced(line, "date")
     {
-        metadata.additional.insert("date".to_string(), date.into());
+        metadata.additional.insert(Cow::Borrowed("date"), date.into());
     }
 }

data/vendor/kreuzberg/src/extractors/latex/mod.rs

@@ -95,7 +95,7 @@ impl DocumentExtractor for LatexExtractor {
 
         Ok(ExtractionResult {
             content: text,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata,
             tables,
             detected_languages: None,

data/vendor/kreuzberg/src/extractors/markdown.rs

@@ -28,6 +28,8 @@ use crate::types::{ExtractionResult, Metadata, Table};
 use async_trait::async_trait;
 #[cfg(feature = "office")]
 use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
+#[cfg(feature = "office")]
+use std::borrow::Cow;
 
 /// Enhanced Markdown extractor with metadata and table support.
 ///
@@ -113,7 +115,7 @@ impl MarkdownExtractor {
                     if !current_row.is_empty()
                         && let Some((ref mut rows, _)) = current_table
                     {
-                        rows.push(current_row.clone());
+                        rows.push(std::mem::take(&mut current_row));
                     }
                     current_row = Vec::new();
                 }
@@ -121,7 +123,7 @@ impl MarkdownExtractor {
                     if !current_row.is_empty()
                         && let Some((ref mut rows, _)) = current_table
                     {
-                        rows.push(current_row.clone());
+                        rows.push(std::mem::take(&mut current_row));
                     }
                     current_row = Vec::new();
                 }
@@ -211,7 +213,7 @@ impl DocumentExtractor for MarkdownExtractor {
         if !metadata.additional.contains_key("title")
             && let Some(title) = extract_title_from_content(&remaining_content)
         {
-            metadata.additional.insert("title".to_string(), title.into());
+            metadata.additional.insert(Cow::Borrowed("title"), title.into());
         }
 
         let parser = Parser::new_ext(&remaining_content, Options::ENABLE_TABLES);
@@ -223,7 +225,7 @@ impl DocumentExtractor for MarkdownExtractor {
 
         Ok(ExtractionResult {
             content: extracted_text,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata,
             tables,
             detected_languages: None,

data/vendor/kreuzberg/src/extractors/odt.rs

@@ -9,8 +9,10 @@ use crate::core::config::ExtractionConfig;
 use crate::extraction::{cells_to_markdown, office_metadata};
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::{ExtractionResult, Metadata, Table};
+use ahash::AHashMap;
 use async_trait::async_trait;
 use roxmltree::Document;
+use std::borrow::Cow;
 use std::io::Cursor;
 
 /// High-performance ODT extractor using native Rust XML parsing.
@@ -475,7 +477,7 @@ impl DocumentExtractor for OdtExtractor {
             (combined_text, tables)
         };
 
-        let mut metadata_map = std::collections::HashMap::new();
+        let mut metadata_map = AHashMap::new();
 
         let cursor = Cursor::new(content_owned.clone());
         let mut archive = zip::ZipArchive::new(cursor).map_err(|e| {
@@ -484,80 +486,95 @@ impl DocumentExtractor for OdtExtractor {
 
         if let Ok(odt_props) = office_metadata::extract_odt_properties(&mut archive) {
             if let Some(title) = odt_props.title {
-                metadata_map.insert("title".to_string(), serde_json::Value::String(title));
+                metadata_map.insert(Cow::Borrowed("title"), serde_json::Value::String(title));
             }
             if let Some(creator) = odt_props.creator {
                 metadata_map.insert(
-                    "authors".to_string(),
+                    Cow::Borrowed("authors"),
                     serde_json::Value::Array(vec![serde_json::Value::String(creator.clone())]),
                 );
-                metadata_map.insert("created_by".to_string(), serde_json::Value::String(creator));
+                metadata_map.insert(Cow::Borrowed("created_by"), serde_json::Value::String(creator));
             }
             if let Some(initial_creator) = odt_props.initial_creator {
                 metadata_map.insert(
-                    "initial_creator".to_string(),
+                    Cow::Borrowed("initial_creator"),
                     serde_json::Value::String(initial_creator),
                 );
             }
             if let Some(subject) = odt_props.subject {
-                metadata_map.insert("subject".to_string(), serde_json::Value::String(subject));
+                metadata_map.insert(Cow::Borrowed("subject"), serde_json::Value::String(subject));
             }
             if let Some(keywords) = odt_props.keywords {
-                metadata_map.insert("keywords".to_string(), serde_json::Value::String(keywords));
+                metadata_map.insert(Cow::Borrowed("keywords"), serde_json::Value::String(keywords));
             }
             if let Some(description) = odt_props.description {
-                metadata_map.insert("description".to_string(), serde_json::Value::String(description));
+                metadata_map.insert(Cow::Borrowed("description"), serde_json::Value::String(description));
             }
             if let Some(creation_date) = odt_props.creation_date {
-                metadata_map.insert("created_at".to_string(), serde_json::Value::String(creation_date));
+                metadata_map.insert(Cow::Borrowed("created_at"), serde_json::Value::String(creation_date));
             }
             if let Some(date) = odt_props.date {
-                metadata_map.insert("modified_at".to_string(), serde_json::Value::String(date));
+                metadata_map.insert(Cow::Borrowed("modified_at"), serde_json::Value::String(date));
             }
             if let Some(language) = odt_props.language {
-                metadata_map.insert("language".to_string(), serde_json::Value::String(language));
+                metadata_map.insert(Cow::Borrowed("language"), serde_json::Value::String(language));
             }
             if let Some(generator) = odt_props.generator {
-                metadata_map.insert("generator".to_string(), serde_json::Value::String(generator));
+                metadata_map.insert(Cow::Borrowed("generator"), serde_json::Value::String(generator));
             }
             if let Some(editing_duration) = odt_props.editing_duration {
                 metadata_map.insert(
-                    "editing_duration".to_string(),
+                    Cow::Borrowed("editing_duration"),
                     serde_json::Value::String(editing_duration),
                 );
             }
             if let Some(editing_cycles) = odt_props.editing_cycles {
-                metadata_map.insert("editing_cycles".to_string(), serde_json::Value::String(editing_cycles));
+                metadata_map.insert(
+                    Cow::Borrowed("editing_cycles"),
+                    serde_json::Value::String(editing_cycles),
+                );
             }
             if let Some(page_count) = odt_props.page_count {
-                metadata_map.insert("page_count".to_string(), serde_json::Value::Number(page_count.into()));
+                metadata_map.insert(
+                    Cow::Borrowed("page_count"),
+                    serde_json::Value::Number(page_count.into()),
+                );
             }
             if let Some(word_count) = odt_props.word_count {
-                metadata_map.insert("word_count".to_string(), serde_json::Value::Number(word_count.into()));
+                metadata_map.insert(
+                    Cow::Borrowed("word_count"),
+                    serde_json::Value::Number(word_count.into()),
+                );
             }
             if let Some(character_count) = odt_props.character_count {
                 metadata_map.insert(
-                    "character_count".to_string(),
+                    Cow::Borrowed("character_count"),
                     serde_json::Value::Number(character_count.into()),
                 );
             }
             if let Some(paragraph_count) = odt_props.paragraph_count {
                 metadata_map.insert(
-                    "paragraph_count".to_string(),
+                    Cow::Borrowed("paragraph_count"),
                     serde_json::Value::Number(paragraph_count.into()),
                 );
             }
             if let Some(table_count) = odt_props.table_count {
-                metadata_map.insert("table_count".to_string(), serde_json::Value::Number(table_count.into()));
+                metadata_map.insert(
+                    Cow::Borrowed("table_count"),
+                    serde_json::Value::Number(table_count.into()),
+                );
             }
             if let Some(image_count) = odt_props.image_count {
-                metadata_map.insert("image_count".to_string(), serde_json::Value::Number(image_count.into()));
+                metadata_map.insert(
+                    Cow::Borrowed("image_count"),
+                    serde_json::Value::Number(image_count.into()),
+                );
             }
         }
 
         Ok(ExtractionResult {
             content: text,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 additional: metadata_map,
                 ..Default::default()

data/vendor/kreuzberg/src/extractors/opml/core.rs

@@ -79,7 +79,7 @@ impl DocumentExtractor for OpmlExtractor {
 
         Ok(ExtractionResult {
             content: extracted_content,
-            mime_type: mime_type.to_string(),
+            mime_type: mime_type.to_string().into(),
             metadata: Metadata {
                 additional: metadata_map,
                 ..Default::default()