@kreuzberg/wasm 4.0.7 → 4.1.0

package/README.md

@@ -22,7 +22,7 @@
     <img src="https://img.shields.io/maven-central/v/dev.kreuzberg/kreuzberg?label=Java&color=007ec6" alt="Java">
   </a>
   <a href="https://github.com/kreuzberg-dev/kreuzberg/releases">
-    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.0.0" alt="Go">
+    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.1.0" alt="Go">
   </a>
   <a href="https://www.nuget.org/packages/Kreuzberg/">
     <img src="https://img.shields.io/nuget/v/Kreuzberg?label=C%23&color=007ec6" alt="C#">
@@ -33,6 +33,9 @@
   <a href="https://rubygems.org/gems/kreuzberg">
     <img src="https://img.shields.io/gem/v/kreuzberg?label=Ruby&color=007ec6" alt="Ruby">
   </a>
+  <a href="https://github.com/kreuzberg-dev/kreuzberg/pkgs/container/kreuzberg">
+    <img src="https://img.shields.io/badge/Docker-007ec6?logo=docker&logoColor=white" alt="Docker">
+  </a>
 
   <!-- Project Info -->
   <a href="https://github.com/kreuzberg-dev/kreuzberg/blob/main/LICENSE">
@@ -184,7 +187,7 @@ interface DocumentJob {
 	mimeType: string;
 }
 
-async function processBatch(documents: DocumentJob[], concurrency: number = 3) {
+async function _processBatch(documents: DocumentJob[], concurrency: number = 3) {
 	await initWasm();
 
 	const results: Record<string, string> = {};
@@ -441,7 +444,7 @@ interface DocumentJob {
 	mimeType: string;
 }
 
-async function processBatch(documents: DocumentJob[], concurrency: number = 3) {
+async function _processBatch(documents: DocumentJob[], concurrency: number = 3) {
 	await initWasm();
 
 	const results: Record<string, string> = {};

package/dist/extraction/batch.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Batch extraction functions
+ *
+ * Provides batch processing capabilities for extracting from multiple documents
+ * in a single operation for improved efficiency.
+ */
+import type { ExtractionConfig as ExtractionConfigType, ExtractionResult } from "../types.d.ts";
+/**
+ * Batch extract content from multiple byte arrays asynchronously
+ *
+ * Extracts content from multiple documents in a single batch operation,
+ * allowing for more efficient processing of multiple files.
+ *
+ * @param files - Array of objects containing data (Uint8Array) and mimeType (string)
+ * @param config - Optional extraction configuration applied to all files
+ * @returns Promise resolving to array of extraction results
+ * @throws {Error} If WASM module is not initialized or extraction fails
+ *
+ * @example
+ * ```typescript
+ * const files = [
+ *   { data: pdfBytes, mimeType: 'application/pdf' },
+ *   { data: docxBytes, mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
+ * ];
+ * const results = await batchExtractBytes(files);
+ * results.forEach((result) => console.log(result.content));
+ * ```
+ */
+export declare function batchExtractBytes(files: Array<{
+    data: Uint8Array;
+    mimeType: string;
+}>, config?: ExtractionConfigType | null): Promise<ExtractionResult[]>;
+/**
+ * Batch extract content from multiple byte arrays synchronously
+ *
+ * Synchronous version of batchExtractBytes. Extracts content from multiple documents
+ * in a single batch operation without async operations.
+ *
+ * @param files - Array of objects containing data (Uint8Array) and mimeType (string)
+ * @param config - Optional extraction configuration applied to all files
+ * @returns Array of extraction results
+ * @throws {Error} If WASM module is not initialized or extraction fails
+ *
+ * @example
+ * ```typescript
+ * const files = [
+ *   { data: pdfBytes, mimeType: 'application/pdf' },
+ *   { data: docxBytes, mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
+ * ];
+ * const results = batchExtractBytesSync(files);
+ * results.forEach((result) => console.log(result.content));
+ * ```
+ */
+export declare function batchExtractBytesSync(files: Array<{
+    data: Uint8Array;
+    mimeType: string;
+}>, config?: ExtractionConfigType | null): ExtractionResult[];
+/**
+ * Batch extract content from multiple File objects asynchronously
+ *
+ * Convenience function that converts File objects to Uint8Array and calls batchExtractBytes.
+ * Automatically uses the file.type as MIME type if available.
+ *
+ * @param files - Array of File objects to extract from
+ * @param config - Optional extraction configuration applied to all files
+ * @returns Promise resolving to array of extraction results
+ * @throws {Error} If WASM module is not initialized, files cannot be read, or extraction fails
+ *
+ * @example
+ * ```typescript
+ * const fileInput = document.getElementById('files');
+ * const files = Array.from(fileInput.files ?? []);
+ * const results = await batchExtractFiles(files);
+ * results.forEach((result, index) => {
+ *   console.log(`File ${index}: ${result.content.substring(0, 50)}...`);
+ * });
+ * ```
+ */
+export declare function batchExtractFiles(files: File[], config?: ExtractionConfigType | null): Promise<ExtractionResult[]>;
+//# sourceMappingURL=batch.d.ts.map

package/dist/extraction/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../typescript/extraction/batch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG9F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EACpD,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6D7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EACpD,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,gBAAgB,EAAE,CA6DpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,IAAI,EAAE,EACb,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAiC7B"}

package/dist/extraction/bytes.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Byte-based extraction functions
+ *
+ * Provides synchronous and asynchronous extraction functions for document bytes.
+ */
+import type { ExtractionConfig as ExtractionConfigType, ExtractionResult } from "../types.d.ts";
+/**
+ * Extract content from bytes (document data)
+ *
+ * Extracts text, metadata, tables, images, and other content from document bytes.
+ * Automatically detects document type from MIME type and applies appropriate extraction logic.
+ *
+ * @param data - The document bytes to extract from
+ * @param mimeType - MIME type of the document (e.g., 'application/pdf', 'image/jpeg')
+ * @param config - Optional extraction configuration
+ * @returns Promise resolving to the extraction result
+ * @throws {Error} If WASM module is not initialized or extraction fails
+ *
+ * @example Extract PDF
+ * ```typescript
+ * const bytes = new Uint8Array(buffer);
+ * const result = await extractBytes(bytes, 'application/pdf');
+ * console.log(result.content);
+ * console.log(result.tables);
+ * ```
+ *
+ * @example Extract with Configuration
+ * ```typescript
+ * const result = await extractBytes(bytes, 'application/pdf', {
+ *   ocr: {
+ *     backend: 'tesseract',
+ *     language: 'deu' // German
+ *   },
+ *   images: {
+ *     extractImages: true,
+ *     targetDpi: 200
+ *   }
+ * });
+ * ```
+ *
+ * @example Extract from File
+ * ```typescript
+ * const file = inputEvent.target.files[0];
+ * const bytes = await fileToUint8Array(file);
+ * const result = await extractBytes(bytes, file.type);
+ * ```
+ */
+export declare function extractBytes(data: Uint8Array, mimeType: string, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
+/**
+ * Extract content from bytes synchronously
+ *
+ * Synchronous version of extractBytes. Performs extraction without async operations.
+ * Note: Some extraction features may still be async internally, but the wrapper is synchronous.
+ *
+ * @param data - The document bytes to extract from
+ * @param mimeType - MIME type of the document
+ * @param config - Optional extraction configuration
+ * @returns The extraction result
+ * @throws {Error} If WASM module is not initialized or extraction fails
+ *
+ * @example
+ * ```typescript
+ * const bytes = new Uint8Array(buffer);
+ * const result = extractBytesSync(bytes, 'application/pdf');
+ * console.log(result.content);
+ * ```
+ */
+export declare function extractBytesSync(data: Uint8Array, mimeType: string, config?: ExtractionConfigType | null): ExtractionResult;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/extraction/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../typescript/extraction/bytes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,YAAY,CACjC,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,OAAO,CAAC,gBAAgB,CAAC,CA4B3B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,gBAAgB,CA4BlB"}

package/dist/extraction/files.d.ts

@@ -0,0 +1,77 @@
+/**
+ * File-based extraction functions
+ *
+ * Provides extraction functions for files in filesystem-based environments (Node.js, Deno, Bun)
+ * and browser File/Blob objects.
+ */
+import type { ExtractionConfig as ExtractionConfigType, ExtractionResult } from "../types.d.ts";
+/**
+ * Extract content from a file on the file system
+ *
+ * Node.js and Deno specific function that reads a file from the file system
+ * and extracts content from it. Automatically detects MIME type if not provided.
+ *
+ * @param path - Path to the file to extract from
+ * @param mimeType - Optional MIME type of the file. If not provided, will attempt to detect
+ * @param config - Optional extraction configuration
+ * @returns Promise resolving to the extraction result
+ * @throws {Error} If WASM module is not initialized, file doesn't exist, or extraction fails
+ *
+ * @example Extract with auto-detection
+ * ```typescript
+ * const result = await extractFile('./document.pdf');
+ * console.log(result.content);
+ * ```
+ *
+ * @example Extract with explicit MIME type
+ * ```typescript
+ * const result = await extractFile('./document.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+ * ```
+ *
+ * @example Extract from Node.js with config
+ * ```typescript
+ * import { extractFile } from '@kreuzberg/wasm';
+ * import { readFile } from 'fs/promises';
+ *
+ * const result = await extractFile('./report.xlsx', null, {
+ *   chunking: {
+ *     maxChars: 1000
+ *   }
+ * });
+ * ```
+ */
+export declare function extractFile(path: string, mimeType?: string | null, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
+/**
+ * Extract content from a File or Blob (browser-friendly wrapper)
+ *
+ * Convenience function that wraps fileToUint8Array and extractBytes,
+ * providing a streamlined API for browser applications handling file inputs.
+ *
+ * @param file - The File or Blob to extract from
+ * @param mimeType - Optional MIME type. If not provided, uses file.type if available
+ * @param config - Optional extraction configuration
+ * @returns Promise resolving to the extraction result
+ * @throws {Error} If WASM module is not initialized or extraction fails
+ *
+ * @example Simple file extraction
+ * ```typescript
+ * const fileInput = document.getElementById('file');
+ * fileInput.addEventListener('change', async (e) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) {
+ *     const result = await extractFromFile(file);
+ *     console.log(result.content);
+ *   }
+ * });
+ * ```
+ *
+ * @example With configuration
+ * ```typescript
+ * const result = await extractFromFile(file, file.type, {
+ *   chunking: { maxChars: 1000 },
+ *   images: { extractImages: true }
+ * });
+ * ```
+ */
+export declare function extractFromFile(file: File | Blob, mimeType?: string | null, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
+//# sourceMappingURL=files.d.ts.map

package/dist/extraction/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../typescript/extraction/files.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAI9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,WAAW,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAmD3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAiB3B"}

package/dist/extraction/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extraction module
+ *
+ * Provides comprehensive extraction functionality for various document formats.
+ * Includes byte-based, file-based, and batch processing capabilities.
+ */
+export type { ExtractionConfig, ExtractionResult } from "../types.d.ts";
+export { batchExtractBytes, batchExtractBytesSync, batchExtractFiles } from "./batch.d.ts";
+export { extractBytes, extractBytesSync } from "./bytes.d.ts";
+export { extractFile, extractFromFile } from "./files.d.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../typescript/extraction/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/extraction/internal.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Internal extraction module helpers
+ *
+ * Provides internal utilities and access to the WASM module state.
+ * Re-exports state management from the centralized state module.
+ */
+import { type WasmModule } from "../initialization/state.d.ts";
+/**
+ * Get the WASM module
+ *
+ * @returns The WASM module
+ * @throws {Error} If WASM module is not loaded
+ */
+export declare function getWasmModule(): WasmModule;
+/**
+ * Check if WASM module is initialized
+ *
+ * @returns True if WASM module is initialized
+ */
+export declare function isInitialized(): boolean;
+//# sourceMappingURL=internal.d.ts.map

package/dist/extraction/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../typescript/extraction/internal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAGN,KAAK,UAAU,EACf,MAAM,4BAA4B,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAO1C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC"}

package/dist/index.d.ts

@@ -57,7 +57,7 @@
  * ## Runtime Detection
  *
  * ```typescript
- * import { detectRuntime, getWasmCapabilities } from '@kreuzberg/wasm/runtime';
+ * import { detectRuntime, getWasmCapabilities } from '@kreuzberg/wasm';
  *
  * const runtime = detectRuntime();
  * const caps = getWasmCapabilities();
@@ -93,330 +93,16 @@
  * const result = await extractBytes(bytes, 'application/pdf', config);
  * ```
  */
-import type { ExtractionConfig as ExtractionConfigType, ExtractionResult } from "./types.d.ts";
+export type * from "./types.d.ts";
+export { initializePdfiumAsync } from "./initialization/pdfium-loader.d.ts";
+export { getInitializationError, getVersion, getWasmModule, initWasm, isInitialized, type ModuleInfo, type WasmModule, } from "./initialization/wasm-loader.d.ts";
+export { extractBytes, extractBytesSync } from "./extraction/bytes.d.ts";
+export { extractFile, extractFromFile } from "./extraction/files.d.ts";
+export { batchExtractBytes, batchExtractBytesSync, batchExtractFiles, } from "./extraction/batch.d.ts";
+export { enableOcr } from "./ocr/enabler.d.ts";
 export { configToJS, fileToUint8Array, isValidExtractionResult, jsToExtractionResult, wrapWasmError, } from "./adapters/wasm-adapter.d.ts";
 export { clearOcrBackends, getOcrBackend, listOcrBackends, registerOcrBackend, unregisterOcrBackend, } from "./ocr/registry.d.ts";
 export { TesseractWasmBackend } from "./ocr/tesseract-wasm-backend.d.ts";
 export { clearPostProcessors, clearValidators, getPostProcessor, getValidator, listPostProcessors, listValidators, type PostProcessor, registerPostProcessor, registerValidator, unregisterPostProcessor, unregisterValidator, type Validator, } from "./plugin-registry.d.ts";
-export { detectRuntime, getRuntimeInfo, getRuntimeVersion, getWasmCapabilities, hasBigInt, hasBlob, hasFileApi, hasModuleWorkers, hasSharedArrayBuffer, hasWasm, hasWasmStreaming, hasWorkers, isBrowser, isBun, isDeno, isNode, isServerEnvironment, isWebEnvironment, type RuntimeType, type WasmCapabilities, } from "./runtime.d.ts";
-export type * from "./types.d.ts";
-export type { Chunk, ChunkingConfig, ChunkMetadata, ExtractedImage, ExtractionConfig, ExtractionResult, ImageExtractionConfig, LanguageDetectionConfig, Metadata, OcrBackendProtocol, OcrConfig, PageContent, PageExtractionConfig, PdfConfig, PostProcessorConfig, Table, TesseractConfig, TokenReductionConfig, } from "./types.d.ts";
-export declare function initWasm(): Promise<void>;
-/**
- * Check if WASM module is initialized
- *
- * @returns True if WASM module is initialized, false otherwise
- *
- * @example
- * ```typescript
- * if (!isInitialized()) {
- *   await initWasm();
- * }
- * ```
- */
-export declare function isInitialized(): boolean;
-/**
- * Get WASM module version
- *
- * @throws {Error} If WASM module is not initialized
- * @returns The version string of the WASM module
- *
- * @example
- * ```typescript
- * const version = getVersion();
- * console.log(`Using Kreuzberg ${version}`);
- * ```
- */
-export declare function getVersion(): string;
-/**
- * Get initialization error if module failed to load
- *
- * @returns The error that occurred during initialization, or null if no error
- *
- * @internal
- */
-export declare function getInitializationError(): Error | null;
-/**
- * Extract content from bytes (document data)
- *
- * Extracts text, metadata, tables, images, and other content from document bytes.
- * Automatically detects document type from MIME type and applies appropriate extraction logic.
- *
- * @param data - The document bytes to extract from
- * @param mimeType - MIME type of the document (e.g., 'application/pdf', 'image/jpeg')
- * @param config - Optional extraction configuration
- * @returns Promise resolving to the extraction result
- * @throws {Error} If WASM module is not initialized or extraction fails
- *
- * @example Extract PDF
- * ```typescript
- * const bytes = new Uint8Array(buffer);
- * const result = await extractBytes(bytes, 'application/pdf');
- * console.log(result.content);
- * console.log(result.tables);
- * ```
- *
- * @example Extract with Configuration
- * ```typescript
- * const result = await extractBytes(bytes, 'application/pdf', {
- *   ocr: {
- *     backend: 'tesseract',
- *     language: 'deu' // German
- *   },
- *   images: {
- *     extractImages: true,
- *     targetDpi: 200
- *   }
- * });
- * ```
- *
- * @example Extract from File
- * ```typescript
- * const file = inputEvent.target.files[0];
- * const bytes = await fileToUint8Array(file);
- * const result = await extractBytes(bytes, file.type);
- * ```
- */
-export declare function extractBytes(data: Uint8Array, mimeType: string, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
-/**
- * Extract content from a file on the file system
- *
- * Node.js and Deno specific function that reads a file from the file system
- * and extracts content from it. Automatically detects MIME type if not provided.
- *
- * @param path - Path to the file to extract from
- * @param mimeType - Optional MIME type of the file. If not provided, will attempt to detect
- * @param config - Optional extraction configuration
- * @returns Promise resolving to the extraction result
- * @throws {Error} If WASM module is not initialized, file doesn't exist, or extraction fails
- *
- * @example Extract with auto-detection
- * ```typescript
- * const result = await extractFile('./document.pdf');
- * console.log(result.content);
- * ```
- *
- * @example Extract with explicit MIME type
- * ```typescript
- * const result = await extractFile('./document.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
- * ```
- *
- * @example Extract from Node.js with config
- * ```typescript
- * import { extractFile } from '@kreuzberg/wasm';
- * import { readFile } from 'fs/promises';
- *
- * const result = await extractFile('./report.xlsx', null, {
- *   chunking: {
- *     maxChars: 1000
- *   }
- * });
- * ```
- */
-export declare function extractFile(path: string, mimeType?: string | null, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
-/**
- * Extract content from a File or Blob (browser-friendly wrapper)
- *
- * Convenience function that wraps fileToUint8Array and extractBytes,
- * providing a streamlined API for browser applications handling file inputs.
- *
- * @param file - The File or Blob to extract from
- * @param mimeType - Optional MIME type. If not provided, uses file.type if available
- * @param config - Optional extraction configuration
- * @returns Promise resolving to the extraction result
- * @throws {Error} If WASM module is not initialized or extraction fails
- *
- * @example Simple file extraction
- * ```typescript
- * const fileInput = document.getElementById('file');
- * fileInput.addEventListener('change', async (e) => {
- *   const file = e.target.files?.[0];
- *   if (file) {
- *     const result = await extractFromFile(file);
- *     console.log(result.content);
- *   }
- * });
- * ```
- *
- * @example With configuration
- * ```typescript
- * const result = await extractFromFile(file, file.type, {
- *   chunking: { maxChars: 1000 },
- *   images: { extractImages: true }
- * });
- * ```
- */
-export declare function extractFromFile(file: File | Blob, mimeType?: string | null, config?: ExtractionConfigType | null): Promise<ExtractionResult>;
-/**
- * Extract content from bytes synchronously
- *
- * Synchronous version of extractBytes. Performs extraction without async operations.
- * Note: Some extraction features may still be async internally, but the wrapper is synchronous.
- *
- * @param data - The document bytes to extract from
- * @param mimeType - MIME type of the document
- * @param config - Optional extraction configuration
- * @returns The extraction result
- * @throws {Error} If WASM module is not initialized or extraction fails
- *
- * @example
- * ```typescript
- * const bytes = new Uint8Array(buffer);
- * const result = extractBytesSync(bytes, 'application/pdf');
- * console.log(result.content);
- * ```
- */
-export declare function extractBytesSync(data: Uint8Array, mimeType: string, config?: ExtractionConfigType | null): ExtractionResult;
-/**
- * Batch extract content from multiple byte arrays asynchronously
- *
- * Extracts content from multiple documents in a single batch operation,
- * allowing for more efficient processing of multiple files.
- *
- * @param files - Array of objects containing data (Uint8Array) and mimeType (string)
- * @param config - Optional extraction configuration applied to all files
- * @returns Promise resolving to array of extraction results
- * @throws {Error} If WASM module is not initialized or extraction fails
- *
- * @example
- * ```typescript
- * const files = [
- *   { data: pdfBytes, mimeType: 'application/pdf' },
- *   { data: docxBytes, mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
- * ];
- * const results = await batchExtractBytes(files);
- * results.forEach((result) => console.log(result.content));
- * ```
- */
-export declare function batchExtractBytes(files: Array<{
-    data: Uint8Array;
-    mimeType: string;
-}>, config?: ExtractionConfigType | null): Promise<ExtractionResult[]>;
-/**
- * Batch extract content from multiple byte arrays synchronously
- *
- * Synchronous version of batchExtractBytes. Extracts content from multiple documents
- * in a single batch operation without async operations.
- *
- * @param files - Array of objects containing data (Uint8Array) and mimeType (string)
- * @param config - Optional extraction configuration applied to all files
- * @returns Array of extraction results
- * @throws {Error} If WASM module is not initialized or extraction fails
- *
- * @example
- * ```typescript
- * const files = [
- *   { data: pdfBytes, mimeType: 'application/pdf' },
- *   { data: docxBytes, mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
- * ];
- * const results = batchExtractBytesSync(files);
- * results.forEach((result) => console.log(result.content));
- * ```
- */
-export declare function batchExtractBytesSync(files: Array<{
-    data: Uint8Array;
-    mimeType: string;
-}>, config?: ExtractionConfigType | null): ExtractionResult[];
-/**
- * Batch extract content from multiple File objects asynchronously
- *
- * Convenience function that converts File objects to Uint8Array and calls batchExtractBytes.
- * Automatically uses the file.type as MIME type if available.
- *
- * @param files - Array of File objects to extract from
- * @param config - Optional extraction configuration applied to all files
- * @returns Promise resolving to array of extraction results
- * @throws {Error} If WASM module is not initialized, files cannot be read, or extraction fails
- *
- * @example
- * ```typescript
- * const fileInput = document.getElementById('files');
- * const files = Array.from(fileInput.files ?? []);
- * const results = await batchExtractFiles(files);
- * results.forEach((result, index) => {
- *   console.log(`File ${index}: ${result.content.substring(0, 50)}...`);
- * });
- * ```
- */
-export declare function batchExtractFiles(files: File[], config?: ExtractionConfigType | null): Promise<ExtractionResult[]>;
-/**
- * Enable OCR functionality with tesseract-wasm backend
- *
- * Convenience function that automatically initializes and registers the Tesseract WASM backend.
- * This is the recommended approach for enabling OCR in WASM-based applications.
- *
- * ## Browser Requirement
- *
- * This function requires a browser environment with support for:
- * - WebWorkers (for Tesseract processing)
- * - createImageBitmap (for image conversion)
- * - Blob API
- *
- * ## Network Requirement
- *
- * Training data will be loaded from jsDelivr CDN on first use of each language.
- * Ensure network access to cdn.jsdelivr.net is available.
- *
- * @throws {Error} If not in browser environment or tesseract-wasm is not available
- *
- * @example Basic Usage
- * ```typescript
- * import { enableOcr, extractBytes, initWasm } from '@kreuzberg/wasm';
- *
- * async function main() {
- *   // Initialize WASM module
- *   await initWasm();
- *
- *   // Enable OCR with tesseract-wasm
- *   await enableOcr();
- *
- *   // Now you can use OCR in extraction
- *   const imageBytes = new Uint8Array(buffer);
- *   const result = await extractBytes(imageBytes, 'image/png', {
- *     ocr: { backend: 'tesseract-wasm', language: 'eng' }
- *   });
- *
- *   console.log(result.content); // Extracted text
- * }
- *
- * main().catch(console.error);
- * ```
- *
- * @example With Progress Tracking
- * ```typescript
- * import { enableOcr, TesseractWasmBackend } from '@kreuzberg/wasm';
- *
- * async function setupOcrWithProgress() {
- *   const backend = new TesseractWasmBackend();
- *   backend.setProgressCallback((progress) => {
- *     console.log(`OCR Progress: ${progress}%`);
- *     updateProgressBar(progress);
- *   });
- *
- *   await backend.initialize();
- *   registerOcrBackend(backend);
- * }
- *
- * setupOcrWithProgress().catch(console.error);
- * ```
- *
- * @example Multiple Languages
- * ```typescript
- * import { enableOcr, extractBytes, initWasm } from '@kreuzberg/wasm';
- *
- * await initWasm();
- * await enableOcr();
- *
- * // Extract English text
- * const englishResult = await extractBytes(engImageBytes, 'image/png', {
- *   ocr: { backend: 'tesseract-wasm', language: 'eng' }
- * });
- *
- * // Extract German text - model is cached after first use
- * const germanResult = await extractBytes(deImageBytes, 'image/png', {
- *   ocr: { backend: 'tesseract-wasm', language: 'deu' }
- * });
- * ```
- */
-export declare function enableOcr(): Promise<void>;
+export { detectRuntime, getRuntimeInfo, getRuntimeVersion, getWasmCapabilities, hasBigInt, hasBlob, hasFileApi, hasModuleWorkers, hasSharedArrayBuffer, hasWasm, hasWasmStreaming, hasWorkers, isBrowser, isBun, isCloudflareWorkers, isDeno, isEdgeEnvironment, isEdgeRuntime, isNode, isServerEnvironment, isWebEnvironment, type RuntimeType, type WasmCapabilities, } from "./runtime.d.ts";
 //# sourceMappingURL=index.d.ts.map