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

package/dist/index.cjs

@@ -1,1245 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// typescript/index.ts
-var index_exports = {};
-__export(index_exports, {
-  TesseractWasmBackend: () => TesseractWasmBackend,
-  batchExtractBytes: () => batchExtractBytes,
-  batchExtractBytesSync: () => batchExtractBytesSync,
-  batchExtractFiles: () => batchExtractFiles,
-  clearOcrBackends: () => clearOcrBackends,
-  configToJS: () => configToJS,
-  detectRuntime: () => detectRuntime,
-  enableOcr: () => enableOcr,
-  extractBytes: () => extractBytes,
-  extractBytesSync: () => extractBytesSync,
-  extractFile: () => extractFile,
-  extractFromFile: () => extractFromFile,
-  fileToUint8Array: () => fileToUint8Array,
-  getInitializationError: () => getInitializationError,
-  getOcrBackend: () => getOcrBackend,
-  getRuntimeInfo: () => getRuntimeInfo,
-  getRuntimeVersion: () => getRuntimeVersion,
-  getVersion: () => getVersion,
-  getWasmCapabilities: () => getWasmCapabilities,
-  hasBigInt: () => hasBigInt,
-  hasBlob: () => hasBlob,
-  hasFileApi: () => hasFileApi,
-  hasModuleWorkers: () => hasModuleWorkers,
-  hasSharedArrayBuffer: () => hasSharedArrayBuffer,
-  hasWasm: () => hasWasm,
-  hasWasmStreaming: () => hasWasmStreaming,
-  hasWorkers: () => hasWorkers,
-  initWasm: () => initWasm,
-  isBrowser: () => isBrowser,
-  isBun: () => isBun,
-  isDeno: () => isDeno,
-  isInitialized: () => isInitialized,
-  isNode: () => isNode,
-  isServerEnvironment: () => isServerEnvironment,
-  isValidExtractionResult: () => isValidExtractionResult,
-  isWebEnvironment: () => isWebEnvironment,
-  jsToExtractionResult: () => jsToExtractionResult,
-  listOcrBackends: () => listOcrBackends,
-  registerOcrBackend: () => registerOcrBackend,
-  unregisterOcrBackend: () => unregisterOcrBackend,
-  wrapWasmError: () => wrapWasmError
-});
-module.exports = __toCommonJS(index_exports);
-
-// typescript/adapters/wasm-adapter.ts
-var MAX_FILE_SIZE = 512 * 1024 * 1024;
-function isNumberOrNull(value) {
-  return typeof value === "number" || value === null;
-}
-function isStringOrNull(value) {
-  return typeof value === "string" || value === null;
-}
-function isBoolean(value) {
-  return typeof value === "boolean";
-}
-async function fileToUint8Array(file) {
-  try {
-    if (file.size > MAX_FILE_SIZE) {
-      throw new Error(
-        `File size (${file.size} bytes) exceeds maximum (${MAX_FILE_SIZE} bytes). Maximum file size is 512 MB.`
-      );
-    }
-    const arrayBuffer = await file.arrayBuffer();
-    return new Uint8Array(arrayBuffer);
-  } catch (error) {
-    throw new Error(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function configToJS(config) {
-  if (!config) {
-    return {};
-  }
-  const normalized = {};
-  const normalizeValue = (value) => {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map(normalizeValue);
-      }
-      const obj = value;
-      const normalized2 = {};
-      for (const [key, val] of Object.entries(obj)) {
-        const normalizedVal = normalizeValue(val);
-        if (normalizedVal !== null && normalizedVal !== void 0) {
-          normalized2[key] = normalizedVal;
-        }
-      }
-      return Object.keys(normalized2).length > 0 ? normalized2 : null;
-    }
-    return value;
-  };
-  for (const [key, value] of Object.entries(config)) {
-    const normalizedValue = normalizeValue(value);
-    if (normalizedValue !== null && normalizedValue !== void 0) {
-      normalized[key] = normalizedValue;
-    }
-  }
-  return normalized;
-}
-function jsToExtractionResult(jsValue) {
-  if (!jsValue || typeof jsValue !== "object") {
-    throw new Error("Invalid extraction result: value is not an object");
-  }
-  const result = jsValue;
-  const mimeType = typeof result.mimeType === "string" ? result.mimeType : typeof result.mime_type === "string" ? result.mime_type : null;
-  if (typeof result.content !== "string") {
-    throw new Error("Invalid extraction result: missing or invalid content");
-  }
-  if (typeof mimeType !== "string") {
-    throw new Error("Invalid extraction result: missing or invalid mimeType");
-  }
-  if (!result.metadata || typeof result.metadata !== "object") {
-    throw new Error("Invalid extraction result: missing or invalid metadata");
-  }
-  const tables = [];
-  if (Array.isArray(result.tables)) {
-    for (const table of result.tables) {
-      if (table && typeof table === "object") {
-        const t = table;
-        if (Array.isArray(t.cells) && t.cells.every((row) => Array.isArray(row) && row.every((cell) => typeof cell === "string")) && typeof t.markdown === "string" && typeof t.pageNumber === "number") {
-          tables.push({
-            cells: t.cells,
-            markdown: t.markdown,
-            pageNumber: t.pageNumber
-          });
-        }
-      }
-    }
-  }
-  const chunks = Array.isArray(result.chunks) ? result.chunks.map((chunk) => {
-    if (!chunk || typeof chunk !== "object") {
-      throw new Error("Invalid chunk structure");
-    }
-    const c = chunk;
-    if (typeof c.content !== "string") {
-      throw new Error("Invalid chunk: missing content");
-    }
-    if (!c.metadata || typeof c.metadata !== "object") {
-      throw new Error("Invalid chunk: missing metadata");
-    }
-    const metadata = c.metadata;
-    let embedding = null;
-    if (Array.isArray(c.embedding)) {
-      if (!c.embedding.every((item) => typeof item === "number")) {
-        throw new Error("Invalid chunk: embedding must contain only numbers");
-      }
-      embedding = c.embedding;
-    }
-    if (typeof metadata.charStart !== "number") {
-      throw new Error("Invalid chunk metadata: charStart must be a number");
-    }
-    if (typeof metadata.charEnd !== "number") {
-      throw new Error("Invalid chunk metadata: charEnd must be a number");
-    }
-    if (!isNumberOrNull(metadata.tokenCount)) {
-      throw new Error("Invalid chunk metadata: tokenCount must be a number or null");
-    }
-    if (typeof metadata.chunkIndex !== "number") {
-      throw new Error("Invalid chunk metadata: chunkIndex must be a number");
-    }
-    if (typeof metadata.totalChunks !== "number") {
-      throw new Error("Invalid chunk metadata: totalChunks must be a number");
-    }
-    return {
-      content: c.content,
-      embedding,
-      metadata: {
-        charStart: metadata.charStart,
-        charEnd: metadata.charEnd,
-        tokenCount: metadata.tokenCount,
-        chunkIndex: metadata.chunkIndex,
-        totalChunks: metadata.totalChunks
-      }
-    };
-  }) : null;
-  const images = Array.isArray(result.images) ? result.images.map((image) => {
-    if (!image || typeof image !== "object") {
-      throw new Error("Invalid image structure");
-    }
-    const img = image;
-    if (!(img.data instanceof Uint8Array)) {
-      throw new Error("Invalid image: data must be Uint8Array");
-    }
-    if (typeof img.format !== "string") {
-      throw new Error("Invalid image: missing format");
-    }
-    if (typeof img.imageIndex !== "number") {
-      throw new Error("Invalid image: imageIndex must be a number");
-    }
-    if (!isNumberOrNull(img.pageNumber)) {
-      throw new Error("Invalid image: pageNumber must be a number or null");
-    }
-    if (!isNumberOrNull(img.width)) {
-      throw new Error("Invalid image: width must be a number or null");
-    }
-    if (!isNumberOrNull(img.height)) {
-      throw new Error("Invalid image: height must be a number or null");
-    }
-    if (!isNumberOrNull(img.bitsPerComponent)) {
-      throw new Error("Invalid image: bitsPerComponent must be a number or null");
-    }
-    if (!isBoolean(img.isMask)) {
-      throw new Error("Invalid image: isMask must be a boolean");
-    }
-    if (!isStringOrNull(img.colorspace)) {
-      throw new Error("Invalid image: colorspace must be a string or null");
-    }
-    if (!isStringOrNull(img.description)) {
-      throw new Error("Invalid image: description must be a string or null");
-    }
-    return {
-      data: img.data,
-      format: img.format,
-      imageIndex: img.imageIndex,
-      pageNumber: img.pageNumber,
-      width: img.width,
-      height: img.height,
-      colorspace: img.colorspace,
-      bitsPerComponent: img.bitsPerComponent,
-      isMask: img.isMask,
-      description: img.description,
-      ocrResult: img.ocrResult ? jsToExtractionResult(img.ocrResult) : null
-    };
-  }) : null;
-  let detectedLanguages = null;
-  const detectedLanguagesRaw = Array.isArray(result.detectedLanguages) ? result.detectedLanguages : result.detected_languages;
-  if (Array.isArray(detectedLanguagesRaw)) {
-    if (!detectedLanguagesRaw.every((lang) => typeof lang === "string")) {
-      throw new Error("Invalid result: detectedLanguages must contain only strings");
-    }
-    detectedLanguages = detectedLanguagesRaw;
-  }
-  return {
-    content: result.content,
-    mimeType,
-    metadata: result.metadata ?? {},
-    tables,
-    detectedLanguages,
-    chunks,
-    images
-  };
-}
-function wrapWasmError(error, context) {
-  if (error instanceof Error) {
-    return new Error(`Error ${context}: ${error.message}`, {
-      cause: error
-    });
-  }
-  const message = String(error);
-  return new Error(`Error ${context}: ${message}`);
-}
-function isValidExtractionResult(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const obj = value;
-  return typeof obj.content === "string" && (typeof obj.mimeType === "string" || typeof obj.mime_type === "string") && obj.metadata !== null && typeof obj.metadata === "object" && Array.isArray(obj.tables);
-}
-
-// typescript/ocr/registry.ts
-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();
-}
-
-// typescript/ocr/tesseract-wasm-backend.ts
-var TesseractWasmBackend = class {
-  /** Tesseract WASM client instance */
-  client = null;
-  /** Track which models are currently loaded to avoid redundant loads */
-  loadedLanguages = /* @__PURE__ */ new Set();
-  /** Cache for language availability validation */
-  supportedLangsCache = null;
-  /** Progress callback for UI updates */
-  progressCallback = null;
-  /** Base URL for training data CDN */
-  CDN_BASE_URL = "https://cdn.jsdelivr.net/npm/tesseract-wasm@0.11.0/dist";
-  /**
-   * Return the unique name of this OCR backend
-   *
-   * @returns Backend identifier "tesseract-wasm"
-   */
-  name() {
-    return "tesseract-wasm";
-  }
-  /**
-   * Return list of supported language codes
-   *
-   * Returns a curated list of commonly available Tesseract language models.
-   * Tesseract supports many more languages through custom models.
-   *
-   * @returns Array of ISO 639-1/2/3 language codes
-   */
-  supportedLanguages() {
-    if (this.supportedLangsCache) {
-      return this.supportedLangsCache;
-    }
-    this.supportedLangsCache = [
-      // Major languages
-      "eng",
-      // English
-      "deu",
-      // German
-      "fra",
-      // French
-      "spa",
-      // Spanish
-      "ita",
-      // Italian
-      "por",
-      // Portuguese
-      "nld",
-      // Dutch
-      "rus",
-      // Russian
-      "jpn",
-      // Japanese
-      "kor",
-      // Korean
-      "chi_sim",
-      // Chinese (Simplified)
-      "chi_tra",
-      // Chinese (Traditional)
-      // Additional European languages
-      "pol",
-      // Polish
-      "tur",
-      // Turkish
-      "swe",
-      // Swedish
-      "dan",
-      // Danish
-      "fin",
-      // Finnish
-      "nor",
-      // Norwegian
-      "ces",
-      // Czech
-      "slk",
-      // Slovak
-      "ron",
-      // Romanian
-      "hun",
-      // Hungarian
-      "hrv",
-      // Croatian
-      "srp",
-      // Serbian
-      "bul",
-      // Bulgarian
-      "ukr",
-      // Ukrainian
-      "ell",
-      // Greek
-      // Asian languages
-      "ara",
-      // Arabic
-      "heb",
-      // Hebrew
-      "hin",
-      // Hindi
-      "tha",
-      // Thai
-      "vie",
-      // Vietnamese
-      "mkd",
-      // Macedonian
-      "ben",
-      // Bengali
-      "tam",
-      // Tamil
-      "tel",
-      // Telugu
-      "kan",
-      // Kannada
-      "mal",
-      // Malayalam
-      "mya",
-      // Burmese
-      "khm",
-      // Khmer
-      "lao",
-      // Lao
-      "sin"
-      // Sinhala
-    ];
-    return this.supportedLangsCache;
-  }
-  /**
-   * Initialize the OCR backend
-   *
-   * Creates the Tesseract WASM client instance. This is called once when
-   * the backend is registered with the extraction pipeline.
-   *
-   * The actual model loading happens in processImage() on-demand to avoid
-   * loading all models upfront.
-   *
-   * @throws {Error} If tesseract-wasm is not available or initialization fails
-   *
-   * @example
-   * ```typescript
-   * const backend = new TesseractWasmBackend();
-   * try {
-   *   await backend.initialize();
-   * } catch (error) {
-   *   console.error('Failed to initialize OCR:', error);
-   * }
-   * ```
-   */
-  async initialize() {
-    if (this.client) {
-      return;
-    }
-    try {
-      const tesseractModule = await this.loadTesseractWasm();
-      if (!tesseractModule || typeof tesseractModule.OCRClient !== "function") {
-        throw new Error("tesseract-wasm OCRClient not found. Ensure tesseract-wasm is installed and available.");
-      }
-      this.client = new tesseractModule.OCRClient();
-      this.loadedLanguages.clear();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to initialize TesseractWasmBackend: ${message}`);
-    }
-  }
-  /**
-   * Process image bytes and extract text via OCR
-   *
-   * Handles image loading, model loading, OCR processing, and result formatting.
-   * Automatically loads the language model on first use and caches it for subsequent calls.
-   *
-   * @param imageBytes - Raw image data (Uint8Array) or Base64-encoded string
-   * @param language - ISO 639-2/3 language code (e.g., "eng", "deu")
-   * @returns Promise resolving to OCR result with content and metadata
-   * @throws {Error} If image processing fails, model loading fails, or language is unsupported
-   *
-   * @example
-   * ```typescript
-   * const backend = new TesseractWasmBackend();
-   * await backend.initialize();
-   *
-   * const imageBuffer = fs.readFileSync('scanned.png');
-   * const result = await backend.processImage(
-   *   new Uint8Array(imageBuffer),
-   *   'eng'
-   * );
-   *
-   * console.log(result.content); // Extracted text
-   * console.log(result.metadata.confidence); // OCR confidence score
-   * ```
-   */
-  async processImage(imageBytes, language) {
-    if (!this.client) {
-      throw new Error("TesseractWasmBackend not initialized. Call initialize() first.");
-    }
-    const supported = this.supportedLanguages();
-    const normalizedLang = language.toLowerCase();
-    const isSupported = supported.some((lang) => lang.toLowerCase() === normalizedLang);
-    if (!isSupported) {
-      throw new Error(`Language "${language}" is not supported. Supported languages: ${supported.join(", ")}`);
-    }
-    try {
-      if (!this.loadedLanguages.has(normalizedLang)) {
-        this.reportProgress(10);
-        await this.loadLanguageModel(normalizedLang);
-        this.loadedLanguages.add(normalizedLang);
-        this.reportProgress(30);
-      }
-      this.reportProgress(40);
-      const imageBitmap = await this.convertToImageBitmap(imageBytes);
-      this.reportProgress(50);
-      await this.client.loadImage(imageBitmap);
-      this.reportProgress(70);
-      const text = await this.client.getText();
-      const confidence = await this.getConfidenceScore();
-      const pageMetadata = await this.getPageMetadata();
-      this.reportProgress(90);
-      return {
-        content: text,
-        mime_type: "text/plain",
-        metadata: {
-          language: normalizedLang,
-          confidence,
-          ...pageMetadata
-        },
-        tables: []
-        // Tesseract-wasm doesn't provide structured table detection
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`OCR processing failed for language "${language}": ${message}`);
-    } finally {
-      this.reportProgress(100);
-    }
-  }
-  /**
-   * Shutdown the OCR backend and release resources
-   *
-   * Properly cleans up the Tesseract WASM client, freeing memory and Web Workers.
-   * Called when the backend is unregistered or the application shuts down.
-   *
-   * @throws {Error} If cleanup fails (errors are logged but not critical)
-   *
-   * @example
-   * ```typescript
-   * const backend = new TesseractWasmBackend();
-   * await backend.initialize();
-   * // ... use backend ...
-   * await backend.shutdown(); // Clean up resources
-   * ```
-   */
-  async shutdown() {
-    try {
-      if (this.client) {
-        if (typeof this.client.destroy === "function") {
-          this.client.destroy();
-        }
-        if (typeof this.client.terminate === "function") {
-          this.client.terminate();
-        }
-        this.client = null;
-      }
-      this.loadedLanguages.clear();
-      this.supportedLangsCache = null;
-      this.progressCallback = null;
-    } catch (error) {
-      console.warn(
-        `Warning during TesseractWasmBackend shutdown: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /**
-   * Set a progress callback for UI updates
-   *
-   * Allows the UI to display progress during OCR processing.
-   * The callback will be called with values from 0 to 100.
-   *
-   * @param callback - Function to call with progress percentage
-   *
-   * @example
-   * ```typescript
-   * const backend = new TesseractWasmBackend();
-   * backend.setProgressCallback((progress) => {
-   *   console.log(`OCR Progress: ${progress}%`);
-   *   document.getElementById('progress-bar').style.width = `${progress}%`;
-   * });
-   * ```
-   */
-  setProgressCallback(callback) {
-    this.progressCallback = callback;
-  }
-  /**
-   * Load language model from CDN
-   *
-   * Fetches the training data for a specific language from jsDelivr CDN.
-   * This is an MVP approach - models are cached by the browser.
-   *
-   * @param language - ISO 639-2/3 language code
-   * @throws {Error} If model download fails or language is not available
-   *
-   * @internal
-   */
-  async loadLanguageModel(language) {
-    if (!this.client) {
-      throw new Error("Client not initialized");
-    }
-    const modelFilename = `${language}.traineddata`;
-    const modelUrl = `${this.CDN_BASE_URL}/${modelFilename}`;
-    try {
-      await this.client.loadModel(modelUrl);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load model for language "${language}" from ${modelUrl}: ${message}`);
-    }
-  }
-  /**
-   * Convert image bytes or Base64 string to ImageBitmap
-   *
-   * Handles both Uint8Array and Base64-encoded image data, converting to
-   * ImageBitmap format required by Tesseract WASM.
-   *
-   * @param imageBytes - Image data as Uint8Array or Base64 string
-   * @returns Promise resolving to ImageBitmap
-   * @throws {Error} If conversion fails (browser API not available or invalid image data)
-   *
-   * @internal
-   */
-  async convertToImageBitmap(imageBytes) {
-    if (typeof createImageBitmap === "undefined") {
-      throw new Error("createImageBitmap is not available. TesseractWasmBackend requires a browser environment.");
-    }
-    try {
-      let bytes = imageBytes;
-      if (typeof imageBytes === "string") {
-        const binaryString = atob(imageBytes);
-        bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-          bytes[i] = binaryString.charCodeAt(i);
-        }
-      }
-      const blob = new Blob([bytes]);
-      const imageBitmap = await createImageBitmap(blob);
-      return imageBitmap;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to convert image bytes to ImageBitmap: ${message}`);
-    }
-  }
-  /**
-   * Get confidence score from OCR result
-   *
-   * Attempts to retrieve confidence score from Tesseract.
-   * Returns a safe default if unavailable.
-   *
-   * @returns Confidence score between 0 and 1
-   *
-   * @internal
-   */
-  async getConfidenceScore() {
-    try {
-      if (this.client && typeof this.client.getConfidence === "function") {
-        const confidence = await this.client.getConfidence();
-        return confidence > 1 ? confidence / 100 : confidence;
-      }
-    } catch {
-    }
-    return 0.9;
-  }
-  /**
-   * Get page metadata from OCR result
-   *
-   * Retrieves additional metadata like image dimensions and processing info.
-   *
-   * @returns Metadata object (may be empty if unavailable)
-   *
-   * @internal
-   */
-  async getPageMetadata() {
-    try {
-      if (this.client && typeof this.client.getPageMetadata === "function") {
-        return await this.client.getPageMetadata();
-      }
-    } catch {
-    }
-    return {};
-  }
-  /**
-   * Dynamically load tesseract-wasm module
-   *
-   * Uses dynamic import to load tesseract-wasm only when needed,
-   * avoiding hard dependency in browser environments where it may not be bundled.
-   *
-   * @returns tesseract-wasm module object
-   * @throws {Error} If module cannot be imported
-   *
-   * @internal
-   */
-  async loadTesseractWasm() {
-    try {
-      const module2 = await import("tesseract-wasm");
-      return module2;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Failed to import tesseract-wasm. Ensure it is installed via: npm install tesseract-wasm. Error: ${message}`
-      );
-    }
-  }
-  /**
-   * Report progress to progress callback
-   *
-   * Internal helper for notifying progress updates during OCR processing.
-   *
-   * @param progress - Progress percentage (0-100)
-   *
-   * @internal
-   */
-  reportProgress(progress) {
-    if (this.progressCallback) {
-      try {
-        this.progressCallback(Math.min(100, Math.max(0, progress)));
-      } catch {
-      }
-    }
-  }
-};
-
-// typescript/runtime.ts
-function detectRuntime() {
-  if (typeof globalThis.Deno !== "undefined") {
-    return "deno";
-  }
-  if (typeof globalThis.Bun !== "undefined") {
-    return "bun";
-  }
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "browser";
-  }
-  return "unknown";
-}
-function isBrowser() {
-  return detectRuntime() === "browser";
-}
-function isNode() {
-  return detectRuntime() === "node";
-}
-function isDeno() {
-  return detectRuntime() === "deno";
-}
-function isBun() {
-  return detectRuntime() === "bun";
-}
-function isWebEnvironment() {
-  const runtime = detectRuntime();
-  return runtime === "browser";
-}
-function isServerEnvironment() {
-  const runtime = detectRuntime();
-  return runtime === "node" || runtime === "deno" || runtime === "bun";
-}
-function hasFileApi() {
-  return typeof window !== "undefined" && typeof File !== "undefined" && typeof Blob !== "undefined";
-}
-function hasBlob() {
-  return typeof Blob !== "undefined";
-}
-function hasWorkers() {
-  return typeof Worker !== "undefined";
-}
-function hasSharedArrayBuffer() {
-  return typeof SharedArrayBuffer !== "undefined";
-}
-function hasModuleWorkers() {
-  if (!hasWorkers()) {
-    return false;
-  }
-  try {
-    const blob = new Blob(['console.log("test")'], {
-      type: "application/javascript"
-    });
-    const workerUrl = URL.createObjectURL(blob);
-    try {
-      return true;
-    } finally {
-      URL.revokeObjectURL(workerUrl);
-    }
-  } catch {
-    return false;
-  }
-}
-function hasWasm() {
-  return typeof WebAssembly !== "undefined" && WebAssembly.instantiate !== void 0;
-}
-function hasWasmStreaming() {
-  return typeof WebAssembly !== "undefined" && WebAssembly.instantiateStreaming !== void 0;
-}
-function hasBigInt() {
-  try {
-    const test = BigInt("1");
-    return typeof test === "bigint";
-  } catch {
-    return false;
-  }
-}
-function getRuntimeVersion() {
-  const runtime = detectRuntime();
-  switch (runtime) {
-    case "node":
-      return process.version?.substring(1);
-    // Remove 'v' prefix
-    case "deno": {
-      const deno = globalThis.Deno;
-      const version = deno?.version;
-      return version?.deno;
-    }
-    case "bun": {
-      const bun = globalThis.Bun;
-      return bun?.version;
-    }
-    default:
-      return void 0;
-  }
-}
-function getWasmCapabilities() {
-  const runtime = detectRuntime();
-  const version = getRuntimeVersion();
-  const capabilities = {
-    runtime,
-    hasWasm: hasWasm(),
-    hasWasmStreaming: hasWasmStreaming(),
-    hasFileApi: hasFileApi(),
-    hasBlob: hasBlob(),
-    hasWorkers: hasWorkers(),
-    hasSharedArrayBuffer: hasSharedArrayBuffer(),
-    hasModuleWorkers: hasModuleWorkers(),
-    hasBigInt: hasBigInt(),
-    ...version !== void 0 ? { runtimeVersion: version } : {}
-  };
-  return capabilities;
-}
-function getRuntimeInfo() {
-  const runtime = detectRuntime();
-  const capabilities = getWasmCapabilities();
-  return {
-    runtime,
-    isBrowser: isBrowser(),
-    isNode: isNode(),
-    isDeno: isDeno(),
-    isBun: isBun(),
-    isWeb: isWebEnvironment(),
-    isServer: isServerEnvironment(),
-    runtimeVersion: getRuntimeVersion(),
-    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "N/A",
-    capabilities
-  };
-}
-
-// typescript/index.ts
-var wasm = null;
-var initialized = false;
-var initializationError = null;
-var initializationPromise = null;
-async function initializePdfiumAsync(wasmModule) {
-  if (!wasmModule || typeof wasmModule.initialize_pdfium_render !== "function") {
-    return;
-  }
-  if (!isBrowser()) {
-    console.debug("PDFium initialization skipped (non-browser environment)");
-    return;
-  }
-  try {
-    const pdfiumModule = await import("./pdfium.js");
-    const pdfium = typeof pdfiumModule.default === "function" ? await pdfiumModule.default() : pdfiumModule;
-    const success = wasmModule.initialize_pdfium_render(pdfium, wasmModule, false);
-    if (!success) {
-      console.warn("PDFium initialization returned false");
-    }
-  } catch (error) {
-    console.debug("PDFium initialization error:", error);
-  }
-}
-async function initWasm() {
-  if (initialized) {
-    return;
-  }
-  if (initializationPromise) {
-    return initializationPromise;
-  }
-  initializationPromise = (async () => {
-    try {
-      if (!hasWasm()) {
-        throw new Error("WebAssembly is not supported in this environment");
-      }
-      let wasmModule;
-      try {
-        wasmModule = await import(
-          /* @vite-ignore */
-          "../pkg/kreuzberg_wasm.js"
-        );
-      } catch {
-        wasmModule = await import(
-          /* @vite-ignore */
-          "./kreuzberg_wasm.js"
-        );
-      }
-      wasm = wasmModule;
-      if (wasm && typeof wasm.default === "function") {
-        await wasm.default();
-      }
-      if (isBrowser() && wasm && typeof wasm.initialize_pdfium_render === "function") {
-        initializePdfiumAsync(wasm).catch((error) => {
-          console.warn("PDFium auto-initialization failed (PDF extraction disabled):", error);
-        });
-      }
-      initialized = true;
-      initializationError = null;
-    } catch (error) {
-      initializationError = error instanceof Error ? error : new Error(String(error));
-      throw wrapWasmError(error, "initializing Kreuzberg WASM module");
-    }
-  })();
-  return initializationPromise;
-}
-function isInitialized() {
-  return initialized;
-}
-function getVersion() {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  return wasm.version();
-}
-function getInitializationError() {
-  return initializationError;
-}
-async function extractBytes(data, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    if (!data || data.length === 0) {
-      throw new Error("Document data cannot be empty");
-    }
-    if (!mimeType) {
-      throw new Error("MIME type is required");
-    }
-    const normalizedConfig = configToJS(config ?? null);
-    const result = await wasm.extractBytes(data, mimeType, normalizedConfig);
-    if (!result) {
-      throw new Error("Invalid extraction result: no result from WASM module");
-    }
-    return jsToExtractionResult(result);
-  } catch (error) {
-    throw wrapWasmError(error, "extracting from bytes");
-  }
-}
-async function extractFile(path, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    if (!path) {
-      throw new Error("File path is required");
-    }
-    const runtime = detectRuntime();
-    if (runtime === "browser") {
-      throw new Error("Use extractBytes with fileToUint8Array for browser environments");
-    }
-    let fileData;
-    if (runtime === "node") {
-      const { readFile } = await import("fs/promises");
-      const buffer = await readFile(path);
-      fileData = new Uint8Array(buffer);
-    } else if (runtime === "deno") {
-      const deno = globalThis.Deno;
-      fileData = await deno.readFile(path);
-    } else if (runtime === "bun") {
-      const { readFile } = await import("fs/promises");
-      const buffer = await readFile(path);
-      fileData = new Uint8Array(buffer);
-    } else {
-      throw new Error(`Unsupported runtime for file extraction: ${runtime}`);
-    }
-    let detectedMimeType = mimeType;
-    if (!detectedMimeType) {
-      detectedMimeType = wasm.detectMimeFromBytes(fileData);
-    }
-    if (!detectedMimeType) {
-      throw new Error("Could not detect MIME type for file. Please provide mimeType parameter.");
-    }
-    detectedMimeType = wasm.normalizeMimeType(detectedMimeType);
-    return await extractBytes(fileData, detectedMimeType, config);
-  } catch (error) {
-    throw wrapWasmError(error, `extracting from file: ${path}`);
-  }
-}
-async function extractFromFile(file, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    const bytes = await fileToUint8Array(file);
-    let type = mimeType ?? (file instanceof File ? file.type : "application/octet-stream");
-    type = wasm.normalizeMimeType(type);
-    return await extractBytes(bytes, type, config);
-  } catch (error) {
-    throw wrapWasmError(error, `extracting from ${file instanceof File ? "file" : "blob"}`);
-  }
-}
-function extractBytesSync(data, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    if (!data || data.length === 0) {
-      throw new Error("Document data cannot be empty");
-    }
-    if (!mimeType) {
-      throw new Error("MIME type is required");
-    }
-    const normalizedConfig = configToJS(config ?? null);
-    const result = wasm.extractBytesSync(data, mimeType, normalizedConfig);
-    if (!result) {
-      throw new Error("Invalid extraction result: no result from WASM module");
-    }
-    return jsToExtractionResult(result);
-  } catch (error) {
-    throw wrapWasmError(error, "extracting from bytes (sync)");
-  }
-}
-async function batchExtractBytes(files, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    if (!Array.isArray(files)) {
-      throw new Error("Files parameter must be an array");
-    }
-    if (files.length === 0) {
-      throw new Error("Files array cannot be empty");
-    }
-    const dataList = [];
-    const mimeTypes = [];
-    for (let i = 0; i < files.length; i += 1) {
-      const file = files[i];
-      if (!file || typeof file !== "object") {
-        throw new Error(`Invalid file at index ${i}: must be an object with data and mimeType`);
-      }
-      const f = file;
-      if (!(f.data instanceof Uint8Array)) {
-        throw new Error(`Invalid file at index ${i}: data must be Uint8Array`);
-      }
-      if (typeof f.mimeType !== "string") {
-        throw new Error(`Invalid file at index ${i}: mimeType must be a string`);
-      }
-      if (f.data.length === 0) {
-        throw new Error(`Invalid file at index ${i}: data cannot be empty`);
-      }
-      dataList.push(f.data);
-      mimeTypes.push(f.mimeType);
-    }
-    const normalizedConfig = configToJS(config ?? null);
-    const results = await wasm.batchExtractBytes(dataList, mimeTypes, normalizedConfig);
-    if (!Array.isArray(results)) {
-      throw new Error("Invalid batch extraction result: expected array");
-    }
-    return results.map((result, index) => {
-      if (!result) {
-        throw new Error(`Invalid extraction result at index ${index}: no result from WASM module`);
-      }
-      return jsToExtractionResult(result);
-    });
-  } catch (error) {
-    throw wrapWasmError(error, "batch extracting from bytes");
-  }
-}
-function batchExtractBytesSync(files, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
-  }
-  try {
-    if (!Array.isArray(files)) {
-      throw new Error("Files parameter must be an array");
-    }
-    if (files.length === 0) {
-      throw new Error("Files array cannot be empty");
-    }
-    const dataList = [];
-    const mimeTypes = [];
-    for (let i = 0; i < files.length; i += 1) {
-      const file = files[i];
-      if (!file || typeof file !== "object") {
-        throw new Error(`Invalid file at index ${i}: must be an object with data and mimeType`);
-      }
-      const f = file;
-      if (!(f.data instanceof Uint8Array)) {
-        throw new Error(`Invalid file at index ${i}: data must be Uint8Array`);
-      }
-      if (typeof f.mimeType !== "string") {
-        throw new Error(`Invalid file at index ${i}: mimeType must be a string`);
-      }
-      if (f.data.length === 0) {
-        throw new Error(`Invalid file at index ${i}: data cannot be empty`);
-      }
-      dataList.push(f.data);
-      mimeTypes.push(f.mimeType);
-    }
-    const normalizedConfig = configToJS(config ?? null);
-    const results = wasm.batchExtractBytesSync(dataList, mimeTypes, normalizedConfig);
-    if (!Array.isArray(results)) {
-      throw new Error("Invalid batch extraction result: expected array");
-    }
-    return results.map((result, index) => {
-      if (!result) {
-        throw new Error(`Invalid extraction result at index ${index}: no result from WASM module`);
-      }
-      return jsToExtractionResult(result);
-    });
-  } catch (error) {
-    throw wrapWasmError(error, "batch extracting from bytes (sync)");
-  }
-}
-async function batchExtractFiles(files, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  try {
-    if (!Array.isArray(files)) {
-      throw new Error("Files parameter must be an array");
-    }
-    if (files.length === 0) {
-      throw new Error("Files array cannot be empty");
-    }
-    const byteFiles = [];
-    for (let i = 0; i < files.length; i += 1) {
-      const file = files[i];
-      if (!(file instanceof File)) {
-        throw new Error(`Invalid file at index ${i}: must be a File object`);
-      }
-      const bytes = await fileToUint8Array(file);
-      byteFiles.push({
-        data: bytes,
-        mimeType: file.type || "application/octet-stream"
-      });
-    }
-    return await batchExtractBytes(byteFiles, config);
-  } catch (error) {
-    throw wrapWasmError(error, "batch extracting from files");
-  }
-}
-async function enableOcr() {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
-  }
-  if (!isBrowser()) {
-    throw new Error(
-      "OCR is only available in browser environments. TesseractWasmBackend requires Web Workers and createImageBitmap."
-    );
-  }
-  try {
-    const backend = new TesseractWasmBackend();
-    await backend.initialize();
-    registerOcrBackend(backend);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to enable OCR: ${message}`);
-  }
-}
-//# sourceMappingURL=index.cjs.map