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

package/dist/index.js

@@ -1,3 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// 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";
+  }
+});
+
 // typescript/adapters/wasm-adapter.ts
 var MAX_FILE_SIZE = 512 * 1024 * 1024;
 function isNumberOrNull(value) {
@@ -104,30 +130,52 @@ function jsToExtractionResult(jsValue) {
       }
       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");
+    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 (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: metadata.charStart,
-        charEnd: metadata.charEnd,
-        tokenCount: metadata.tokenCount,
-        chunkIndex: metadata.chunkIndex,
-        totalChunks: metadata.totalChunks
+        charStart,
+        charEnd,
+        tokenCount,
+        chunkIndex,
+        totalChunks
       }
     };
   }) : null;
@@ -312,93 +360,48 @@ var TesseractWasmBackend = class {
       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;
   }
@@ -500,7 +503,6 @@ var TesseractWasmBackend = class {
           ...pageMetadata
         },
         tables: []
-        // Tesseract-wasm doesn't provide structured table detection
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -786,7 +788,6 @@ function getRuntimeVersion() {
   switch (runtime) {
     case "node":
       return process.version?.substring(1);
-    // Remove 'v' prefix
     case "deno": {
       const deno = globalThis.Deno;
       const version = deno?.version;
@@ -834,6 +835,168 @@ function getRuntimeInfo() {
   };
 }
 
+// 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;
@@ -848,7 +1011,7 @@ async function initializePdfiumAsync(wasmModule) {
     return;
   }
   try {
-    const pdfiumModule = await import("./pdfium.js");
+    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) {
@@ -1172,6 +1335,8 @@ export {
   batchExtractBytesSync,
   batchExtractFiles,
   clearOcrBackends,
+  clearPostProcessors,
+  clearValidators,
   configToJS,
   detectRuntime,
   enableOcr,
@@ -1182,8 +1347,10 @@ export {
   fileToUint8Array,
   getInitializationError,
   getOcrBackend,
+  getPostProcessor,
   getRuntimeInfo,
   getRuntimeVersion,
+  getValidator,
   getVersion,
   getWasmCapabilities,
   hasBigInt,
@@ -1205,8 +1372,14 @@ export {
   isWebEnvironment,
   jsToExtractionResult,
   listOcrBackends,
+  listPostProcessors,
+  listValidators,
   registerOcrBackend,
+  registerPostProcessor,
+  registerValidator,
   unregisterOcrBackend,
+  unregisterPostProcessor,
+  unregisterValidator,
   wrapWasmError
 };
 //# sourceMappingURL=index.js.map