@kreuzberg/wasm 4.0.8 → 4.1.0

package/dist/index.js

@@ -24,6 +24,176 @@ var init_pdfium = __esm({
   }
 });
 
+// typescript/runtime.ts
+function detectRuntime() {
+  const globalCaches = globalThis.caches;
+  if (typeof caches !== "undefined" && globalCaches !== null && typeof globalCaches === "object" && "default" in globalCaches && typeof window === "undefined" && typeof document === "undefined") {
+    return "cloudflare-workers";
+  }
+  if (typeof globalThis.EdgeRuntime !== "undefined") {
+    return "edge-runtime";
+  }
+  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 isCloudflareWorkers() {
+  return detectRuntime() === "cloudflare-workers";
+}
+function isEdgeRuntime() {
+  return detectRuntime() === "edge-runtime";
+}
+function isEdgeEnvironment() {
+  const runtime = detectRuntime();
+  return runtime === "cloudflare-workers" || runtime === "edge-runtime";
+}
+function isWebEnvironment() {
+  const runtime = detectRuntime();
+  return runtime === "browser";
+}
+function isServerEnvironment() {
+  const runtime = detectRuntime();
+  return runtime === "node" || runtime === "deno" || runtime === "bun" || runtime === "cloudflare-workers" || runtime === "edge-runtime";
+}
+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/initialization/pdfium-loader.ts
+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);
+  }
+}
+
 // typescript/adapters/wasm-adapter.ts
 var MAX_FILE_SIZE = 512 * 1024 * 1024;
 function isNumberOrNull(value) {
@@ -257,59 +427,417 @@ function isValidExtractionResult(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");
+// typescript/initialization/state.ts
+var wasm = null;
+var initialized = false;
+var initializationError = null;
+var initializationPromise = null;
+function getWasmModule() {
+  return wasm;
+}
+function setWasmModule(module) {
+  wasm = module;
+}
+function isInitialized() {
+  return initialized;
+}
+function setInitialized(value) {
+  initialized = value;
+}
+function getInitializationError() {
+  return initializationError;
+}
+function setInitializationError(error) {
+  initializationError = error;
+}
+function getInitializationPromise() {
+  return initializationPromise;
+}
+function setInitializationPromise(promise) {
+  initializationPromise = promise;
+}
+
+// typescript/initialization/wasm-loader.ts
+async function loadWasmBinaryForNode() {
+  if (!isNode()) {
+    return void 0;
   }
-  if (typeof backend.processImage !== "function") {
-    throw new Error("Backend must implement processImage() method");
+  try {
+    const fs = await import(
+      /* @vite-ignore */
+      "fs/promises"
+    );
+    const path = await import(
+      /* @vite-ignore */
+      "path"
+    );
+    const url = await import(
+      /* @vite-ignore */
+      "url"
+    );
+    const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+    const wasmPath = path.join(__dirname, "..", "pkg", "kreuzberg_wasm_bg.wasm");
+    const wasmBuffer = await fs.readFile(wasmPath);
+    return new Uint8Array(wasmBuffer);
+  } catch {
+    return void 0;
   }
-  const backendName = backend.name();
-  if (!backendName || typeof backendName !== "string") {
-    throw new Error("Backend name must be a non-empty string");
+}
+function getVersion() {
+  if (!isInitialized()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
   }
-  if (ocrBackendRegistry.has(backendName)) {
-    console.warn(`OCR backend "${backendName}" is already registered and will be replaced`);
+  const wasmModule = getWasmModule();
+  if (!wasmModule) {
+    throw new Error("WASM module not loaded. Call initWasm() first.");
   }
-  ocrBackendRegistry.set(backendName, backend);
-}
-function getOcrBackend(name) {
-  return ocrBackendRegistry.get(name);
-}
-function listOcrBackends() {
-  return Array.from(ocrBackendRegistry.keys());
+  return wasmModule.version();
 }
-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(", ")}`
-    );
+async function initWasm() {
+  if (isInitialized()) {
+    return;
   }
-  if (typeof backend.shutdown === "function") {
+  let currentPromise = getInitializationPromise();
+  if (currentPromise) {
+    return currentPromise;
+  }
+  currentPromise = (async () => {
     try {
-      await backend.shutdown();
+      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(
+          /* @vite-ignore */
+          pkgPath
+        );
+      } catch {
+        wasmModule = await import(
+          /* @vite-ignore */
+          fallbackPath
+        );
+      }
+      const loadedModule = wasmModule;
+      setWasmModule(loadedModule);
+      if (loadedModule && typeof loadedModule.default === "function") {
+        const wasmBinary = await loadWasmBinaryForNode();
+        if (wasmBinary) {
+          await loadedModule.default(wasmBinary);
+        } else {
+          await loadedModule.default();
+        }
+      }
+      if (isBrowser() && loadedModule && typeof loadedModule.initialize_pdfium_render === "function") {
+        initializePdfiumAsync(loadedModule).catch((error) => {
+          console.warn("PDFium auto-initialization failed (PDF extraction disabled):", error);
+        });
+      }
+      setInitialized(true);
+      setInitializationError(null);
     } catch (error) {
-      console.warn(
-        `Error shutting down OCR backend "${name}": ${error instanceof Error ? error.message : String(error)}`
-      );
+      setInitializationError(error instanceof Error ? error : new Error(String(error)));
+      throw wrapWasmError(error, "initializing Kreuzberg WASM module");
     }
+  })();
+  setInitializationPromise(currentPromise);
+  return currentPromise;
+}
+
+// typescript/extraction/internal.ts
+function getWasmModule2() {
+  const wasm2 = getWasmModule();
+  if (!wasm2) {
+    throw new Error("WASM module not loaded. Call initWasm() first.");
   }
-  ocrBackendRegistry.delete(name);
+  return wasm2;
 }
-async function clearOcrBackends() {
-  const backends = Array.from(ocrBackendRegistry.entries());
-  for (const [name, backend] of backends) {
-    if (typeof backend.shutdown === "function") {
-      try {
+function isInitialized2() {
+  return isInitialized();
+}
+
+// typescript/extraction/bytes.ts
+async function extractBytes(data, mimeType, config) {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  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 wasm2.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");
+  }
+}
+function extractBytesSync(data, mimeType, config) {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  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 = wasm2.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)");
+  }
+}
+
+// typescript/extraction/files.ts
+async function extractFile(path, mimeType, config) {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  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 = wasm2.detectMimeFromBytes(fileData);
+    }
+    if (!detectedMimeType) {
+      throw new Error("Could not detect MIME type for file. Please provide mimeType parameter.");
+    }
+    detectedMimeType = wasm2.normalizeMimeType(detectedMimeType);
+    return await extractBytes(fileData, detectedMimeType, config);
+  } catch (error) {
+    throw wrapWasmError(error, `extracting from file: ${path}`);
+  }
+}
+async function extractFromFile(file, mimeType, config) {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  try {
+    const bytes = await fileToUint8Array(file);
+    let type = mimeType ?? (file instanceof File ? file.type : "application/octet-stream");
+    type = wasm2.normalizeMimeType(type);
+    return await extractBytes(bytes, type, config);
+  } catch (error) {
+    throw wrapWasmError(error, `extracting from ${file instanceof File ? "file" : "blob"}`);
+  }
+}
+
+// typescript/extraction/batch.ts
+async function batchExtractBytes(files, config) {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  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 wasm2.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 (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const wasm2 = getWasmModule2();
+  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 = wasm2.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 (!isInitialized2()) {
+    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");
+  }
+}
+
+// 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(
@@ -697,136 +1225,24 @@ var TesseractWasmBackend = class {
   }
 };
 
-// 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;
+// typescript/ocr/enabler.ts
+async function enableOcr() {
+  if (!isInitialized2()) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
   }
-}
-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;
+  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}`);
   }
-}
-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
@@ -871,460 +1287,125 @@ async function unregisterPostProcessor(name) {
     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;
-  }
-  if (initializationPromise) {
-    return initializationPromise;
-  }
-  initializationPromise = (async () => {
-    try {
-      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(
-          /* @vite-ignore */
-          pkgPath
-        );
-      } catch {
-        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 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.");
+    if (processor.shutdown) {
+      await processor.shutdown();
     }
-    detectedMimeType = wasm.normalizeMimeType(detectedMimeType);
-    return await extractBytes(fileData, detectedMimeType, config);
   } catch (error) {
-    throw wrapWasmError(error, `extracting from file: ${path}`);
+    console.warn(`Error during shutdown of post-processor "${name}":`, error);
   }
+  postProcessors.delete(name);
 }
-async function extractFromFile(file, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
+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);
+    }
   }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
+  postProcessors.clear();
+}
+function validateValidator(validator) {
+  if (validator === null || validator === void 0) {
+    throw new Error("Validator cannot be null or undefined");
   }
-  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"}`);
+  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 extractBytesSync(data, mimeType, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
+function registerValidator(validator) {
+  validateValidator(validator);
+  const name = validator.name();
+  if (validators.has(name)) {
+    console.warn(`Validator "${name}" already registered, overwriting with new implementation`);
   }
-  if (!wasm) {
-    throw new Error("WASM module not loaded. Call initWasm() first.");
+  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 (!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");
+    if (validator.shutdown) {
+      await validator.shutdown();
     }
-    return jsToExtractionResult(result);
   } catch (error) {
-    throw wrapWasmError(error, "extracting from bytes (sync)");
+    console.warn(`Error during shutdown of validator "${name}":`, error);
   }
+  validators.delete(name);
 }
-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`);
+async function clearValidators() {
+  const entries = Array.from(validators.entries());
+  for (const [_name, validator] of entries) {
+    try {
+      if (validator.shutdown) {
+        await validator.shutdown();
       }
-      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");
+    } catch (error) {
+      console.warn(`Error during shutdown of validator "${_name}":`, error);
     }
-    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");
   }
+  validators.clear();
 }
-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.");
+function executePostProcessor(name, result) {
+  const processor = postProcessors.get(name);
+  if (!processor) {
+    return Promise.reject(new Error(`Post-processor "${name}" is not registered`));
   }
   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");
+    const output = processor.process(result);
+    if (output instanceof Promise) {
+      return output;
     }
-    return results.map((result, index) => {
-      if (!result) {
-        throw new Error(`Invalid extraction result at index ${index}: no result from WASM module`);
-      }
-      return jsToExtractionResult(result);
-    });
+    return Promise.resolve(output);
   } catch (error) {
-    throw wrapWasmError(error, "batch extracting from bytes (sync)");
+    return Promise.reject(new Error(`Error executing post-processor "${name}": ${String(error)}`));
   }
 }
-async function batchExtractFiles(files, config) {
-  if (!initialized) {
-    throw new Error("WASM module not initialized. Call initWasm() first.");
+function executeValidator(name, result) {
+  const validator = validators.get(name);
+  if (!validator) {
+    return Promise.reject(new Error(`Validator "${name}" is not registered`));
   }
   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"
-      });
+    const output = validator.validate(result);
+    if (output instanceof Promise) {
+      return output;
     }
-    return await batchExtractBytes(byteFiles, config);
+    return Promise.resolve(output);
   } catch (error) {
-    throw wrapWasmError(error, "batch extracting from files");
+    return Promise.reject(new Error(`Error executing validator "${name}": ${String(error)}`));
   }
 }
-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}`);
+function setupGlobalCallbacks() {
+  if (typeof globalThis !== "undefined") {
+    const callbacksObj = globalThis;
+    callbacksObj.__kreuzberg_execute_post_processor = executePostProcessor;
+    callbacksObj.__kreuzberg_execute_validator = executeValidator;
   }
 }
+setupGlobalCallbacks();
 export {
   TesseractWasmBackend,
   batchExtractBytes,
@@ -1349,6 +1430,7 @@ export {
   getValidator,
   getVersion,
   getWasmCapabilities,
+  getWasmModule,
   hasBigInt,
   hasBlob,
   hasFileApi,
@@ -1358,9 +1440,13 @@ export {
   hasWasmStreaming,
   hasWorkers,
   initWasm,
+  initializePdfiumAsync,
   isBrowser,
   isBun,
+  isCloudflareWorkers,
   isDeno,
+  isEdgeEnvironment,
+  isEdgeRuntime,
   isInitialized,
   isNode,
   isServerEnvironment,