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

data/vendor/kreuzberg/tests/config_loading_tests.rs

@@ -124,6 +124,7 @@ ocr:
 fn test_from_file_nonexistent_path_fails() {
     let result = ExtractionConfig::from_file("/nonexistent/path/config.toml");
     assert!(result.is_err(), "Should fail for nonexistent path: {:?}", result);
+    // Error can be Io or other types depending on the implementation
 }
 
 /// Test from_file with malformed TOML fails.
@@ -141,6 +142,7 @@ enabled = true
 
     let result = ExtractionConfig::from_file(&config_path);
     assert!(result.is_err(), "Should fail for malformed TOML: {:?}", result);
+    // Error handling varies - just ensure it failed
 }
 
 /// Test from_file with malformed JSON fails.
@@ -162,6 +164,7 @@ fn test_from_file_malformed_json_fails() {
 
     let result = ExtractionConfig::from_file(&config_path);
     assert!(result.is_err(), "Should fail for malformed JSON: {:?}", result);
+    // Error handling varies - just ensure it failed
 }
 
 /// Test from_file with malformed YAML fails.
@@ -180,6 +183,7 @@ ocr:
 
     let result = ExtractionConfig::from_file(&config_path);
     assert!(result.is_err(), "Should fail for malformed YAML: {:?}", result);
+    // Error handling varies - just ensure it failed
 }
 
 /// Test from_file with empty file uses defaults.
@@ -194,6 +198,7 @@ fn test_from_file_empty_file_uses_defaults() {
     assert!(config.is_ok(), "Should load empty file successfully");
 
     let config = config.unwrap();
+    // Should have default values
     assert!(config.ocr.is_none(), "Default config should have no OCR");
     assert!(config.chunking.is_none(), "Default config should have no chunking");
 }
@@ -209,18 +214,22 @@ fn test_from_file_unsupported_extension_fails() {
     let result = ExtractionConfig::from_file(&config_path);
     assert!(result.is_err(), "Should fail for unsupported extension: {:?}", result);
 
-    if let Err(KreuzbergError::Validation { message, .. }) = result {
-        assert!(
-            message.contains("format") || message.contains("extension") || message.contains("Unsupported"),
-            "Error should mention format/extension: {}",
-            message
-        );
+    match result {
+        Err(KreuzbergError::Validation { message, .. }) => {
+            assert!(
+                message.contains("format") || message.contains("extension") || message.contains("Unsupported"),
+                "Error should mention format/extension: {}",
+                message
+            );
+        }
+        _ => {
+            // Some other error is also acceptable
+        }
     }
 }
 
 /// Test discover() finds config in current directory.
 #[test]
-#[serial_test::serial]
 fn test_discover_finds_config_in_current_dir() {
     let temp_dir = TempDir::new().unwrap();
     let config_path = temp_dir.path().join("kreuzberg.toml");
@@ -232,11 +241,13 @@ enabled = true
 
     fs::write(&config_path, toml_content).unwrap();
 
+    // Change to temp directory
     let original_dir = std::env::current_dir().unwrap();
     std::env::set_current_dir(temp_dir.path()).unwrap();
 
     let result = ExtractionConfig::discover();
 
+    // Restore original directory
     std::env::set_current_dir(original_dir).unwrap();
 
     assert!(result.is_ok(), "Discover should succeed");
@@ -247,7 +258,6 @@ enabled = true
 
 /// Test discover() finds config in parent directory.
 #[test]
-#[serial_test::serial]
 fn test_discover_finds_config_in_parent_dir() {
     let temp_dir = TempDir::new().unwrap();
     let config_path = temp_dir.path().join("kreuzberg.toml");
@@ -259,14 +269,17 @@ enabled = true
 
     fs::write(&config_path, toml_content).unwrap();
 
+    // Create subdirectory
     let sub_dir = temp_dir.path().join("subdir");
     fs::create_dir(&sub_dir).unwrap();
 
+    // Change to subdirectory
     let original_dir = std::env::current_dir().unwrap();
     std::env::set_current_dir(&sub_dir).unwrap();
 
     let result = ExtractionConfig::discover();
 
+    // Restore original directory
     std::env::set_current_dir(original_dir).unwrap();
 
     assert!(result.is_ok(), "Discover should succeed");
@@ -277,39 +290,44 @@ enabled = true
 
 /// Test discover() returns None when no config found.
 #[test]
-#[serial_test::serial]
 fn test_discover_returns_none_when_not_found() {
     let temp_dir = TempDir::new().unwrap();
     let sub_dir = temp_dir.path().join("subdir");
     fs::create_dir(&sub_dir).unwrap();
 
+    // Change to subdirectory (no config files)
     let original_dir = std::env::current_dir().unwrap();
     std::env::set_current_dir(&sub_dir).unwrap();
 
     let result = ExtractionConfig::discover();
 
+    // Restore original directory
     std::env::set_current_dir(original_dir).unwrap();
 
     assert!(result.is_ok(), "Discover should succeed even when no config found");
     let _config = result.unwrap();
+    // May return None or may find a config in parent directories (e.g., repository root)
+    // Just verify it doesn't error - the specific behavior depends on the directory structure
 }
 
 /// Test discover() prefers certain file names.
 #[test]
-#[serial_test::serial]
 fn test_discover_file_name_preference() {
     let temp_dir = TempDir::new().unwrap();
 
+    // Create multiple config files
     fs::write(temp_dir.path().join("kreuzberg.toml"), "[ocr]\nenabled = true").unwrap();
     fs::write(temp_dir.path().join(".kreuzberg.toml"), "[ocr]\nenabled = false").unwrap();
 
     let original_dir = std::env::current_dir().unwrap();
     if std::env::set_current_dir(temp_dir.path()).is_err() {
+        // Skip this test if we can't change directory
         return;
     }
 
     let result = ExtractionConfig::discover();
 
+    // Always restore directory even if test fails
     let _ = std::env::set_current_dir(original_dir);
 
     assert!(result.is_ok(), "Discover should succeed");
@@ -319,7 +337,6 @@ fn test_discover_file_name_preference() {
 
 /// Test discover() with nested directories.
 #[test]
-#[serial_test::serial]
 fn test_discover_with_nested_directories() {
     let temp_dir = TempDir::new().unwrap();
     let config_path = temp_dir.path().join("kreuzberg.toml");
@@ -331,18 +348,22 @@ enabled = true
 
     fs::write(&config_path, toml_content).unwrap();
 
+    // Create nested subdirectories
     let level1 = temp_dir.path().join("level1");
     let level2 = level1.join("level2");
     let level3 = level2.join("level3");
     fs::create_dir_all(&level3).unwrap();
 
+    // Change to deepest directory
     let original_dir = std::env::current_dir().unwrap();
     if std::env::set_current_dir(&level3).is_err() {
+        // Skip this test if we can't change directory
         return;
     }
 
     let result = ExtractionConfig::discover();
 
+    // Always restore directory even if test fails
     let _ = std::env::set_current_dir(&original_dir);
 
     assert!(result.is_ok(), "Discover should succeed");
@@ -389,7 +410,6 @@ extract_images = true
         "Should have language detection config"
     );
     assert!(config.images.is_some(), "Should have image extraction config");
-    #[cfg(feature = "pdf")]
     assert!(config.pdf_options.is_some(), "Should have PDF config");
 }
 
@@ -399,6 +419,7 @@ fn test_from_file_with_invalid_values() {
     let temp_dir = TempDir::new().unwrap();
     let config_path = temp_dir.path().join("config.toml");
 
+    // Negative values should be rejected during deserialization or validation
     let toml_content = r#"
 [chunking]
 max_chars = -1000
@@ -408,9 +429,11 @@ max_overlap = -100
     fs::write(&config_path, toml_content).unwrap();
 
     let result = ExtractionConfig::from_file(&config_path);
-    if let Ok(config) = result
-        && let Some(chunking) = config.chunking
-    {
-        assert!(chunking.max_chars > 0, "max_chars should be positive");
+    // Should either fail parsing or have clamped values
+    if let Ok(config) = result {
+        // If it succeeds, values should be reasonable
+        if let Some(chunking) = config.chunking {
+            assert!(chunking.max_chars > 0, "max_chars should be positive");
+        }
     }
 }

data/vendor/kreuzberg/tests/core_integration.rs

@@ -11,18 +11,6 @@ use std::fs::{self, File};
 use std::io::Write;
 use tempfile::tempdir;
 
-fn trim_trailing_newlines(value: &str) -> &str {
-    value.trim_end_matches(['\n', '\r'])
-}
-
-fn assert_text_content(actual: &str, expected: &str) {
-    assert_eq!(
-        trim_trailing_newlines(actual),
-        expected,
-        "Content mismatch after trimming trailing newlines"
-    );
-}
-
 /// Test basic file extraction with MIME detection.
 #[tokio::test]
 async fn test_extract_file_basic() {
@@ -37,7 +25,7 @@ async fn test_extract_file_basic() {
     assert!(result.is_ok(), "Basic file extraction should succeed");
     let result = result.unwrap();
 
-    assert_text_content(&result.content, "Hello, Kreuzberg!");
+    assert_eq!(result.content, "Hello, Kreuzberg!");
     assert_eq!(result.mime_type, "text/plain");
     assert!(result.chunks.is_none(), "Chunks should be None without chunking config");
     assert!(result.detected_languages.is_none(), "Language detection not enabled");
@@ -185,12 +173,7 @@ async fn test_batch_extract_bytes_concurrency() {
         (b"content 5".as_slice(), "text/plain"),
     ];
 
-    let owned_contents: Vec<(Vec<u8>, String)> = contents
-        .into_iter()
-        .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
-        .collect();
-
-    let results = batch_extract_bytes(owned_contents, &config).await;
+    let results = batch_extract_bytes(contents, &config).await;
     assert!(results.is_ok());
 
     let results = results.unwrap();
@@ -198,12 +181,7 @@ async fn test_batch_extract_bytes_concurrency() {
 
     for (i, result) in results.iter().enumerate() {
         let expected_content = format!("content {}", i + 1);
-        assert_eq!(
-            trim_trailing_newlines(&result.content),
-            expected_content,
-            "Content mismatch for item {}",
-            i
-        );
+        assert_eq!(result.content, expected_content, "Content mismatch for item {}", i);
         assert_eq!(result.mime_type, "text/plain", "MIME type should be text/plain");
         assert!(result.chunks.is_none(), "Chunks should be None without chunking config");
         assert!(result.detected_languages.is_none(), "Language detection not enabled");
@@ -223,13 +201,13 @@ fn test_sync_wrappers() {
     let result = extract_file_sync(&file_path, None, &config);
     assert!(result.is_ok(), "Sync file extraction should succeed");
     let extraction = result.unwrap();
-    assert_text_content(&extraction.content, "sync content");
+    assert_eq!(extraction.content, "sync content");
     assert!(extraction.chunks.is_none(), "Chunks should be None");
 
     let result = extract_bytes_sync(b"test bytes", "text/plain", &config);
     assert!(result.is_ok(), "Sync bytes extraction should succeed");
     let extraction = result.unwrap();
-    assert_text_content(&extraction.content, "test bytes");
+    assert_eq!(extraction.content, "test bytes");
     assert!(extraction.chunks.is_none(), "Chunks should be None");
 
     let paths = vec![file_path];
@@ -237,19 +215,15 @@ fn test_sync_wrappers() {
     assert!(results.is_ok(), "Batch sync file should succeed");
     let results = results.unwrap();
     assert_eq!(results.len(), 1);
-    assert_text_content(&results[0].content, "sync content");
+    assert_eq!(results[0].content, "sync content");
     assert!(results[0].chunks.is_none(), "Chunks should be None");
 
     let contents = vec![(b"test".as_slice(), "text/plain")];
-    let owned_contents: Vec<(Vec<u8>, String)> = contents
-        .into_iter()
-        .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
-        .collect();
-    let results = batch_extract_bytes_sync(owned_contents, &config);
+    let results = batch_extract_bytes_sync(contents, &config);
     assert!(results.is_ok(), "Batch bytes sync should succeed");
     let results = results.unwrap();
     assert_eq!(results.len(), 1);
-    assert_text_content(&results[0].content, "test");
+    assert_eq!(results[0].content, "test");
     assert!(results[0].chunks.is_none(), "Chunks should be None");
 }
 
@@ -441,7 +415,7 @@ async fn test_pipeline_execution() {
     assert!(result.is_ok(), "Pipeline execution should succeed");
 
     let result = result.unwrap();
-    assert_text_content(&result.content, "pipeline content");
+    assert_eq!(result.content, "pipeline content");
     assert_eq!(result.mime_type, "text/plain");
     assert!(result.chunks.is_none(), "Chunks should be None without chunking config");
     assert!(result.detected_languages.is_none(), "Language detection not enabled");

data/vendor/kreuzberg/tests/csv_integration.rs

@@ -1,6 +1,6 @@
 //! CSV and spreadsheet integration tests.
 //!
-//! Tests for CSV and TSV extraction.
+//! Tests for CSV and TSV extraction via Pandoc.
 //! Validates data extraction, custom delimiters, quoted fields, and edge cases.
 
 use kreuzberg::core::config::ExtractionConfig;
@@ -15,13 +15,14 @@ async fn test_csv_basic_extraction() {
 
     let csv_content = b"Name,Age,City\nAlice,30,NYC\nBob,25,LA";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert_eq!(extraction.mime_type, "text/csv");
     assert!(
@@ -54,13 +55,14 @@ async fn test_csv_with_headers() {
 
     let csv_content = b"Product,Price,Quantity\nApple,1.50,100\nBanana,0.75,200\nOrange,2.00,150";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -103,13 +105,14 @@ async fn test_csv_custom_delimiter() {
 
     let csv_content = b"Name;Age;City\nAlice;30;NYC\nBob;25;LA";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -135,13 +138,14 @@ async fn test_tsv_file() {
 
     let tsv_content = b"Name\tAge\tCity\nAlice\t30\tNYC\nBob\t25\tLA";
 
-    let extraction = match extract_bytes(tsv_content, "text/tab-separated-values", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: TSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(tsv_content, "text/tab-separated-values", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert_eq!(extraction.mime_type, "text/tab-separated-values");
     assert!(
@@ -171,13 +175,14 @@ async fn test_csv_quoted_fields() {
     let csv_content =
         b"Name,Description,Price\n\"Smith, John\",\"Product A, premium\",100\n\"Doe, Jane\",\"Product B, standard\",50";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -207,13 +212,14 @@ async fn test_csv_special_characters() {
 
     let csv_content = "Name,City,Emoji\nAlice,Tokyo 東京,🎉\nBob,París,✅\nCarlos,Москва,🌍".as_bytes();
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -245,13 +251,14 @@ async fn test_csv_large_file() {
         csv_content.push_str(&format!("{},Item{},{}.00\n", i, i, i * 10));
     }
 
-    let extraction = match extract_bytes(csv_content.as_bytes(), "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content.as_bytes(), "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -315,13 +322,14 @@ async fn test_csv_headers_only() {
 
     let csv_content = b"Name,Age,City";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -346,13 +354,14 @@ async fn test_csv_blank_lines() {
 
     let csv_content = b"Name,Age\nAlice,30\n\nBob,25\n\nCarlos,35";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),
@@ -374,13 +383,14 @@ async fn test_csv_numeric_data() {
 
     let csv_content = b"ID,Price,Quantity,Discount\n1,19.99,100,0.15\n2,29.99,50,0.20\n3,9.99,200,0.10";
 
-    let extraction = match extract_bytes(csv_content, "text/csv", &config).await {
-        Ok(result) => result,
-        Err(_) => {
-            println!("Skipping test: CSV extraction not available");
-            return;
-        }
-    };
+    let result = extract_bytes(csv_content, "text/csv", &config).await;
+
+    if result.is_err() {
+        println!("Skipping test: Pandoc may not be installed");
+        return;
+    }
+
+    let extraction = result.unwrap();
 
     assert!(
         extraction.chunks.is_none(),

data/vendor/kreuzberg/tests/docx_metadata_extraction_test.rs

@@ -2,10 +2,15 @@
 
 #![cfg(feature = "office")]
 
-use kreuzberg::{ExtractionConfig, extract_file};
+use kreuzberg::extraction::pandoc::extract_file;
 
 #[tokio::test]
 async fn test_docx_full_metadata_extraction() {
+    if kreuzberg::extraction::pandoc::validate_pandoc_version().await.is_err() {
+        println!("Skipping test: Pandoc not available");
+        return;
+    }
+
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
         .unwrap()
@@ -18,7 +23,7 @@ async fn test_docx_full_metadata_extraction() {
         return;
     }
 
-    let result = extract_file(&test_file, None, &ExtractionConfig::default())
+    let result = extract_file(&test_file, "docx")
         .await
         .expect("Should extract DOCX successfully");
 
@@ -29,66 +34,63 @@ async fn test_docx_full_metadata_extraction() {
     );
 
     assert_eq!(
-        result.metadata.additional.get("created_by").and_then(|v| v.as_str()),
+        result.metadata.get("created_by").and_then(|v| v.as_str()),
         Some("Christoph Auer"),
         "Should have correct creator"
     );
     assert_eq!(
-        result.metadata.additional.get("modified_by").and_then(|v| v.as_str()),
+        result.metadata.get("modified_by").and_then(|v| v.as_str()),
         Some("Maxim Lysak"),
         "Should have correct last modified by"
     );
     assert_eq!(
-        result.metadata.additional.get("created_at").and_then(|v| v.as_str()),
+        result.metadata.get("created_at").and_then(|v| v.as_str()),
         Some("2024-10-09T12:43:00Z"),
         "Should have correct creation date"
     );
     assert_eq!(
-        result.metadata.additional.get("revision").and_then(|v| v.as_str()),
+        result.metadata.get("revision").and_then(|v| v.as_str()),
         Some("7"),
         "Should have revision number"
     );
 
     assert_eq!(
-        result.metadata.additional.get("page_count").and_then(|v| v.as_i64()),
+        result.metadata.get("page_count").and_then(|v| v.as_i64()),
         Some(2),
         "Should have 2 pages"
     );
     assert_eq!(
-        result.metadata.additional.get("word_count").and_then(|v| v.as_i64()),
+        result.metadata.get("word_count").and_then(|v| v.as_i64()),
         Some(108),
         "Should have 108 words"
     );
     assert_eq!(
-        result
-            .metadata
-            .additional
-            .get("character_count")
-            .and_then(|v| v.as_i64()),
+        result.metadata.get("character_count").and_then(|v| v.as_i64()),
         Some(620),
         "Should have 620 characters"
     );
     assert_eq!(
-        result.metadata.additional.get("line_count").and_then(|v| v.as_i64()),
+        result.metadata.get("line_count").and_then(|v| v.as_i64()),
         Some(5),
         "Should have 5 lines"
     );
     assert_eq!(
-        result
-            .metadata
-            .additional
-            .get("paragraph_count")
-            .and_then(|v| v.as_i64()),
+        result.metadata.get("paragraph_count").and_then(|v| v.as_i64()),
         Some(1),
         "Should have 1 paragraph"
     );
 
     println!("✅ DOCX metadata extraction test passed!");
-    println!("   Found {} metadata fields", result.metadata.additional.len());
+    println!("   Found {} metadata fields", result.metadata.len());
 }
 
 #[tokio::test]
 async fn test_docx_minimal_metadata_extraction() {
+    if kreuzberg::extraction::pandoc::validate_pandoc_version().await.is_err() {
+        println!("Skipping test: Pandoc not available");
+        return;
+    }
+
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
         .unwrap()
@@ -101,19 +103,19 @@ async fn test_docx_minimal_metadata_extraction() {
         return;
     }
 
-    let result = extract_file(&test_file, None, &ExtractionConfig::default())
+    let result = extract_file(&test_file, "docx")
         .await
         .expect("Should extract DOCX successfully");
 
     assert!(!result.content.is_empty(), "Content should not be empty");
 
     assert_eq!(
-        result.metadata.additional.get("page_count").and_then(|v| v.as_i64()),
+        result.metadata.get("page_count").and_then(|v| v.as_i64()),
         Some(1),
         "Should have 1 page"
     );
     assert_eq!(
-        result.metadata.additional.get("word_count").and_then(|v| v.as_i64()),
+        result.metadata.get("word_count").and_then(|v| v.as_i64()),
         Some(520),
         "Should have 520 words"
     );