kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

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

@@ -1,5 +1,3 @@
-#![cfg(all(feature = "tokio-runtime", feature = "office"))]
-
 //! PowerPoint presentation extractor.
 
 use crate::Result;
@@ -45,10 +43,8 @@ impl PptxExtractor {
         for image in &mut images {
             let image_data = image.data.clone();
             let tess_config_clone = tess_config.clone();
-            let span = tracing::Span::current();
 
             let ocr_result = tokio::task::spawn_blocking(move || {
-                let _guard = span.entered();
                 let cache_dir = std::env::var("KREUZBERG_CACHE_DIR").ok().map(std::path::PathBuf::from);
 
                 let proc = OcrProcessor::new(cache_dir)?;
@@ -71,7 +67,6 @@ impl PptxExtractor {
                         detected_languages: None,
                         chunks: None,
                         images: None,
-                        pages: None,
                     };
                     image.ocr_result = Some(Box::new(extraction_result));
                 }
@@ -105,13 +100,6 @@ impl Plugin for PptxExtractor {
 
 #[async_trait]
 impl DocumentExtractor for PptxExtractor {
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, content, config),
-        fields(
-            extractor.name = self.name(),
-            content.size_bytes = content.len(),
-        )
-    ))]
     async fn extract_bytes(
         &self,
         content: &[u8],
@@ -120,18 +108,18 @@ impl DocumentExtractor for PptxExtractor {
     ) -> Result<ExtractionResult> {
         let extract_images = config.images.as_ref().is_some_and(|img| img.extract_images);
 
-        let pages_config = config.pages.clone();
+        // Extract PPTX content
         let pptx_result = if crate::core::batch_mode::is_batch_mode() {
+            // Batch mode: Use spawn_blocking for parallelism
             let content_owned = content.to_vec();
-            let span = tracing::Span::current();
             tokio::task::spawn_blocking(move || {
-                let _guard = span.entered();
-                crate::extraction::pptx::extract_pptx_from_bytes(&content_owned, extract_images, pages_config.as_ref())
+                crate::extraction::pptx::extract_pptx_from_bytes(&content_owned, extract_images)
             })
             .await
             .map_err(|e| crate::error::KreuzbergError::parsing(format!("PPTX extraction task failed: {}", e)))??
         } else {
-            crate::extraction::pptx::extract_pptx_from_bytes(content, extract_images, config.pages.as_ref())?
+            // Single-file mode: Direct extraction (no spawn overhead)
+            crate::extraction::pptx::extract_pptx_from_bytes(content, extract_images)?
         };
 
         let mut additional = std::collections::HashMap::new();
@@ -139,41 +127,28 @@ impl DocumentExtractor for PptxExtractor {
         additional.insert("image_count".to_string(), serde_json::json!(pptx_result.image_count));
         additional.insert("table_count".to_string(), serde_json::json!(pptx_result.table_count));
 
-        let images = if extract_images {
-            // Image extraction is enabled, return images or empty vector
-            if !pptx_result.images.is_empty() {
-                #[cfg(feature = "ocr")]
-                {
-                    let processed_images = self.process_images_with_ocr(pptx_result.images, config).await?;
-                    Some(processed_images)
-                }
-                #[cfg(not(feature = "ocr"))]
-                {
-                    Some(pptx_result.images)
-                }
-            } else {
-                Some(vec![])
+        let images = if !pptx_result.images.is_empty() {
+            #[cfg(feature = "ocr")]
+            {
+                let processed_images = self.process_images_with_ocr(pptx_result.images, config).await?;
+                Some(processed_images)
+            }
+            #[cfg(not(feature = "ocr"))]
+            {
+                Some(pptx_result.images)
             }
         } else {
-            // Image extraction is disabled
             None
         };
 
-        let mut metadata = Metadata {
-            format: Some(crate::types::FormatMetadata::Pptx(pptx_result.metadata)),
-            additional,
-            ..Default::default()
-        };
-
-        if let Some(page_structure) = pptx_result.page_structure {
-            metadata.pages = Some(page_structure);
-        }
-
         Ok(ExtractionResult {
             content: pptx_result.content,
             mime_type: mime_type.to_string(),
-            metadata,
-            pages: pptx_result.page_contents,
+            metadata: Metadata {
+                format: Some(crate::types::FormatMetadata::Pptx(pptx_result.metadata)),
+                additional,
+                ..Default::default()
+            },
             tables: vec![],
             detected_languages: None,
             chunks: None,
@@ -181,12 +156,6 @@ impl DocumentExtractor for PptxExtractor {
         })
     }
 
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, path, config),
-        fields(
-            extractor.name = self.name(),
-        )
-    ))]
     async fn extract_file(&self, path: &Path, mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
         let path_str = path
             .to_str()
@@ -194,49 +163,35 @@ impl DocumentExtractor for PptxExtractor {
 
         let extract_images = config.images.as_ref().is_some_and(|img| img.extract_images);
 
-        let pptx_result =
-            crate::extraction::pptx::extract_pptx_from_path(path_str, extract_images, config.pages.as_ref())?;
+        let pptx_result = crate::extraction::pptx::extract_pptx_from_path(path_str, extract_images)?;
 
         let mut additional = std::collections::HashMap::new();
         additional.insert("slide_count".to_string(), serde_json::json!(pptx_result.slide_count));
         additional.insert("image_count".to_string(), serde_json::json!(pptx_result.image_count));
         additional.insert("table_count".to_string(), serde_json::json!(pptx_result.table_count));
 
-        let images = if extract_images {
-            // Image extraction is enabled, return images or empty vector
-            if !pptx_result.images.is_empty() {
-                #[cfg(feature = "ocr")]
-                {
-                    let processed_images = self.process_images_with_ocr(pptx_result.images, config).await?;
-                    Some(processed_images)
-                }
-                #[cfg(not(feature = "ocr"))]
-                {
-                    Some(pptx_result.images)
-                }
-            } else {
-                Some(vec![])
+        let images = if !pptx_result.images.is_empty() {
+            #[cfg(feature = "ocr")]
+            {
+                let processed_images = self.process_images_with_ocr(pptx_result.images, config).await?;
+                Some(processed_images)
+            }
+            #[cfg(not(feature = "ocr"))]
+            {
+                Some(pptx_result.images)
             }
         } else {
-            // Image extraction is disabled
             None
         };
 
-        let mut metadata = Metadata {
-            format: Some(crate::types::FormatMetadata::Pptx(pptx_result.metadata)),
-            additional,
-            ..Default::default()
-        };
-
-        if let Some(page_structure) = pptx_result.page_structure {
-            metadata.pages = Some(page_structure);
-        }
-
         Ok(ExtractionResult {
             content: pptx_result.content,
             mime_type: mime_type.to_string(),
-            metadata,
-            pages: pptx_result.page_contents,
+            metadata: Metadata {
+                format: Some(crate::types::FormatMetadata::Pptx(pptx_result.metadata)),
+                additional,
+                ..Default::default()
+            },
             tables: vec![],
             detected_languages: None,
             chunks: None,

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

@@ -5,7 +5,6 @@ use crate::core::config::ExtractionConfig;
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::{ExtractionResult, Metadata};
 use async_trait::async_trait;
-#[cfg(feature = "tokio-runtime")]
 use std::path::Path;
 
 /// Structured data extractor supporting JSON, YAML, and TOML.
@@ -43,13 +42,6 @@ impl Plugin for StructuredExtractor {
 
 #[async_trait]
 impl DocumentExtractor for StructuredExtractor {
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, content, _config),
-        fields(
-            extractor.name = self.name(),
-            content.size_bytes = content.len(),
-        )
-    ))]
     async fn extract_bytes(
         &self,
         content: &[u8],
@@ -81,7 +73,6 @@ impl DocumentExtractor for StructuredExtractor {
                 additional,
                 ..Default::default()
             },
-            pages: None,
             tables: vec![],
             detected_languages: None,
             chunks: None,
@@ -89,13 +80,6 @@ impl DocumentExtractor for StructuredExtractor {
         })
     }
 
-    #[cfg(feature = "tokio-runtime")]
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, path, config),
-        fields(
-            extractor.name = self.name(),
-        )
-    ))]
     async fn extract_file(&self, path: &Path, mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
         let bytes = tokio::fs::read(path).await?;
         self.extract_bytes(&bytes, mime_type, config).await

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

@@ -53,40 +53,28 @@ impl Plugin for PlainTextExtractor {
 
 #[async_trait]
 impl DocumentExtractor for PlainTextExtractor {
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, content, _config),
-        fields(
-            extractor.name = self.name(),
-            content.size_bytes = content.len(),
-        )
-    ))]
     async fn extract_bytes(
         &self,
         content: &[u8],
         mime_type: &str,
         _config: &ExtractionConfig,
     ) -> Result<ExtractionResult> {
-        let text = String::from_utf8_lossy(content).into_owned();
-        let text = text.trim_end_matches('\n').trim_end_matches('\r').to_string();
-        let line_count = text.lines().count();
-        let word_count = text.split_whitespace().count();
-        let character_count = text.len();
+        let text_result = parse_text(content, false)?;
 
         Ok(ExtractionResult {
-            content: text,
+            content: text_result.content,
             mime_type: mime_type.to_string(),
             metadata: crate::types::Metadata {
                 format: Some(crate::types::FormatMetadata::Text(crate::types::TextMetadata {
-                    line_count,
-                    word_count,
-                    character_count,
+                    line_count: text_result.line_count,
+                    word_count: text_result.word_count,
+                    character_count: text_result.character_count,
                     headers: None,
                     links: None,
                     code_blocks: None,
                 })),
                 ..Default::default()
             },
-            pages: None,
             tables: vec![],
             detected_languages: None,
             chunks: None,
@@ -95,7 +83,7 @@ impl DocumentExtractor for PlainTextExtractor {
     }
 
     fn supported_mime_types(&self) -> &[&str] {
-        &["text/plain", "text/csv", "text/tab-separated-values"]
+        &["text/plain"]
     }
 
     fn priority(&self) -> i32 {
@@ -150,13 +138,6 @@ impl Plugin for MarkdownExtractor {
 
 #[async_trait]
 impl DocumentExtractor for MarkdownExtractor {
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, content, _config),
-        fields(
-            extractor.name = self.name(),
-            content.size_bytes = content.len(),
-        )
-    ))]
     async fn extract_bytes(
         &self,
         content: &[u8],
@@ -179,7 +160,6 @@ impl DocumentExtractor for MarkdownExtractor {
                 })),
                 ..Default::default()
             },
-            pages: None,
             tables: vec![],
             detected_languages: None,
             chunks: None,
@@ -247,10 +227,7 @@ mod tests {
         let extractor = PlainTextExtractor::new();
         assert_eq!(extractor.name(), "plain-text-extractor");
         assert_eq!(extractor.version(), env!("CARGO_PKG_VERSION"));
-        assert_eq!(
-            extractor.supported_mime_types(),
-            &["text/plain", "text/csv", "text/tab-separated-values"]
-        );
+        assert_eq!(extractor.supported_mime_types(), &["text/plain"]);
         assert_eq!(extractor.priority(), 50);
     }
 

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

@@ -3,7 +3,6 @@
 use crate::Result;
 use crate::core::config::ExtractionConfig;
 use crate::extraction::xml::parse_xml;
-use crate::extractors::SyncExtractor;
 use crate::plugins::{DocumentExtractor, Plugin};
 use crate::types::ExtractionResult;
 use async_trait::async_trait;
@@ -52,8 +51,14 @@ impl Plugin for XmlExtractor {
     }
 }
 
-impl SyncExtractor for XmlExtractor {
-    fn extract_sync(&self, content: &[u8], mime_type: &str, _config: &ExtractionConfig) -> Result<ExtractionResult> {
+#[async_trait]
+impl DocumentExtractor for XmlExtractor {
+    async fn extract_bytes(
+        &self,
+        content: &[u8],
+        mime_type: &str,
+        _config: &ExtractionConfig,
+    ) -> Result<ExtractionResult> {
         let xml_result = parse_xml(content, false)?;
 
         Ok(ExtractionResult {
@@ -70,28 +75,8 @@ impl SyncExtractor for XmlExtractor {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         })
     }
-}
-
-#[async_trait]
-impl DocumentExtractor for XmlExtractor {
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, content, config),
-        fields(
-            extractor.name = self.name(),
-            content.size_bytes = content.len(),
-        )
-    ))]
-    async fn extract_bytes(
-        &self,
-        content: &[u8],
-        mime_type: &str,
-        config: &ExtractionConfig,
-    ) -> Result<ExtractionResult> {
-        self.extract_sync(content, mime_type, config)
-    }
 
     fn supported_mime_types(&self) -> &[&str] {
         &["application/xml", "text/xml", "image/svg+xml"]
@@ -100,10 +85,6 @@ impl DocumentExtractor for XmlExtractor {
     fn priority(&self) -> i32 {
         50
     }
-
-    fn as_sync_extractor(&self) -> Option<&dyn crate::extractors::SyncExtractor> {
-        Some(self)
-    }
 }
 
 #[cfg(test)]

data/vendor/kreuzberg/src/keywords/processor.rs

@@ -45,8 +45,7 @@ impl Plugin for KeywordExtractor {
     }
 }
 
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[async_trait]
 impl PostProcessor for KeywordExtractor {
     async fn process(&self, result: &mut ExtractionResult, config: &ExtractionConfig) -> Result<()> {
         let keyword_config = match &config.keywords {
@@ -113,7 +112,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         processor.process(&mut result, &config).await.unwrap();
@@ -142,7 +140,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         processor.process(&mut result, &config).await.unwrap();
@@ -167,7 +164,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         processor.process(&mut result, &config).await.unwrap();
@@ -192,7 +188,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         processor.process(&mut result, &config).await.unwrap();
@@ -228,7 +223,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let config_with_keywords = ExtractionConfig {
@@ -253,7 +247,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let long_result = ExtractionResult {
@@ -264,7 +257,6 @@ machine learning that uses neural networks with multiple layers.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let short_duration = processor.estimated_duration_ms(&short_result);

data/vendor/kreuzberg/src/keywords/rake.rs

@@ -248,6 +248,7 @@ mod tests {
         let english_text = "Natural language processing is a subfield of artificial intelligence.";
         let config = KeywordConfig::rake().with_language("fr");
         let keywords = extract_keywords_rake(english_text, &config).unwrap();
+        dbg!(&keywords);
         assert!(
             !keywords.is_empty(),
             "Should fall back to English stopwords and extract keywords"

data/vendor/kreuzberg/src/language_detection/mod.rs

@@ -4,13 +4,8 @@
 
 use crate::Result;
 use crate::core::config::LanguageDetectionConfig;
-use once_cell::sync::Lazy;
-use std::sync::Arc;
 use whatlang::{Lang, detect};
 
-pub mod processor;
-pub use processor::LanguageDetector;
-
 /// Detect languages in text using whatlang.
 ///
 /// Returns a list of detected language codes (ISO 639-3 format).
@@ -185,44 +180,6 @@ fn lang_to_iso639_3(lang: Lang) -> String {
     .to_string()
 }
 
-/// Register the language detection processor with the global registry.
-///
-/// This function should be called once at application startup to register
-/// the language detection post-processor.
-///
-/// **Note:** This is called automatically on first use.
-/// Explicit calling is optional.
-pub fn register_language_detection_processor() -> Result<()> {
-    let registry = crate::plugins::registry::get_post_processor_registry();
-    let mut registry = registry
-        .write()
-        .map_err(|e| crate::KreuzbergError::Other(format!("Post-processor registry lock poisoned: {}", e)))?;
-
-    registry.register(Arc::new(LanguageDetector), 40)?;
-
-    Ok(())
-}
-
-/// Lazy-initialized flag that ensures language detection processor is registered exactly once.
-///
-/// This static is accessed on first use to automatically register the
-/// language detection processor with the plugin registry.
-static PROCESSOR_INITIALIZED: Lazy<Result<()>> = Lazy::new(register_language_detection_processor);
-
-/// Ensure the language detection processor is registered.
-///
-/// This function is called automatically when needed.
-/// It's safe to call multiple times - registration only happens once.
-pub fn ensure_initialized() -> Result<()> {
-    PROCESSOR_INITIALIZED
-        .as_ref()
-        .map(|_| ())
-        .map_err(|e| crate::KreuzbergError::Plugin {
-            message: format!("Failed to register language detection processor: {}", e),
-            plugin_name: "language-detection".to_string(),
-        })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -719,57 +676,6 @@ mod tests {
         assert_eq!(langs[0], "eng");
     }
 
-    #[test]
-    fn test_medical_terminology() {
-        let text = "The patient presented with acute myocardial infarction and was administered thrombolytic therapy. \
-                   The electrocardiogram showed significant ST-segment elevation in the anterior leads. \
-                   Cardiac biomarkers including troponin and creatine kinase were significantly elevated.";
-        let config = LanguageDetectionConfig {
-            enabled: true,
-            min_confidence: 0.5,
-            detect_multiple: false,
-        };
-
-        let result = detect_languages(text, &config).unwrap();
-        assert!(result.is_some());
-        let langs = result.unwrap();
-        assert_eq!(langs[0], "eng");
-    }
-
-    #[test]
-    fn test_legal_terminology() {
-        let text = "The plaintiff hereby alleges that the defendant breached the contractual obligations as stipulated in the aforementioned agreement. \
-                   Pursuant to clause 5.2, the defendant was required to provide adequate consideration within thirty days of execution. \
-                   The court finds that the preponderance of evidence supports the plaintiff's claims.";
-        let config = LanguageDetectionConfig {
-            enabled: true,
-            min_confidence: 0.5,
-            detect_multiple: false,
-        };
-
-        let result = detect_languages(text, &config).unwrap();
-        assert!(result.is_some());
-        let langs = result.unwrap();
-        assert_eq!(langs[0], "eng");
-    }
-
-    #[test]
-    fn test_scientific_terminology() {
-        let text = "The experimental protocol involved spectrophotometric analysis using ultraviolet-visible spectroscopy. \
-                   Quantum mechanical calculations were performed using density functional theory at the B3LYP level. \
-                   The results demonstrated significant correlation between molecular structure and optical properties.";
-        let config = LanguageDetectionConfig {
-            enabled: true,
-            min_confidence: 0.5,
-            detect_multiple: false,
-        };
-
-        let result = detect_languages(text, &config).unwrap();
-        assert!(result.is_some());
-        let langs = result.unwrap();
-        assert_eq!(langs[0], "eng");
-    }
-
     #[test]
     fn test_code_with_comments() {
         let text = r#"
@@ -845,6 +751,57 @@ mod tests {
         assert_eq!(langs[0], "eng");
     }
 
+    #[test]
+    fn test_medical_terminology() {
+        let text = "The patient presented with acute myocardial infarction and was administered thrombolytic therapy. \
+                   The electrocardiogram showed significant ST-segment elevation in the anterior leads. \
+                   Cardiac biomarkers including troponin and creatine kinase were significantly elevated.";
+        let config = LanguageDetectionConfig {
+            enabled: true,
+            min_confidence: 0.5,
+            detect_multiple: false,
+        };
+
+        let result = detect_languages(text, &config).unwrap();
+        assert!(result.is_some());
+        let langs = result.unwrap();
+        assert_eq!(langs[0], "eng");
+    }
+
+    #[test]
+    fn test_legal_terminology() {
+        let text = "The plaintiff hereby alleges that the defendant breached the contractual obligations as stipulated in the aforementioned agreement. \
+                   Pursuant to clause 5.2, the defendant was required to provide adequate consideration within thirty days of execution. \
+                   The court finds that the preponderance of evidence supports the plaintiff's claims.";
+        let config = LanguageDetectionConfig {
+            enabled: true,
+            min_confidence: 0.5,
+            detect_multiple: false,
+        };
+
+        let result = detect_languages(text, &config).unwrap();
+        assert!(result.is_some());
+        let langs = result.unwrap();
+        assert_eq!(langs[0], "eng");
+    }
+
+    #[test]
+    fn test_scientific_terminology() {
+        let text = "The experimental protocol involved spectrophotometric analysis using ultraviolet-visible spectroscopy. \
+                   Quantum mechanical calculations were performed using density functional theory at the B3LYP level. \
+                   The results demonstrated significant correlation between molecular structure and optical properties.";
+        let config = LanguageDetectionConfig {
+            enabled: true,
+            min_confidence: 0.5,
+            detect_multiple: false,
+        };
+
+        let result = detect_languages(text, &config).unwrap();
+        assert!(result.is_some());
+        let langs = result.unwrap();
+        assert_eq!(langs[0], "eng");
+    }
+
     #[test]
     fn test_latin_cyrillic_mix() {
         let text = format!(

data/vendor/kreuzberg/src/lib.rs

@@ -39,10 +39,11 @@ pub mod core;
 pub mod error;
 pub mod extraction;
 pub mod extractors;
-pub mod panic_context;
 pub mod plugins;
 pub mod text;
 pub mod types;
+
+#[cfg(feature = "quality")]
 pub mod utils;
 
 #[cfg(feature = "api")]
@@ -78,34 +79,21 @@ pub mod pdf;
 pub use error::{KreuzbergError, Result};
 pub use types::*;
 
-#[cfg(feature = "tokio-runtime")]
-pub use core::extractor::{batch_extract_bytes, batch_extract_file};
-pub use core::extractor::{extract_bytes, extract_file};
-
-pub use core::extractor::{batch_extract_bytes_sync, extract_bytes_sync};
+pub use core::extractor::{batch_extract_bytes, batch_extract_file, extract_bytes, extract_file};
 
-#[cfg(feature = "tokio-runtime")]
-pub use core::extractor::{batch_extract_file_sync, extract_file_sync};
+pub use core::extractor::{batch_extract_bytes_sync, batch_extract_file_sync, extract_bytes_sync, extract_file_sync};
 
 pub use core::config::{
     ChunkingConfig, EmbeddingConfig, EmbeddingModelType, ExtractionConfig, ImageExtractionConfig,
-    LanguageDetectionConfig, OcrConfig, PostProcessorConfig, TokenReductionConfig,
+    LanguageDetectionConfig, OcrConfig, PdfConfig, PostProcessorConfig, TokenReductionConfig,
 };
 
-#[cfg(feature = "api")]
-pub use core::server_config::ServerConfig;
-
-#[cfg(feature = "pdf")]
-pub use core::config::PdfConfig;
-
 pub use core::mime::{
     DOCX_MIME_TYPE, EXCEL_MIME_TYPE, HTML_MIME_TYPE, JSON_MIME_TYPE, MARKDOWN_MIME_TYPE, PDF_MIME_TYPE,
     PLAIN_TEXT_MIME_TYPE, POWER_POINT_MIME_TYPE, XML_MIME_TYPE, detect_mime_type, detect_mime_type_from_bytes,
     detect_or_validate, get_extensions_for_mime, validate_mime_type,
 };
 
-pub use core::formats::{KNOWN_FORMATS, is_valid_format_field};
-
 pub use plugins::registry::{
     get_document_extractor_registry, get_ocr_backend_registry, get_post_processor_registry, get_validator_registry,
 };