@kreuzberg/wasm 4.0.0-rc.6 → 4.0.1

package/dist/index.js

@@ -1,88 +1,1020 @@
-"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 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 });
+
+// typescript/pdfium.js
+var pdfium_exports = {};
+__export(pdfium_exports, {
+  default: () => initPdfium
+});
+async function initPdfium() {
+  return {
+    // Dummy implementation for testing
+  };
+}
+var init_pdfium = __esm({
+  "typescript/pdfium.js"() {
+    "use strict";
   }
-  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);
-var index_exports = {};
-__export(index_exports, {
-  TesseractWasmBackend: () => import_tesseract_wasm_backend2.TesseractWasmBackend,
-  batchExtractBytes: () => batchExtractBytes,
-  batchExtractBytesSync: () => batchExtractBytesSync,
-  batchExtractFiles: () => batchExtractFiles,
-  clearOcrBackends: () => import_registry2.clearOcrBackends,
-  configToJS: () => import_wasm_adapter2.configToJS,
-  detectRuntime: () => import_runtime2.detectRuntime,
-  enableOcr: () => enableOcr,
-  extractBytes: () => extractBytes,
-  extractBytesSync: () => extractBytesSync,
-  extractFile: () => extractFile,
-  extractFromFile: () => extractFromFile,
-  fileToUint8Array: () => import_wasm_adapter2.fileToUint8Array,
-  getInitializationError: () => getInitializationError,
-  getOcrBackend: () => import_registry2.getOcrBackend,
-  getRuntimeInfo: () => import_runtime2.getRuntimeInfo,
-  getRuntimeVersion: () => import_runtime2.getRuntimeVersion,
-  getVersion: () => getVersion,
-  getWasmCapabilities: () => import_runtime2.getWasmCapabilities,
-  hasBigInt: () => import_runtime2.hasBigInt,
-  hasBlob: () => import_runtime2.hasBlob,
-  hasFileApi: () => import_runtime2.hasFileApi,
-  hasModuleWorkers: () => import_runtime2.hasModuleWorkers,
-  hasSharedArrayBuffer: () => import_runtime2.hasSharedArrayBuffer,
-  hasWasm: () => import_runtime2.hasWasm,
-  hasWasmStreaming: () => import_runtime2.hasWasmStreaming,
-  hasWorkers: () => import_runtime2.hasWorkers,
-  initWasm: () => initWasm,
-  isBrowser: () => import_runtime2.isBrowser,
-  isBun: () => import_runtime2.isBun,
-  isDeno: () => import_runtime2.isDeno,
-  isInitialized: () => isInitialized,
-  isNode: () => import_runtime2.isNode,
-  isServerEnvironment: () => import_runtime2.isServerEnvironment,
-  isValidExtractionResult: () => import_wasm_adapter2.isValidExtractionResult,
-  isWebEnvironment: () => import_runtime2.isWebEnvironment,
-  jsToExtractionResult: () => import_wasm_adapter2.jsToExtractionResult,
-  listOcrBackends: () => import_registry2.listOcrBackends,
-  registerOcrBackend: () => import_registry2.registerOcrBackend,
-  unregisterOcrBackend: () => import_registry2.unregisterOcrBackend,
-  wrapWasmError: () => import_wasm_adapter2.wrapWasmError
 });
-module.exports = __toCommonJS(index_exports);
-var import_wasm_adapter = require("./adapters/wasm-adapter.js");
-var import_registry = require("./ocr/registry.js");
-var import_tesseract_wasm_backend = require("./ocr/tesseract-wasm-backend.js");
-var import_runtime = require("./runtime.js");
-var import_wasm_adapter2 = require("./adapters/wasm-adapter.js");
-var import_registry2 = require("./ocr/registry.js");
-var import_tesseract_wasm_backend2 = require("./ocr/tesseract-wasm-backend.js");
-var import_runtime2 = require("./runtime.js");
-let wasm = null;
-let initialized = false;
-let initializationError = null;
-let initializationPromise = null;
+
+// 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;
+    }
+    const coerceToNumber = (value, fieldName) => {
+      if (typeof value === "number") {
+        return value;
+      }
+      if (typeof value === "bigint") {
+        return Number(value);
+      }
+      if (typeof value === "string") {
+        const parsed = parseInt(value, 10);
+        if (Number.isNaN(parsed)) {
+          throw new Error(`Invalid chunk metadata: ${fieldName} must be a valid number, got "${value}"`);
+        }
+        return parsed;
+      }
+      throw new Error(`Invalid chunk metadata: ${fieldName} must be a number, got ${typeof value}`);
+    };
+    const charStart = coerceToNumber(
+      metadata.charStart ?? metadata.char_start ?? metadata.byteStart ?? metadata.byte_start,
+      "charStart"
+    );
+    const charEnd = coerceToNumber(
+      metadata.charEnd ?? metadata.char_end ?? metadata.byteEnd ?? metadata.byte_end,
+      "charEnd"
+    );
+    const chunkIndex = coerceToNumber(metadata.chunkIndex ?? metadata.chunk_index, "chunkIndex");
+    const totalChunks = coerceToNumber(metadata.totalChunks ?? metadata.total_chunks, "totalChunks");
+    let tokenCount = null;
+    const tokenCountValue = metadata.tokenCount ?? metadata.token_count;
+    if (tokenCountValue !== null && tokenCountValue !== void 0) {
+      tokenCount = coerceToNumber(tokenCountValue, "tokenCount");
+    }
+    return {
+      content: c.content,
+      embedding,
+      metadata: {
+        charStart,
+        charEnd,
+        tokenCount,
+        chunkIndex,
+        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 = [
+      "eng",
+      "deu",
+      "fra",
+      "spa",
+      "ita",
+      "por",
+      "nld",
+      "rus",
+      "jpn",
+      "kor",
+      "chi_sim",
+      "chi_tra",
+      "pol",
+      "tur",
+      "swe",
+      "dan",
+      "fin",
+      "nor",
+      "ces",
+      "slk",
+      "ron",
+      "hun",
+      "hrv",
+      "srp",
+      "bul",
+      "ukr",
+      "ell",
+      "ara",
+      "heb",
+      "hin",
+      "tha",
+      "vie",
+      "mkd",
+      "ben",
+      "tam",
+      "tel",
+      "kan",
+      "mal",
+      "mya",
+      "khm",
+      "lao",
+      "sin"
+    ];
+    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: []
+      };
+    } 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 module = await import("tesseract-wasm");
+      return module;
+    } 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);
+    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/plugin-registry.ts
+var postProcessors = /* @__PURE__ */ new Map();
+var validators = /* @__PURE__ */ new Map();
+function validatePostProcessor(processor) {
+  if (processor === null || processor === void 0) {
+    throw new Error("Post-processor cannot be null or undefined");
+  }
+  const obj = processor;
+  if (typeof obj.name !== "function") {
+    throw new Error("Post-processor must implement name() method");
+  }
+  if (typeof obj.process !== "function") {
+    throw new Error("Post-processor must implement process() method");
+  }
+  const name = obj.name();
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error("Post-processor name must be a non-empty string");
+  }
+  return true;
+}
+function registerPostProcessor(processor) {
+  validatePostProcessor(processor);
+  const name = processor.name();
+  if (postProcessors.has(name)) {
+    console.warn(`Post-processor "${name}" already registered, overwriting with new implementation`);
+  }
+  postProcessors.set(name, processor);
+}
+function getPostProcessor(name) {
+  return postProcessors.get(name);
+}
+function listPostProcessors() {
+  return Array.from(postProcessors.keys());
+}
+async function unregisterPostProcessor(name) {
+  const processor = postProcessors.get(name);
+  if (!processor) {
+    const available = Array.from(postProcessors.keys());
+    const availableStr = available.length > 0 ? ` Available: ${available.join(", ")}` : "";
+    throw new Error(`Post-processor "${name}" is not registered.${availableStr}`);
+  }
+  try {
+    if (processor.shutdown) {
+      await processor.shutdown();
+    }
+  } catch (error) {
+    console.warn(`Error during shutdown of post-processor "${name}":`, error);
+  }
+  postProcessors.delete(name);
+}
+async function clearPostProcessors() {
+  const entries = Array.from(postProcessors.entries());
+  for (const [_name, processor] of entries) {
+    try {
+      if (processor.shutdown) {
+        await processor.shutdown();
+      }
+    } catch (error) {
+      console.warn(`Error during shutdown of post-processor "${_name}":`, error);
+    }
+  }
+  postProcessors.clear();
+}
+function validateValidator(validator) {
+  if (validator === null || validator === void 0) {
+    throw new Error("Validator cannot be null or undefined");
+  }
+  const obj = validator;
+  if (typeof obj.name !== "function") {
+    throw new Error("Validator must implement name() method");
+  }
+  if (typeof obj.validate !== "function") {
+    throw new Error("Validator must implement validate() method");
+  }
+  const name = obj.name();
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error("Validator name must be a non-empty string");
+  }
+  return true;
+}
+function registerValidator(validator) {
+  validateValidator(validator);
+  const name = validator.name();
+  if (validators.has(name)) {
+    console.warn(`Validator "${name}" already registered, overwriting with new implementation`);
+  }
+  validators.set(name, validator);
+}
+function getValidator(name) {
+  return validators.get(name);
+}
+function listValidators() {
+  return Array.from(validators.keys());
+}
+async function unregisterValidator(name) {
+  const validator = validators.get(name);
+  if (!validator) {
+    const available = Array.from(validators.keys());
+    const availableStr = available.length > 0 ? ` Available: ${available.join(", ")}` : "";
+    throw new Error(`Validator "${name}" is not registered.${availableStr}`);
+  }
+  try {
+    if (validator.shutdown) {
+      await validator.shutdown();
+    }
+  } catch (error) {
+    console.warn(`Error during shutdown of validator "${name}":`, error);
+  }
+  validators.delete(name);
+}
+async function clearValidators() {
+  const entries = Array.from(validators.entries());
+  for (const [_name, validator] of entries) {
+    try {
+      if (validator.shutdown) {
+        await validator.shutdown();
+      }
+    } catch (error) {
+      console.warn(`Error during shutdown of validator "${_name}":`, error);
+    }
+  }
+  validators.clear();
+}
+function executePostProcessor(name, result) {
+  const processor = postProcessors.get(name);
+  if (!processor) {
+    return Promise.reject(new Error(`Post-processor "${name}" is not registered`));
+  }
+  try {
+    const output = processor.process(result);
+    if (output instanceof Promise) {
+      return output;
+    }
+    return Promise.resolve(output);
+  } catch (error) {
+    return Promise.reject(new Error(`Error executing post-processor "${name}": ${String(error)}`));
+  }
+}
+function executeValidator(name, result) {
+  const validator = validators.get(name);
+  if (!validator) {
+    return Promise.reject(new Error(`Validator "${name}" is not registered`));
+  }
+  try {
+    const output = validator.validate(result);
+    if (output instanceof Promise) {
+      return output;
+    }
+    return Promise.resolve(output);
+  } catch (error) {
+    return Promise.reject(new Error(`Error executing validator "${name}": ${String(error)}`));
+  }
+}
+function setupGlobalCallbacks() {
+  if (typeof globalThis !== "undefined") {
+    const callbacksObj = globalThis;
+    callbacksObj.__kreuzberg_execute_post_processor = executePostProcessor;
+    callbacksObj.__kreuzberg_execute_validator = executeValidator;
+  }
+}
+setupGlobalCallbacks();
+
+// 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 Promise.resolve().then(() => (init_pdfium(), pdfium_exports));
+    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;
@@ -92,24 +1024,37 @@ async function initWasm() {
   }
   initializationPromise = (async () => {
     try {
-      if (!(0, import_runtime.hasWasm)()) {
+      if (!hasWasm()) {
         throw new Error("WebAssembly is not supported in this environment");
       }
       let wasmModule;
+      const pkgPath = "./pkg/kreuzberg_wasm.js";
+      const fallbackPath = "./kreuzberg_wasm.js";
       try {
-        wasmModule = await import("../../pkg/kreuzberg_wasm");
+        wasmModule = await import(
+          /* @vite-ignore */
+          pkgPath
+        );
       } catch {
-        wasmModule = await import("./kreuzberg_wasm");
+        wasmModule = await import(
+          /* @vite-ignore */
+          fallbackPath
+        );
       }
       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 (0, import_wasm_adapter.wrapWasmError)(error, "initializing Kreuzberg WASM module");
+      throw wrapWasmError(error, "initializing Kreuzberg WASM module");
     }
   })();
   return initializationPromise;
@@ -143,14 +1088,14 @@ async function extractBytes(data, mimeType, config) {
     if (!mimeType) {
       throw new Error("MIME type is required");
     }
-    const normalizedConfig = (0, import_wasm_adapter.configToJS)(config ?? null);
+    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 (0, import_wasm_adapter.jsToExtractionResult)(result);
+    return jsToExtractionResult(result);
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, "extracting from bytes");
+    throw wrapWasmError(error, "extracting from bytes");
   }
 }
 async function extractFile(path, mimeType, config) {
@@ -164,20 +1109,20 @@ async function extractFile(path, mimeType, config) {
     if (!path) {
       throw new Error("File path is required");
     }
-    const runtime = (0, import_runtime.detectRuntime)();
+    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("node:fs/promises");
+      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("node:fs/promises");
+      const { readFile } = await import("fs/promises");
       const buffer = await readFile(path);
       fileData = new Uint8Array(buffer);
     } else {
@@ -193,7 +1138,7 @@ async function extractFile(path, mimeType, config) {
     detectedMimeType = wasm.normalizeMimeType(detectedMimeType);
     return await extractBytes(fileData, detectedMimeType, config);
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, `extracting from file: ${path}`);
+    throw wrapWasmError(error, `extracting from file: ${path}`);
   }
 }
 async function extractFromFile(file, mimeType, config) {
@@ -204,12 +1149,12 @@ async function extractFromFile(file, mimeType, config) {
     throw new Error("WASM module not loaded. Call initWasm() first.");
   }
   try {
-    const bytes = await (0, import_wasm_adapter.fileToUint8Array)(file);
+    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 (0, import_wasm_adapter.wrapWasmError)(error, `extracting from ${file instanceof File ? "file" : "blob"}`);
+    throw wrapWasmError(error, `extracting from ${file instanceof File ? "file" : "blob"}`);
   }
 }
 function extractBytesSync(data, mimeType, config) {
@@ -226,14 +1171,14 @@ function extractBytesSync(data, mimeType, config) {
     if (!mimeType) {
       throw new Error("MIME type is required");
     }
-    const normalizedConfig = (0, import_wasm_adapter.configToJS)(config ?? null);
+    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 (0, import_wasm_adapter.jsToExtractionResult)(result);
+    return jsToExtractionResult(result);
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, "extracting from bytes (sync)");
+    throw wrapWasmError(error, "extracting from bytes (sync)");
   }
 }
 async function batchExtractBytes(files, config) {
@@ -270,7 +1215,7 @@ async function batchExtractBytes(files, config) {
       dataList.push(f.data);
       mimeTypes.push(f.mimeType);
     }
-    const normalizedConfig = (0, import_wasm_adapter.configToJS)(config ?? null);
+    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");
@@ -279,10 +1224,10 @@ async function batchExtractBytes(files, config) {
       if (!result) {
         throw new Error(`Invalid extraction result at index ${index}: no result from WASM module`);
       }
-      return (0, import_wasm_adapter.jsToExtractionResult)(result);
+      return jsToExtractionResult(result);
     });
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, "batch extracting from bytes");
+    throw wrapWasmError(error, "batch extracting from bytes");
   }
 }
 function batchExtractBytesSync(files, config) {
@@ -319,7 +1264,7 @@ function batchExtractBytesSync(files, config) {
       dataList.push(f.data);
       mimeTypes.push(f.mimeType);
     }
-    const normalizedConfig = (0, import_wasm_adapter.configToJS)(config ?? null);
+    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");
@@ -328,10 +1273,10 @@ function batchExtractBytesSync(files, config) {
       if (!result) {
         throw new Error(`Invalid extraction result at index ${index}: no result from WASM module`);
       }
-      return (0, import_wasm_adapter.jsToExtractionResult)(result);
+      return jsToExtractionResult(result);
     });
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, "batch extracting from bytes (sync)");
+    throw wrapWasmError(error, "batch extracting from bytes (sync)");
   }
 }
 async function batchExtractFiles(files, config) {
@@ -351,7 +1296,7 @@ async function batchExtractFiles(files, config) {
       if (!(file instanceof File)) {
         throw new Error(`Invalid file at index ${i}: must be a File object`);
       }
-      const bytes = await (0, import_wasm_adapter.fileToUint8Array)(file);
+      const bytes = await fileToUint8Array(file);
       byteFiles.push({
         data: bytes,
         mimeType: file.type || "application/octet-stream"
@@ -359,25 +1304,78 @@ async function batchExtractFiles(files, config) {
     }
     return await batchExtractBytes(byteFiles, config);
   } catch (error) {
-    throw (0, import_wasm_adapter.wrapWasmError)(error, "batch extracting from files");
+    throw wrapWasmError(error, "batch extracting from files");
   }
 }
 async function enableOcr() {
   if (!initialized) {
     throw new Error("WASM module not initialized. Call initWasm() first.");
   }
-  if (!(0, import_runtime.isBrowser)()) {
+  if (!isBrowser()) {
     throw new Error(
       "OCR is only available in browser environments. TesseractWasmBackend requires Web Workers and createImageBitmap."
     );
   }
   try {
-    const backend = new import_tesseract_wasm_backend.TesseractWasmBackend();
+    const backend = new TesseractWasmBackend();
     await backend.initialize();
-    (0, import_registry.registerOcrBackend)(backend);
+    registerOcrBackend(backend);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to enable OCR: ${message}`);
   }
 }
+export {
+  TesseractWasmBackend,
+  batchExtractBytes,
+  batchExtractBytesSync,
+  batchExtractFiles,
+  clearOcrBackends,
+  clearPostProcessors,
+  clearValidators,
+  configToJS,
+  detectRuntime,
+  enableOcr,
+  extractBytes,
+  extractBytesSync,
+  extractFile,
+  extractFromFile,
+  fileToUint8Array,
+  getInitializationError,
+  getOcrBackend,
+  getPostProcessor,
+  getRuntimeInfo,
+  getRuntimeVersion,
+  getValidator,
+  getVersion,
+  getWasmCapabilities,
+  hasBigInt,
+  hasBlob,
+  hasFileApi,
+  hasModuleWorkers,
+  hasSharedArrayBuffer,
+  hasWasm,
+  hasWasmStreaming,
+  hasWorkers,
+  initWasm,
+  isBrowser,
+  isBun,
+  isDeno,
+  isInitialized,
+  isNode,
+  isServerEnvironment,
+  isValidExtractionResult,
+  isWebEnvironment,
+  jsToExtractionResult,
+  listOcrBackends,
+  listPostProcessors,
+  listValidators,
+  registerOcrBackend,
+  registerPostProcessor,
+  registerValidator,
+  unregisterOcrBackend,
+  unregisterPostProcessor,
+  unregisterValidator,
+  wrapWasmError
+};
 //# sourceMappingURL=index.js.map