@kreuzberg/node 4.0.0-rc.5 → 4.0.0-rc.8

package/dist/index.mjs

@@ -0,0 +1,754 @@
+import { createRequire } from "node:module";
+import {
+  CacheError,
+  ErrorCode,
+  ImageProcessingError,
+  KreuzbergError,
+  MissingDependencyError,
+  OcrError,
+  ParsingError,
+  PluginError,
+  ValidationError
+} from "./errors.js";
+import { GutenOcrBackend } from "./ocr/guten-ocr.js";
+export * from "./types.js";
+let binding = null;
+let bindingInitialized = false;
+function createNativeBindingError(error) {
+  const hintParts = [];
+  let detail = "Unknown error while requiring native module.";
+  if (error instanceof Error) {
+    detail = error.message || error.toString();
+    if (/pdfium/i.test(detail)) {
+      hintParts.push(
+        "Pdfium runtime library was not found. Ensure the bundled libpdfium (dll/dylib/so) is present next to the native module."
+      );
+    }
+    return new Error(
+      [
+        "Failed to load Kreuzberg native bindings.",
+        hintParts.length ? hintParts.join(" ") : "",
+        "Report this error and attach the logs/stack trace for investigation.",
+        `Underlying error: ${detail}`
+      ].filter(Boolean).join(" "),
+      { cause: error }
+    );
+  }
+  return new Error(
+    [
+      "Failed to load Kreuzberg native bindings.",
+      "Report this error and attach the logs/stack trace for investigation.",
+      `Underlying error: ${String(error)}`
+    ].join(" ")
+  );
+}
+function assertUint8Array(value, name) {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name} must be a Uint8Array`);
+  }
+  return value;
+}
+function assertUint8ArrayList(values, name) {
+  if (!Array.isArray(values)) {
+    throw new TypeError(`${name} must be an array of Uint8Array`);
+  }
+  const array = values;
+  return array.map((value, index) => {
+    try {
+      return assertUint8Array(value, `${name}[${index}]`);
+    } catch {
+      throw new TypeError(`${name}[${index}] must be a Uint8Array`);
+    }
+  });
+}
+function __setBindingForTests(mock) {
+  binding = mock;
+  bindingInitialized = true;
+}
+function __resetBindingForTests() {
+  binding = null;
+  bindingInitialized = false;
+}
+function loadNativeBinding() {
+  const localRequire = typeof require !== "undefined" ? (
+    // biome-ignore lint/suspicious/noExplicitAny: Node typings are available at runtime
+    require
+  ) : createRequire(import.meta.url);
+  if (!localRequire) {
+    throw new Error("Unable to resolve native binding loader (require not available).");
+  }
+  return localRequire("../index.js");
+}
+function getBinding() {
+  if (bindingInitialized) {
+    return binding;
+  }
+  try {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      binding = loadNativeBinding();
+      bindingInitialized = true;
+      return binding;
+    }
+  } catch (error) {
+    throw createNativeBindingError(error);
+  }
+  throw new Error(
+    "Failed to load Kreuzberg bindings. Neither NAPI (Node.js) nor WASM (browsers/Deno) bindings are available. Make sure you have installed the @kreuzberg/node package for Node.js/Bun."
+  );
+}
+function parseMetadata(metadataStr) {
+  try {
+    return JSON.parse(metadataStr);
+  } catch {
+    return {};
+  }
+}
+function ensureUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof Buffer !== "undefined" && value instanceof Buffer) {
+    return new Uint8Array(value);
+  }
+  if (Array.isArray(value)) {
+    return new Uint8Array(value);
+  }
+  return new Uint8Array();
+}
+function convertChunk(rawChunk) {
+  if (!rawChunk) {
+    return {
+      content: "",
+      metadata: {
+        byteStart: 0,
+        byteEnd: 0,
+        tokenCount: null,
+        chunkIndex: 0,
+        totalChunks: 0
+      },
+      embedding: null
+    };
+  }
+  const metadata = rawChunk.metadata ?? {};
+  return {
+    content: rawChunk.content ?? "",
+    embedding: rawChunk.embedding ?? null,
+    metadata: {
+      byteStart: metadata.byte_start ?? metadata.charStart ?? 0,
+      byteEnd: metadata.byte_end ?? metadata.charEnd ?? 0,
+      tokenCount: metadata.token_count ?? metadata.tokenCount ?? null,
+      chunkIndex: metadata.chunk_index ?? metadata.chunkIndex ?? 0,
+      totalChunks: metadata.total_chunks ?? metadata.totalChunks ?? 0,
+      firstPage: metadata.first_page ?? metadata.firstPage ?? null,
+      lastPage: metadata.last_page ?? metadata.lastPage ?? null
+    }
+  };
+}
+function convertImage(rawImage) {
+  if (!rawImage) {
+    return {
+      data: new Uint8Array(),
+      format: "unknown",
+      imageIndex: 0,
+      pageNumber: null,
+      width: null,
+      height: null,
+      colorspace: null,
+      bitsPerComponent: null,
+      isMask: false,
+      description: null,
+      ocrResult: null
+    };
+  }
+  return {
+    data: ensureUint8Array(rawImage.data),
+    format: rawImage.format ?? "unknown",
+    imageIndex: rawImage.imageIndex ?? 0,
+    pageNumber: rawImage.pageNumber ?? null,
+    width: rawImage.width ?? null,
+    height: rawImage.height ?? null,
+    colorspace: rawImage.colorspace ?? null,
+    bitsPerComponent: rawImage.bitsPerComponent ?? null,
+    isMask: rawImage.isMask ?? false,
+    description: rawImage.description ?? null,
+    ocrResult: rawImage.ocrResult ? convertResult(rawImage.ocrResult) : null
+  };
+}
+function convertResult(rawResult) {
+  return {
+    content: rawResult.content,
+    mimeType: rawResult.mimeType,
+    metadata: typeof rawResult.metadata === "string" ? parseMetadata(rawResult.metadata) : rawResult.metadata,
+    tables: rawResult.tables || [],
+    detectedLanguages: rawResult.detectedLanguages || null,
+    chunks: Array.isArray(rawResult.chunks) ? rawResult.chunks.map((chunk) => convertChunk(chunk)) : null,
+    images: Array.isArray(rawResult.images) ? rawResult.images.map((image) => convertImage(image)) : null
+  };
+}
+function setIfDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function normalizeTesseractConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "psm", config.psm);
+  setIfDefined(normalized, "enableTableDetection", config.enableTableDetection);
+  setIfDefined(normalized, "tesseditCharWhitelist", config.tesseditCharWhitelist);
+  return normalized;
+}
+function normalizeOcrConfig(ocr) {
+  if (!ocr) {
+    return void 0;
+  }
+  const normalized = {
+    backend: ocr.backend
+  };
+  setIfDefined(normalized, "language", ocr.language);
+  const tesseract = normalizeTesseractConfig(ocr.tesseractConfig);
+  if (tesseract) {
+    setIfDefined(normalized, "tesseractConfig", tesseract);
+  }
+  return normalized;
+}
+function normalizeChunkingConfig(chunking) {
+  if (!chunking) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "maxChars", chunking.maxChars);
+  setIfDefined(normalized, "maxOverlap", chunking.maxOverlap);
+  setIfDefined(normalized, "preset", chunking.preset);
+  setIfDefined(normalized, "embedding", chunking.embedding);
+  setIfDefined(normalized, "enabled", chunking.enabled);
+  return normalized;
+}
+function normalizeImageExtractionConfig(images) {
+  if (!images) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "extractImages", images.extractImages);
+  setIfDefined(normalized, "targetDpi", images.targetDpi);
+  setIfDefined(normalized, "maxImageDimension", images.maxImageDimension);
+  setIfDefined(normalized, "autoAdjustDpi", images.autoAdjustDpi);
+  setIfDefined(normalized, "minDpi", images.minDpi);
+  setIfDefined(normalized, "maxDpi", images.maxDpi);
+  return normalized;
+}
+function normalizePdfConfig(pdf) {
+  if (!pdf) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "extractImages", pdf.extractImages);
+  setIfDefined(normalized, "passwords", pdf.passwords);
+  setIfDefined(normalized, "extractMetadata", pdf.extractMetadata);
+  return normalized;
+}
+function normalizeTokenReductionConfig(tokenReduction) {
+  if (!tokenReduction) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "mode", tokenReduction.mode);
+  setIfDefined(normalized, "preserveImportantWords", tokenReduction.preserveImportantWords);
+  return normalized;
+}
+function normalizeLanguageDetectionConfig(languageDetection) {
+  if (!languageDetection) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "enabled", languageDetection.enabled);
+  setIfDefined(normalized, "minConfidence", languageDetection.minConfidence);
+  setIfDefined(normalized, "detectMultiple", languageDetection.detectMultiple);
+  return normalized;
+}
+function normalizePostProcessorConfig(postprocessor) {
+  if (!postprocessor) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "enabled", postprocessor.enabled);
+  setIfDefined(normalized, "enabledProcessors", postprocessor.enabledProcessors);
+  setIfDefined(normalized, "disabledProcessors", postprocessor.disabledProcessors);
+  return normalized;
+}
+function normalizeHtmlPreprocessing(options) {
+  if (!options) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "enabled", options.enabled);
+  setIfDefined(normalized, "preset", options.preset);
+  setIfDefined(normalized, "removeNavigation", options.removeNavigation);
+  setIfDefined(normalized, "removeForms", options.removeForms);
+  return normalized;
+}
+function normalizeHtmlOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "headingStyle", options.headingStyle);
+  setIfDefined(normalized, "listIndentType", options.listIndentType);
+  setIfDefined(normalized, "listIndentWidth", options.listIndentWidth);
+  setIfDefined(normalized, "bullets", options.bullets);
+  setIfDefined(normalized, "strongEmSymbol", options.strongEmSymbol);
+  setIfDefined(normalized, "escapeAsterisks", options.escapeAsterisks);
+  setIfDefined(normalized, "escapeUnderscores", options.escapeUnderscores);
+  setIfDefined(normalized, "escapeMisc", options.escapeMisc);
+  setIfDefined(normalized, "escapeAscii", options.escapeAscii);
+  setIfDefined(normalized, "codeLanguage", options.codeLanguage);
+  setIfDefined(normalized, "autolinks", options.autolinks);
+  setIfDefined(normalized, "defaultTitle", options.defaultTitle);
+  setIfDefined(normalized, "brInTables", options.brInTables);
+  setIfDefined(normalized, "hocrSpatialTables", options.hocrSpatialTables);
+  setIfDefined(normalized, "highlightStyle", options.highlightStyle);
+  setIfDefined(normalized, "extractMetadata", options.extractMetadata);
+  setIfDefined(normalized, "whitespaceMode", options.whitespaceMode);
+  setIfDefined(normalized, "stripNewlines", options.stripNewlines);
+  setIfDefined(normalized, "wrap", options.wrap);
+  setIfDefined(normalized, "wrapWidth", options.wrapWidth);
+  setIfDefined(normalized, "convertAsInline", options.convertAsInline);
+  setIfDefined(normalized, "subSymbol", options.subSymbol);
+  setIfDefined(normalized, "supSymbol", options.supSymbol);
+  setIfDefined(normalized, "newlineStyle", options.newlineStyle);
+  setIfDefined(normalized, "codeBlockStyle", options.codeBlockStyle);
+  setIfDefined(normalized, "keepInlineImagesIn", options.keepInlineImagesIn);
+  setIfDefined(normalized, "encoding", options.encoding);
+  setIfDefined(normalized, "debug", options.debug);
+  setIfDefined(normalized, "stripTags", options.stripTags);
+  setIfDefined(normalized, "preserveTags", options.preserveTags);
+  const preprocessing = normalizeHtmlPreprocessing(options.preprocessing);
+  setIfDefined(normalized, "preprocessing", preprocessing);
+  return normalized;
+}
+function normalizeKeywordConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "algorithm", config.algorithm);
+  setIfDefined(normalized, "maxKeywords", config.maxKeywords);
+  setIfDefined(normalized, "minScore", config.minScore);
+  setIfDefined(normalized, "ngramRange", config.ngramRange);
+  setIfDefined(normalized, "language", config.language);
+  setIfDefined(normalized, "yakeParams", config.yakeParams);
+  setIfDefined(normalized, "rakeParams", config.rakeParams);
+  return normalized;
+}
+function normalizePageConfig(pages) {
+  if (!pages) {
+    return void 0;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "extract_pages", pages.extractPages);
+  setIfDefined(normalized, "insert_page_markers", pages.insertPageMarkers);
+  setIfDefined(normalized, "marker_format", pages.markerFormat);
+  return normalized;
+}
+function normalizeExtractionConfig(config) {
+  if (!config) {
+    return null;
+  }
+  const normalized = {};
+  setIfDefined(normalized, "useCache", config.useCache);
+  setIfDefined(normalized, "enableQualityProcessing", config.enableQualityProcessing);
+  setIfDefined(normalized, "forceOcr", config.forceOcr);
+  setIfDefined(normalized, "maxConcurrentExtractions", config.maxConcurrentExtractions);
+  const ocr = normalizeOcrConfig(config.ocr);
+  setIfDefined(normalized, "ocr", ocr);
+  const chunking = normalizeChunkingConfig(config.chunking);
+  setIfDefined(normalized, "chunking", chunking);
+  const images = normalizeImageExtractionConfig(config.images);
+  setIfDefined(normalized, "images", images);
+  const pdf = normalizePdfConfig(config.pdfOptions);
+  setIfDefined(normalized, "pdfOptions", pdf);
+  const tokenReduction = normalizeTokenReductionConfig(config.tokenReduction);
+  setIfDefined(normalized, "tokenReduction", tokenReduction);
+  const languageDetection = normalizeLanguageDetectionConfig(config.languageDetection);
+  setIfDefined(normalized, "languageDetection", languageDetection);
+  const postprocessor = normalizePostProcessorConfig(config.postprocessor);
+  setIfDefined(normalized, "postprocessor", postprocessor);
+  const keywords = normalizeKeywordConfig(config.keywords);
+  setIfDefined(normalized, "keywords", keywords);
+  const pages = normalizePageConfig(config.pages);
+  setIfDefined(normalized, "pages", pages);
+  const htmlOptions = normalizeHtmlOptions(config.htmlOptions);
+  setIfDefined(normalized, "htmlOptions", htmlOptions);
+  return normalized;
+}
+function extractFileSync(filePath, mimeType = null, config = null) {
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResult = getBinding().extractFileSync(filePath, mimeType, normalizedConfig);
+  return convertResult(rawResult);
+}
+async function extractFile(filePath, mimeType = null, config = null) {
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResult = await getBinding().extractFile(filePath, mimeType, normalizedConfig);
+  return convertResult(rawResult);
+}
+function extractBytesSync(data, mimeType, config = null) {
+  const validated = assertUint8Array(data, "data");
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResult = getBinding().extractBytesSync(Buffer.from(validated), mimeType, normalizedConfig);
+  return convertResult(rawResult);
+}
+async function extractBytes(data, mimeType, config = null) {
+  const validated = assertUint8Array(data, "data");
+  if (process.env["KREUZBERG_DEBUG_GUTEN"] === "1") {
+    console.log("[TypeScript] Debug input header:", Array.from(validated.slice(0, 8)));
+  }
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResult = await getBinding().extractBytes(Buffer.from(validated), mimeType, normalizedConfig);
+  return convertResult(rawResult);
+}
+function batchExtractFilesSync(paths, config = null) {
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResults = getBinding().batchExtractFilesSync(paths, normalizedConfig);
+  return rawResults.map(convertResult);
+}
+async function batchExtractFiles(paths, config = null) {
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResults = await getBinding().batchExtractFiles(paths, normalizedConfig);
+  return rawResults.map(convertResult);
+}
+function batchExtractBytesSync(dataList, mimeTypes, config = null) {
+  const buffers = assertUint8ArrayList(dataList, "dataList").map((data) => Buffer.from(data));
+  if (buffers.length !== mimeTypes.length) {
+    throw new TypeError("dataList and mimeTypes must have the same length");
+  }
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResults = getBinding().batchExtractBytesSync(buffers, mimeTypes, normalizedConfig);
+  return rawResults.map(convertResult);
+}
+async function batchExtractBytes(dataList, mimeTypes, config = null) {
+  const buffers = assertUint8ArrayList(dataList, "dataList").map((data) => Buffer.from(data));
+  if (buffers.length !== mimeTypes.length) {
+    throw new TypeError("dataList and mimeTypes must have the same length");
+  }
+  const normalizedConfig = normalizeExtractionConfig(config);
+  const rawResults = await getBinding().batchExtractBytes(buffers, mimeTypes, normalizedConfig);
+  return rawResults.map(convertResult);
+}
+function registerPostProcessor(processor) {
+  const binding2 = getBinding();
+  const wrappedProcessor = {
+    name: processor.name.bind(processor),
+    processingStage: processor.processingStage?.bind(processor),
+    async process(...args) {
+      const wrappedValue = args[0];
+      const jsonString = wrappedValue[0];
+      const wireResult = JSON.parse(jsonString);
+      const result = {
+        content: wireResult.content,
+        mimeType: wireResult.mime_type,
+        metadata: typeof wireResult.metadata === "string" ? JSON.parse(wireResult.metadata) : wireResult.metadata,
+        tables: wireResult.tables || [],
+        detectedLanguages: wireResult.detected_languages ?? null,
+        chunks: wireResult.chunks ?? null,
+        images: wireResult.images ?? null
+      };
+      const updated = await processor.process(result);
+      const wireUpdated = {
+        content: updated.content,
+        mime_type: updated.mimeType,
+        metadata: updated.metadata,
+        tables: updated.tables,
+        detected_languages: updated.detectedLanguages,
+        chunks: updated.chunks,
+        images: updated.images
+      };
+      return JSON.stringify(wireUpdated);
+    }
+  };
+  Object.defineProperty(wrappedProcessor, "__original", {
+    value: processor,
+    enumerable: false
+  });
+  const stage = processor.processingStage?.() ?? "middle";
+  Object.defineProperty(wrappedProcessor, "__stage", {
+    value: stage,
+    enumerable: false
+  });
+  binding2.registerPostProcessor(wrappedProcessor);
+}
+function unregisterPostProcessor(name) {
+  const binding2 = getBinding();
+  binding2.unregisterPostProcessor(name);
+}
+function clearPostProcessors() {
+  const binding2 = getBinding();
+  binding2.clearPostProcessors();
+}
+function listPostProcessors() {
+  const binding2 = getBinding();
+  return binding2.listPostProcessors();
+}
+function registerValidator(validator) {
+  const binding2 = getBinding();
+  const wrappedValidator = {
+    name: validator.name.bind(validator),
+    priority: validator.priority?.bind(validator),
+    async validate(...args) {
+      const jsonString = args[0];
+      if (!jsonString || jsonString === "undefined") {
+        throw new Error("Validator received invalid JSON string");
+      }
+      const wireResult = JSON.parse(jsonString);
+      const result = {
+        content: wireResult.content,
+        mimeType: wireResult.mime_type,
+        metadata: typeof wireResult.metadata === "string" ? JSON.parse(wireResult.metadata) : wireResult.metadata,
+        tables: wireResult.tables || [],
+        detectedLanguages: wireResult.detected_languages,
+        chunks: wireResult.chunks,
+        images: wireResult.images ?? null
+      };
+      await Promise.resolve(validator.validate(result));
+      return "";
+    }
+  };
+  binding2.registerValidator(wrappedValidator);
+}
+function unregisterValidator(name) {
+  const binding2 = getBinding();
+  binding2.unregisterValidator(name);
+}
+function clearValidators() {
+  const binding2 = getBinding();
+  binding2.clearValidators();
+}
+function listValidators() {
+  const binding2 = getBinding();
+  return binding2.listValidators();
+}
+function isOcrProcessTuple(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[1] === "string" && (typeof value[0] === "string" || Buffer.isBuffer(value[0]) || value[0] instanceof Uint8Array);
+}
+function isNestedOcrProcessTuple(value) {
+  return Array.isArray(value) && value.length === 1 && isOcrProcessTuple(value[0]);
+}
+function describePayload(value) {
+  if (typeof value === "string") {
+    return { ctor: "String", length: value.length };
+  }
+  return { ctor: value.constructor?.name ?? "Buffer", length: value.length };
+}
+function registerOcrBackend(backend) {
+  const binding2 = getBinding();
+  const wrappedBackend = {
+    name: backend.name.bind(backend),
+    supportedLanguages: backend.supportedLanguages.bind(backend),
+    async processImage(...processArgs) {
+      const [imagePayload, maybeLanguage] = processArgs;
+      if (process.env["KREUZBERG_DEBUG_GUTEN"] === "1") {
+        console.log("[registerOcrBackend] JS arguments", { length: processArgs.length });
+        console.log("[registerOcrBackend] Raw args", {
+          imagePayloadType: Array.isArray(imagePayload) ? "tuple" : typeof imagePayload,
+          maybeLanguageType: typeof maybeLanguage,
+          metadata: Array.isArray(imagePayload) ? { tupleLength: imagePayload.length } : describePayload(imagePayload)
+        });
+      }
+      let rawBytes;
+      let language = maybeLanguage;
+      if (isNestedOcrProcessTuple(imagePayload)) {
+        [rawBytes, language] = imagePayload[0];
+      } else if (isOcrProcessTuple(imagePayload)) {
+        [rawBytes, language] = imagePayload;
+      } else {
+        rawBytes = imagePayload;
+      }
+      if (typeof language !== "string") {
+        throw new Error("OCR backend did not receive a language parameter");
+      }
+      if (process.env["KREUZBERG_DEBUG_GUTEN"] === "1") {
+        const length = typeof rawBytes === "string" ? rawBytes.length : rawBytes.length;
+        console.log(
+          "[registerOcrBackend] Received payload",
+          Array.isArray(imagePayload) ? "tuple" : typeof rawBytes,
+          "ctor",
+          describePayload(rawBytes).ctor,
+          "length",
+          length
+        );
+      }
+      const buffer = typeof rawBytes === "string" ? Buffer.from(rawBytes, "base64") : Buffer.from(rawBytes);
+      const result = await backend.processImage(new Uint8Array(buffer), language);
+      return JSON.stringify(result);
+    }
+  };
+  binding2.registerOcrBackend(wrappedBackend);
+}
+function listOcrBackends() {
+  const binding2 = getBinding();
+  return binding2.listOcrBackends();
+}
+function unregisterOcrBackend(name) {
+  const binding2 = getBinding();
+  binding2.unregisterOcrBackend(name);
+}
+function clearOcrBackends() {
+  const binding2 = getBinding();
+  binding2.clearOcrBackends();
+}
+function listDocumentExtractors() {
+  const binding2 = getBinding();
+  return binding2.listDocumentExtractors();
+}
+function unregisterDocumentExtractor(name) {
+  const binding2 = getBinding();
+  binding2.unregisterDocumentExtractor(name);
+}
+function clearDocumentExtractors() {
+  const binding2 = getBinding();
+  binding2.clearDocumentExtractors();
+}
+const ExtractionConfig = {
+  /**
+   * Load extraction configuration from a file.
+   *
+   * Automatically detects the file format based on extension:
+   * - `.toml` - TOML format
+   * - `.yaml` - YAML format
+   * - `.json` - JSON format
+   *
+   * @param filePath - Path to the configuration file (absolute or relative)
+   * @returns ExtractionConfig object loaded from the file
+   *
+   * @throws {Error} If file does not exist or is not accessible
+   * @throws {Error} If file content is not valid TOML/YAML/JSON
+   * @throws {Error} If configuration structure is invalid
+   * @throws {Error} If file extension is not supported
+   *
+   * @example
+   * ```typescript
+   * import { ExtractionConfig } from '@kreuzberg/node';
+   *
+   * // Load from TOML file
+   * const config1 = ExtractionConfig.fromFile('kreuzberg.toml');
+   *
+   * // Load from YAML file
+   * const config2 = ExtractionConfig.fromFile('./config.yaml');
+   *
+   * // Load from JSON file
+   * const config3 = ExtractionConfig.fromFile('./config.json');
+   * ```
+   */
+  fromFile(filePath) {
+    const binding2 = getBinding();
+    return binding2.loadExtractionConfigFromFile(filePath);
+  },
+  /**
+   * Discover and load configuration from current or parent directories.
+   *
+   * Searches for a `kreuzberg.toml` file starting from the current working directory
+   * and traversing up the directory tree. Returns the first configuration file found.
+   *
+   * @returns ExtractionConfig object if found, or null if no configuration file exists
+   *
+   * @example
+   * ```typescript
+   * import { ExtractionConfig } from '@kreuzberg/node';
+   *
+   * // Try to find config in current or parent directories
+   * const config = ExtractionConfig.discover();
+   * if (config) {
+   *   console.log('Found configuration');
+   *   // Use config for extraction
+   * } else {
+   *   console.log('No configuration file found, using defaults');
+   * }
+   * ```
+   */
+  discover() {
+    const binding2 = getBinding();
+    return binding2.discoverExtractionConfig();
+  }
+};
+function detectMimeType(bytes) {
+  const binding2 = getBinding();
+  return binding2.detectMimeType(bytes);
+}
+function detectMimeTypeFromPath(path, checkExists) {
+  const binding2 = getBinding();
+  return binding2.detectMimeTypeFromPath(path, checkExists);
+}
+function validateMimeType(mimeType) {
+  const binding2 = getBinding();
+  return binding2.validateMimeType(mimeType);
+}
+function getExtensionsForMime(mimeType) {
+  const binding2 = getBinding();
+  return binding2.getExtensionsForMime(mimeType);
+}
+function listEmbeddingPresets() {
+  const binding2 = getBinding();
+  return binding2.listEmbeddingPresets();
+}
+function getEmbeddingPreset(name) {
+  const binding2 = getBinding();
+  return binding2.getEmbeddingPreset(name);
+}
+function getLastErrorCode() {
+  const binding2 = getBinding();
+  return binding2.getLastErrorCode();
+}
+function getLastPanicContext() {
+  const binding2 = getBinding();
+  return binding2.getLastPanicContext();
+}
+const __version__ = "4.0.0-rc.8";
+export {
+  CacheError,
+  ErrorCode,
+  ExtractionConfig,
+  GutenOcrBackend,
+  ImageProcessingError,
+  KreuzbergError,
+  MissingDependencyError,
+  OcrError,
+  ParsingError,
+  PluginError,
+  ValidationError,
+  __resetBindingForTests,
+  __setBindingForTests,
+  __version__,
+  batchExtractBytes,
+  batchExtractBytesSync,
+  batchExtractFiles,
+  batchExtractFilesSync,
+  clearDocumentExtractors,
+  clearOcrBackends,
+  clearPostProcessors,
+  clearValidators,
+  detectMimeType,
+  detectMimeTypeFromPath,
+  extractBytes,
+  extractBytesSync,
+  extractFile,
+  extractFileSync,
+  getEmbeddingPreset,
+  getExtensionsForMime,
+  getLastErrorCode,
+  getLastPanicContext,
+  listDocumentExtractors,
+  listEmbeddingPresets,
+  listOcrBackends,
+  listPostProcessors,
+  listValidators,
+  registerOcrBackend,
+  registerPostProcessor,
+  registerValidator,
+  unregisterDocumentExtractor,
+  unregisterOcrBackend,
+  unregisterPostProcessor,
+  unregisterValidator,
+  validateMimeType
+};
+//# sourceMappingURL=index.mjs.map