@kreuzberg/wasm 4.0.0-rc.21 → 4.0.0-rc.24

package/dist/index.d.cts

@@ -1,423 +0,0 @@
-import { E as ExtractionConfig, a as ExtractionResult } from './types-CKjcIYcX.cjs.js';
-export { C as Chunk, b as ChunkingConfig, c as ChunkMetadata, d as ExtractedImage, I as ImageExtractionConfig, L as LanguageDetectionConfig, M as Metadata, O as OcrBackendProtocol, e as OcrConfig, P as PageContent, f as PageExtractionConfig, g as PdfConfig, h as PostProcessorConfig, T as Table, i as TesseractConfig, j as TokenReductionConfig, E as ExtractionConfig, a as ExtractionResult } from './types-CKjcIYcX.cjs.js';
-export { configToJS, fileToUint8Array, isValidExtractionResult, jsToExtractionResult, wrapWasmError } from './adapters/wasm-adapter.cjs';
-export { clearOcrBackends, getOcrBackend, listOcrBackends, registerOcrBackend, unregisterOcrBackend } from './ocr/registry.cjs';
-export { TesseractWasmBackend } from './ocr/tesseract-wasm-backend.cjs';
-export { type RuntimeType, type WasmCapabilities, detectRuntime, getRuntimeInfo, getRuntimeVersion, getWasmCapabilities, hasBigInt, hasBlob, hasFileApi, hasModuleWorkers, hasSharedArrayBuffer, hasWasm, hasWasmStreaming, hasWorkers, isBrowser, isBun, isDeno, isNode, isServerEnvironment, isWebEnvironment } from './runtime.d.cts';
-
-/**
- * Kreuzberg - WebAssembly Bindings for Browser and Runtime Environments
- *
- * This module provides WebAssembly bindings for Kreuzberg document intelligence,
- * enabling high-performance document extraction in browser and JavaScript runtime environments.
- *
- * ## Features
- *
- * - Extract text, metadata, and tables from documents
- * - Support for multiple document formats (PDF, Office, images, etc.)
- * - Browser and runtime-compatible WASM bindings
- * - Type-safe TypeScript interfaces
- * - Runtime detection and feature capability checking
- * - Automatic type conversion and error handling
- *
- * ## Installation
- *
- * ```bash
- * npm install @kreuzberg/wasm
- * ```
- *
- * ## Basic Usage
- *
- * ```typescript
- * import { extractBytes, initWasm } from '@kreuzberg/wasm';
- *
- * // Initialize WASM module once at app startup
- * await initWasm();
- *
- * // Extract from bytes
- * const bytes = new Uint8Array(buffer);
- * const result = await extractBytes(bytes, 'application/pdf');
- * console.log(result.content);
- * ```
- *
- * ## Browser Usage with File Input
- *
- * ```typescript
- * import { extractBytes, initWasm } from '@kreuzberg/wasm';
- * import { fileToUint8Array } from '@kreuzberg/wasm/adapters/wasm-adapter';
- *
- * // Initialize once at app startup
- * await initWasm();
- *
- * // Handle file input
- * const fileInput = document.getElementById('file');
- * fileInput.addEventListener('change', async (e) => {
- *   const file = e.target.files?.[0];
- *   if (file) {
- *     const bytes = await fileToUint8Array(file);
- *     const result = await extractBytes(bytes, file.type);
- *     console.log(result.content);
- *   }
- * });
- * ```
- *
- * ## Runtime Detection
- *
- * ```typescript
- * import { detectRuntime, getWasmCapabilities } from '@kreuzberg/wasm/runtime';
- *
- * const runtime = detectRuntime();
- * const caps = getWasmCapabilities();
- *
- * if (caps.hasWorkers) {
- *   // Can use Web Workers for parallel processing
- * }
- * ```
- *
- * ## Configuration
- *
- * ```typescript
- * import { extractBytes, initWasm } from '@kreuzberg/wasm';
- * import type { ExtractionConfig } from '@kreuzberg/wasm';
- *
- * await initWasm();
- *
- * const config: ExtractionConfig = {
- *   ocr: {
- *     backend: 'tesseract',
- *     language: 'eng'
- *   },
- *   chunking: {
- *     maxChars: 1000,
- *     chunkOverlap: 100
- *   },
- *   images: {
- *     extractImages: true,
- *     targetDpi: 150
- *   }
- * };
- *
- * const result = await extractBytes(bytes, 'application/pdf', config);
- * ```
- */
-
-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();
- * }
- * ```
- */
-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}`);
- * ```
- */
-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
- */
-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);
- * ```
- */
-declare function extractBytes(data: Uint8Array, mimeType: string, config?: ExtractionConfig | 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
- *   }
- * });
- * ```
- */
-declare function extractFile(path: string, mimeType?: string | null, config?: ExtractionConfig | 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 }
- * });
- * ```
- */
-declare function extractFromFile(file: File | Blob, mimeType?: string | null, config?: ExtractionConfig | 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);
- * ```
- */
-declare function extractBytesSync(data: Uint8Array, mimeType: string, config?: ExtractionConfig | 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));
- * ```
- */
-declare function batchExtractBytes(files: Array<{
-    data: Uint8Array;
-    mimeType: string;
-}>, config?: ExtractionConfig | 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));
- * ```
- */
-declare function batchExtractBytesSync(files: Array<{
-    data: Uint8Array;
-    mimeType: string;
-}>, config?: ExtractionConfig | 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)}...`);
- * });
- * ```
- */
-declare function batchExtractFiles(files: File[], config?: ExtractionConfig | 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' }
- * });
- * ```
- */
-declare function enableOcr(): Promise<void>;
-
-export { batchExtractBytes, batchExtractBytesSync, batchExtractFiles, enableOcr, extractBytes, extractBytesSync, extractFile, extractFromFile, getInitializationError, getVersion, initWasm, isInitialized };

package/dist/ocr/registry.cjs

@@ -1,92 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// typescript/ocr/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  clearOcrBackends: () => clearOcrBackends,
-  getOcrBackend: () => getOcrBackend,
-  listOcrBackends: () => listOcrBackends,
-  registerOcrBackend: () => registerOcrBackend,
-  unregisterOcrBackend: () => unregisterOcrBackend
-});
-module.exports = __toCommonJS(registry_exports);
-var ocrBackendRegistry = /* @__PURE__ */ new Map();
-function registerOcrBackend(backend) {
-  if (!backend) {
-    throw new Error("Backend cannot be null or undefined");
-  }
-  if (typeof backend.name !== "function") {
-    throw new Error("Backend must implement name() method");
-  }
-  if (typeof backend.supportedLanguages !== "function") {
-    throw new Error("Backend must implement supportedLanguages() method");
-  }
-  if (typeof backend.processImage !== "function") {
-    throw new Error("Backend must implement processImage() method");
-  }
-  const backendName = backend.name();
-  if (!backendName || typeof backendName !== "string") {
-    throw new Error("Backend name must be a non-empty string");
-  }
-  if (ocrBackendRegistry.has(backendName)) {
-    console.warn(`OCR backend "${backendName}" is already registered and will be replaced`);
-  }
-  ocrBackendRegistry.set(backendName, backend);
-}
-function getOcrBackend(name) {
-  return ocrBackendRegistry.get(name);
-}
-function listOcrBackends() {
-  return Array.from(ocrBackendRegistry.keys());
-}
-async function unregisterOcrBackend(name) {
-  const backend = ocrBackendRegistry.get(name);
-  if (!backend) {
-    throw new Error(
-      `OCR backend "${name}" is not registered. Available backends: ${Array.from(ocrBackendRegistry.keys()).join(", ")}`
-    );
-  }
-  if (typeof backend.shutdown === "function") {
-    try {
-      await backend.shutdown();
-    } catch (error) {
-      console.warn(
-        `Error shutting down OCR backend "${name}": ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  ocrBackendRegistry.delete(name);
-}
-async function clearOcrBackends() {
-  const backends = Array.from(ocrBackendRegistry.entries());
-  for (const [name, backend] of backends) {
-    if (typeof backend.shutdown === "function") {
-      try {
-        await backend.shutdown();
-      } catch (error) {
-        console.warn(
-          `Error shutting down OCR backend "${name}": ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-  ocrBackendRegistry.clear();
-}
-//# sourceMappingURL=registry.cjs.map

package/dist/ocr/registry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../typescript/ocr/registry.ts"],"sourcesContent":["/**\n * OCR Backend Registry\n *\n * Provides a registry for OCR backends in the WASM environment.\n * This enables auto-registration and management of OCR backends.\n *\n * Note: The WASM package provides a lightweight registry in the browser.\n * For more advanced features like Rust integration, use @kreuzberg/node or @kreuzberg/deno.\n *\n * @example\n * ```typescript\n * import { TesseractWasmBackend } from '@kreuzberg/wasm/ocr/tesseract-wasm-backend';\n * import { enableOcr } from '@kreuzberg/wasm';\n *\n * // Simple auto-registration\n * await enableOcr();\n * ```\n */\n\nimport type { OcrBackendProtocol } from \"../types.js\";\n\n/** Global registry of OCR backends */\nconst ocrBackendRegistry = new Map<string, OcrBackendProtocol>();\n\n/**\n * Register an OCR backend\n *\n * Registers an OCR backend with the WASM extraction pipeline.\n * If a backend with the same name is already registered, it will be replaced.\n *\n * @param backend - OCR backend implementing OcrBackendProtocol\n * @throws {Error} If backend validation fails\n *\n * @example\n * ```typescript\n * import { TesseractWasmBackend } from '@kreuzberg/wasm/ocr/tesseract-wasm-backend';\n * import { registerOcrBackend } from '@kreuzberg/wasm/ocr/registry';\n *\n * const backend = new TesseractWasmBackend();\n * await backend.initialize();\n * registerOcrBackend(backend);\n * ```\n */\nexport function registerOcrBackend(backend: OcrBackendProtocol): void {\n\t// Validate backend\n\tif (!backend) {\n\t\tthrow new Error(\"Backend cannot be null or undefined\");\n\t}\n\n\tif (typeof backend.name !== \"function\") {\n\t\tthrow new Error(\"Backend must implement name() method\");\n\t}\n\n\tif (typeof backend.supportedLanguages !== \"function\") {\n\t\tthrow new Error(\"Backend must implement supportedLanguages() method\");\n\t}\n\n\tif (typeof backend.processImage !== \"function\") {\n\t\tthrow new Error(\"Backend must implement processImage() method\");\n\t}\n\n\tconst backendName = backend.name();\n\n\tif (!backendName || typeof backendName !== \"string\") {\n\t\tthrow new Error(\"Backend name must be a non-empty string\");\n\t}\n\n\t// Check for duplicate registration (allow overwriting with warning)\n\tif (ocrBackendRegistry.has(backendName)) {\n\t\tconsole.warn(`OCR backend \"${backendName}\" is already registered and will be replaced`);\n\t}\n\n\t// Register the backend\n\tocrBackendRegistry.set(backendName, backend);\n}\n\n/**\n * Get a registered OCR backend by name\n *\n * @param name - Backend name\n * @returns The OCR backend or undefined if not found\n *\n * @example\n * ```typescript\n * import { getOcrBackend } from '@kreuzberg/wasm/ocr/registry';\n *\n * const backend = getOcrBackend('tesseract-wasm');\n * if (backend) {\n *   console.log('Available languages:', backend.supportedLanguages());\n * }\n * ```\n */\nexport function getOcrBackend(name: string): OcrBackendProtocol | undefined {\n\treturn ocrBackendRegistry.get(name);\n}\n\n/**\n * List all registered OCR backends\n *\n * @returns Array of registered backend names\n *\n * @example\n * ```typescript\n * import { listOcrBackends } from '@kreuzberg/wasm/ocr/registry';\n *\n * const backends = listOcrBackends();\n * console.log('Available OCR backends:', backends);\n * ```\n */\nexport function listOcrBackends(): string[] {\n\treturn Array.from(ocrBackendRegistry.keys());\n}\n\n/**\n * Unregister an OCR backend\n *\n * @param name - Backend name to unregister\n * @throws {Error} If backend is not found\n *\n * @example\n * ```typescript\n * import { unregisterOcrBackend } from '@kreuzberg/wasm/ocr/registry';\n *\n * unregisterOcrBackend('tesseract-wasm');\n * ```\n */\nexport async function unregisterOcrBackend(name: string): Promise<void> {\n\tconst backend = ocrBackendRegistry.get(name);\n\n\tif (!backend) {\n\t\tthrow new Error(\n\t\t\t`OCR backend \"${name}\" is not registered. Available backends: ${Array.from(ocrBackendRegistry.keys()).join(\", \")}`,\n\t\t);\n\t}\n\n\t// Call shutdown if available\n\tif (typeof backend.shutdown === \"function\") {\n\t\ttry {\n\t\t\tawait backend.shutdown();\n\t\t} catch (error) {\n\t\t\tconsole.warn(\n\t\t\t\t`Error shutting down OCR backend \"${name}\": ${error instanceof Error ? error.message : String(error)}`,\n\t\t\t);\n\t\t}\n\t}\n\n\tocrBackendRegistry.delete(name);\n}\n\n/**\n * Clear all registered OCR backends\n *\n * Unregisters all OCR backends and calls their shutdown methods.\n *\n * @example\n * ```typescript\n * import { clearOcrBackends } from '@kreuzberg/wasm/ocr/registry';\n *\n * // Clean up all backends when shutting down\n * await clearOcrBackends();\n * ```\n */\nexport async function clearOcrBackends(): Promise<void> {\n\tconst backends = Array.from(ocrBackendRegistry.entries());\n\n\tfor (const [name, backend] of backends) {\n\t\tif (typeof backend.shutdown === \"function\") {\n\t\t\ttry {\n\t\t\t\tawait backend.shutdown();\n\t\t\t} catch (error) {\n\t\t\t\tconsole.warn(\n\t\t\t\t\t`Error shutting down OCR backend \"${name}\": ${error instanceof Error ? error.message : String(error)}`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tocrBackendRegistry.clear();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,IAAM,qBAAqB,oBAAI,IAAgC;AAqBxD,SAAS,mBAAmB,SAAmC;AAErE,MAAI,CAAC,SAAS;AACb,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACtD;AAEA,MAAI,OAAO,QAAQ,SAAS,YAAY;AACvC,UAAM,IAAI,MAAM,sCAAsC;AAAA,EACvD;AAEA,MAAI,OAAO,QAAQ,uBAAuB,YAAY;AACrD,UAAM,IAAI,MAAM,oDAAoD;AAAA,EACrE;AAEA,MAAI,OAAO,QAAQ,iBAAiB,YAAY;AAC/C,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAC/D;AAEA,QAAM,cAAc,QAAQ,KAAK;AAEjC,MAAI,CAAC,eAAe,OAAO,gBAAgB,UAAU;AACpD,UAAM,IAAI,MAAM,yCAAyC;AAAA,EAC1D;AAGA,MAAI,mBAAmB,IAAI,WAAW,GAAG;AACxC,YAAQ,KAAK,gBAAgB,WAAW,8CAA8C;AAAA,EACvF;AAGA,qBAAmB,IAAI,aAAa,OAAO;AAC5C;AAkBO,SAAS,cAAc,MAA8C;AAC3E,SAAO,mBAAmB,IAAI,IAAI;AACnC;AAeO,SAAS,kBAA4B;AAC3C,SAAO,MAAM,KAAK,mBAAmB,KAAK,CAAC;AAC5C;AAeA,eAAsB,qBAAqB,MAA6B;AACvE,QAAM,UAAU,mBAAmB,IAAI,IAAI;AAE3C,MAAI,CAAC,SAAS;AACb,UAAM,IAAI;AAAA,MACT,gBAAgB,IAAI,4CAA4C,MAAM,KAAK,mBAAmB,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IACjH;AAAA,EACD;AAGA,MAAI,OAAO,QAAQ,aAAa,YAAY;AAC3C,QAAI;AACH,YAAM,QAAQ,SAAS;AAAA,IACxB,SAAS,OAAO;AACf,cAAQ;AAAA,QACP,oCAAoC,IAAI,MAAM,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,MACrG;AAAA,IACD;AAAA,EACD;AAEA,qBAAmB,OAAO,IAAI;AAC/B;AAeA,eAAsB,mBAAkC;AACvD,QAAM,WAAW,MAAM,KAAK,mBAAmB,QAAQ,CAAC;AAExD,aAAW,CAAC,MAAM,OAAO,KAAK,UAAU;AACvC,QAAI,OAAO,QAAQ,aAAa,YAAY;AAC3C,UAAI;AACH,cAAM,QAAQ,SAAS;AAAA,MACxB,SAAS,OAAO;AACf,gBAAQ;AAAA,UACP,oCAAoC,IAAI,MAAM,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,QACrG;AAAA,MACD;AAAA,IACD;AAAA,EACD;AAEA,qBAAmB,MAAM;AAC1B;","names":[]}

package/dist/ocr/registry.d.cts

@@ -1,102 +0,0 @@
-import { O as OcrBackendProtocol } from '../types-CKjcIYcX.cjs';
-
-/**
- * OCR Backend Registry
- *
- * Provides a registry for OCR backends in the WASM environment.
- * This enables auto-registration and management of OCR backends.
- *
- * Note: The WASM package provides a lightweight registry in the browser.
- * For more advanced features like Rust integration, use @kreuzberg/node or @kreuzberg/deno.
- *
- * @example
- * ```typescript
- * import { TesseractWasmBackend } from '@kreuzberg/wasm/ocr/tesseract-wasm-backend';
- * import { enableOcr } from '@kreuzberg/wasm';
- *
- * // Simple auto-registration
- * await enableOcr();
- * ```
- */
-
-/**
- * Register an OCR backend
- *
- * Registers an OCR backend with the WASM extraction pipeline.
- * If a backend with the same name is already registered, it will be replaced.
- *
- * @param backend - OCR backend implementing OcrBackendProtocol
- * @throws {Error} If backend validation fails
- *
- * @example
- * ```typescript
- * import { TesseractWasmBackend } from '@kreuzberg/wasm/ocr/tesseract-wasm-backend';
- * import { registerOcrBackend } from '@kreuzberg/wasm/ocr/registry';
- *
- * const backend = new TesseractWasmBackend();
- * await backend.initialize();
- * registerOcrBackend(backend);
- * ```
- */
-declare function registerOcrBackend(backend: OcrBackendProtocol): void;
-/**
- * Get a registered OCR backend by name
- *
- * @param name - Backend name
- * @returns The OCR backend or undefined if not found
- *
- * @example
- * ```typescript
- * import { getOcrBackend } from '@kreuzberg/wasm/ocr/registry';
- *
- * const backend = getOcrBackend('tesseract-wasm');
- * if (backend) {
- *   console.log('Available languages:', backend.supportedLanguages());
- * }
- * ```
- */
-declare function getOcrBackend(name: string): OcrBackendProtocol | undefined;
-/**
- * List all registered OCR backends
- *
- * @returns Array of registered backend names
- *
- * @example
- * ```typescript
- * import { listOcrBackends } from '@kreuzberg/wasm/ocr/registry';
- *
- * const backends = listOcrBackends();
- * console.log('Available OCR backends:', backends);
- * ```
- */
-declare function listOcrBackends(): string[];
-/**
- * Unregister an OCR backend
- *
- * @param name - Backend name to unregister
- * @throws {Error} If backend is not found
- *
- * @example
- * ```typescript
- * import { unregisterOcrBackend } from '@kreuzberg/wasm/ocr/registry';
- *
- * unregisterOcrBackend('tesseract-wasm');
- * ```
- */
-declare function unregisterOcrBackend(name: string): Promise<void>;
-/**
- * Clear all registered OCR backends
- *
- * Unregisters all OCR backends and calls their shutdown methods.
- *
- * @example
- * ```typescript
- * import { clearOcrBackends } from '@kreuzberg/wasm/ocr/registry';
- *
- * // Clean up all backends when shutting down
- * await clearOcrBackends();
- * ```
- */
-declare function clearOcrBackends(): Promise<void>;
-
-export { clearOcrBackends, getOcrBackend, listOcrBackends, registerOcrBackend, unregisterOcrBackend };