@autorag/librarian 2.10.1 → 2.10.2

package/dist/parser/parse-worker.js

@@ -0,0 +1,780 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/language.ts
+function supportedList() {
+  return AUTORAG_LANGUAGE_TAGS.join(", ");
+}
+function toTag(raw) {
+  const tag = raw.trim().toLowerCase();
+  if (!AUTORAG_LANGUAGE_TAGS.includes(tag)) {
+    throw new LanguageError(`Unsupported language "${raw.trim()}". Supported: ${supportedList()}.`);
+  }
+  return tag;
+}
+function dedupe(tags) {
+  return [...new Set(tags)];
+}
+function normalizeLanguages(raw) {
+  if (raw === undefined || raw === null)
+    return [...DEFAULT_LANGUAGES];
+  if (typeof raw === "string")
+    return parseLanguageList(raw);
+  if (!Array.isArray(raw)) {
+    throw new LanguageError(`languages must be a string or an array of language tags; received ${typeof raw}.`);
+  }
+  const entries = raw.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw new LanguageError(`languages[${index}] must be a string language tag; received ${typeof entry}.`);
+    }
+    return entry;
+  });
+  const tags = entries.filter((entry) => entry.trim() !== "").map(toTag);
+  if (tags.length === 0) {
+    throw new LanguageError(`languages must list at least one language. Supported: ${supportedList()}.`);
+  }
+  return dedupe(tags);
+}
+function parseLanguageList(value) {
+  const tags = value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "").map(toTag);
+  if (tags.length === 0) {
+    throw new LanguageError(`languages must list at least one language. Supported: ${supportedList()}.`);
+  }
+  return dedupe(tags);
+}
+var AUTORAG_LANGUAGE_TAGS, DEFAULT_LANGUAGES, LanguageError;
+var init_language = __esm(() => {
+  AUTORAG_LANGUAGE_TAGS = [
+    "ko",
+    "en",
+    "ja",
+    "zh-hans",
+    "zh-hant",
+    "fr",
+    "de",
+    "es",
+    "ru",
+    "it",
+    "pt",
+    "vi",
+    "th",
+    "ar",
+    "hi"
+  ];
+  DEFAULT_LANGUAGES = ["ko", "en"];
+  LanguageError = class LanguageError extends Error {
+    name = "LanguageError";
+  };
+});
+
+// src/parser/errors.ts
+function messageFrom(cause) {
+  if (cause instanceof Error)
+    return cause.message;
+  if (typeof cause === "string")
+    return cause;
+  return "unknown parser failure";
+}
+var ParseError, ParseIsolationError;
+var init_errors = __esm(() => {
+  ParseError = class ParseError extends Error {
+    parserName;
+    virtualPath;
+    constructor(parserName, virtualPath, cause) {
+      super(`Parser "${parserName}" failed for ${virtualPath}: ${messageFrom(cause)}`);
+      this.name = "ParseError";
+      this.parserName = parserName;
+      this.virtualPath = virtualPath;
+      this.cause = cause;
+    }
+  };
+  ParseIsolationError = class ParseIsolationError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "ParseIsolationError";
+      this.code = code;
+    }
+  };
+});
+
+// src/parser/text.ts
+import { detect } from "chardet";
+import iconv from "iconv-lite";
+function decodeText(bytes) {
+  const buffer = Buffer.from(bytes);
+  if (isPureAscii(bytes)) {
+    return iconv.decode(buffer, "ascii");
+  }
+  const utf8 = iconv.decode(buffer, "utf8");
+  if (replacementCount(utf8) > 0) {
+    const cp949 = iconv.decode(buffer, "cp949");
+    if (replacementCount(cp949) < replacementCount(utf8))
+      return cp949.normalize("NFC");
+  }
+  const detected = detect(buffer);
+  const encoding = detected && WINDOWS_949_LABELS.has(detected) ? "cp949" : detected ?? "utf8";
+  return iconv.decode(buffer, encoding).normalize("NFC");
+}
+function normalizeMarkdown(markdown) {
+  return markdown.normalize("NFC");
+}
+function replacementCount(value) {
+  return [...value].filter((character) => character === "�").length;
+}
+function isPureAscii(bytes) {
+  if (bytes.length === 0)
+    return true;
+  if (bytes.length < 4)
+    return false;
+  for (let i = 0;i < bytes.length; i += 1) {
+    const byte = bytes[i];
+    if (byte < 1 || byte === 27 || byte > 127)
+      return false;
+  }
+  return true;
+}
+var WINDOWS_949_LABELS;
+var init_text = __esm(() => {
+  WINDOWS_949_LABELS = new Set(["EUC-KR", "ISO-2022-KR", "windows-949", "CP949"]);
+});
+
+// src/parser/types.ts
+class Parser {
+  version = "1";
+}
+
+// src/parser/eml.ts
+import { simpleParser } from "mailparser";
+function addressText(address) {
+  if (address === undefined)
+    return;
+  if (Array.isArray(address)) {
+    return address.map((item) => item.text).filter((text) => text.length > 0).join(", ");
+  }
+  return address.text;
+}
+var EmlParser;
+var init_eml = __esm(() => {
+  init_errors();
+  init_text();
+  EmlParser = class EmlParser extends Parser {
+    name = "eml";
+    extensions = [".eml"];
+    async parse(input) {
+      try {
+        const parsed = await simpleParser(Buffer.from(input.bytes));
+        const from = addressText(parsed.from);
+        const to = addressText(parsed.to);
+        const lines = [
+          parsed.subject ? `# ${parsed.subject}` : undefined,
+          from ? `From: ${from}` : undefined,
+          to ? `To: ${to}` : undefined,
+          parsed.date ? `Date: ${parsed.date.toISOString()}` : undefined,
+          parsed.text?.trim()
+        ].filter((line) => line !== undefined && line.length > 0);
+        return {
+          markdown: normalizeMarkdown(lines.join(`
+
+`)),
+          metadata: {
+            parser: this.name,
+            subject: parsed.subject,
+            from,
+            to,
+            date: parsed.date?.toISOString()
+          }
+        };
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      }
+    }
+  };
+});
+
+// src/parser/kordoc.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { parse as kordocParse } from "kordoc";
+function installedKordocVersion() {
+  try {
+    const entry = createRequire(import.meta.url).resolve("kordoc");
+    const manifest = JSON.parse(readFileSync(join(dirname(dirname(entry)), "package.json"), "utf8"));
+    if (manifest.name === "kordoc" && typeof manifest.version === "string")
+      return manifest.version;
+  } catch {}
+  return "unknown";
+}
+function toKordocInput(bytes) {
+  return Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+var KORDOC_VERSION, KORDOC_EXTENSIONS, KORDOC_IMAGE_EXTENSIONS, defaultParse = async (bytes, options) => {
+  const result = await kordocParse(toKordocInput(bytes), {
+    plain: true,
+    ...options.ocr === undefined ? {} : { ocr: options.ocr }
+  });
+  if (result.success) {
+    return {
+      success: true,
+      fileType: result.fileType,
+      markdown: result.markdown,
+      warnings: result.warnings
+    };
+  }
+  return { success: false, fileType: result.fileType, error: result.error, code: result.code };
+}, KordocParser;
+var init_kordoc = __esm(() => {
+  init_errors();
+  KORDOC_VERSION = installedKordocVersion();
+  KORDOC_EXTENSIONS = [".hwp", ".hwpx", ".hml", ".hwpml", ".pdf", ".docx", ".xlsx", ".xls"];
+  KORDOC_IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp"];
+  KordocParser = class KordocParser extends Parser {
+    name = "kordoc";
+    version = KORDOC_VERSION;
+    extensions;
+    #parse;
+    #ocr;
+    constructor(options = {}) {
+      super();
+      this.#parse = options.parse ?? defaultParse;
+      this.#ocr = options.ocr;
+      this.extensions = options.images === true ? [...KORDOC_EXTENSIONS, ...KORDOC_IMAGE_EXTENSIONS] : KORDOC_EXTENSIONS;
+    }
+    async parse(input) {
+      let result;
+      try {
+        result = await this.#parse(input.bytes, { ocr: this.#ocr });
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      }
+      if (!result.success) {
+        throw new ParseError(this.name, input.virtualPath, new Error(`${result.code ?? "PARSE_ERROR"}: ${result.error}`));
+      }
+      const diagnostics = (result.warnings ?? []).map((warning) => ({
+        code: "parser-warning",
+        severity: "warning",
+        message: warning.code ? `${warning.code}: ${warning.message}` : warning.message
+      }));
+      return {
+        markdown: result.markdown,
+        metadata: { parser: this.name, format: result.fileType ?? "unknown" },
+        ...diagnostics.length > 0 ? { diagnostics } : {}
+      };
+    }
+  };
+});
+
+// src/parser/ocr-engines.ts
+import { mkdir } from "node:fs/promises";
+import { createWorker } from "tesseract.js";
+function tesseractLanguageListFor(tags) {
+  const languages = [...new Set(tags)].map((tag) => TESSERACT_LANGUAGES[tag]);
+  if (languages.length === 0) {
+    throw new Error("OCR provider requires at least one language.");
+  }
+  return languages;
+}
+function tesseractLanguageFor(tags) {
+  return tesseractLanguageListFor(tags).join("+");
+}
+function createTesseractOcrProvider(options) {
+  const language = tesseractLanguageFor(options.languages);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TESSERACT_TIMEOUT_MS;
+  const engine = options.engine ?? ((resolvedLanguage, pageImage) => recognizeWithTesseract({
+    language: resolvedLanguage,
+    bytes: pageImage,
+    timeoutMs,
+    cachePath: options.cachePath
+  }));
+  return (pageImage, pageNumber, mimeType) => engine(language, pageImage, pageNumber, mimeType);
+}
+function recognizeWithTesseract(recognition) {
+  const controller = new AbortController;
+  const operation = startTesseract(recognition, controller.signal);
+  return withTimeout(operation, recognition.timeoutMs, () => controller.abort());
+}
+function startTesseract(recognition, signal) {
+  let cleanupResolve = () => {
+    return;
+  };
+  let cleanupReject = () => {
+    return;
+  };
+  const cleanup = new Promise((resolve, reject) => {
+    cleanupResolve = resolve;
+    cleanupReject = reject;
+  });
+  const result = runTesseract(recognition, signal, cleanupResolve, cleanupReject);
+  return { result, cleanup };
+}
+async function runTesseract(recognition, signal, cleanupResolve, cleanupReject) {
+  let worker;
+  let termination;
+  const terminate = async () => {
+    if (worker === undefined)
+      return;
+    termination ??= worker.terminate().then(() => {
+      return;
+    });
+    await termination;
+  };
+  const abort = () => {
+    if (worker !== undefined) {
+      terminate().then(cleanupResolve, cleanupReject);
+    }
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    const tooSmall = ocrImageTooSmallMessage(recognition.bytes);
+    if (tooSmall !== undefined)
+      throw new Error(tooSmall);
+    const { cachePath } = recognition;
+    if (cachePath !== undefined)
+      await mkdir(cachePath, { recursive: true });
+    worker = await createWorker(recognition.language, undefined, {
+      ...cachePath === undefined ? {} : { cachePath },
+      errorHandler: containTesseractWorkerError
+    });
+    if (signal.aborted)
+      throw new Error("OCR aborted before worker was ready");
+    const result = await worker.recognize(Buffer.from(recognition.bytes));
+    return result.data.text;
+  } finally {
+    signal.removeEventListener("abort", abort);
+    await terminate().then(cleanupResolve, cleanupReject);
+  }
+}
+function containTesseractWorkerError(_payload) {}
+function ocrImageTooSmallMessage(bytes) {
+  const size = readImagePixelSize(bytes);
+  if (size === undefined || size.width >= MIN_LEPTONICA_SIDE_PIXELS && size.height >= MIN_LEPTONICA_SIDE_PIXELS) {
+    return;
+  }
+  return `Image is too small to scale (${size.width}x${size.height} vs minimum of ${MIN_LEPTONICA_SIDE_PIXELS} pixels).`;
+}
+function readImagePixelSize(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80)
+    return readPngSize(bytes);
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216)
+    return readJpegSize(bytes);
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73)
+    return readWebpSize(bytes);
+  return;
+}
+function readPngSize(bytes) {
+  if (bytes.length < 24)
+    return;
+  if (bytes[0] !== 137 || bytes[1] !== 80 || bytes[2] !== 78 || bytes[3] !== 71 || bytes[4] !== 13 || bytes[5] !== 10 || bytes[6] !== 26 || bytes[7] !== 10) {
+    return;
+  }
+  if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function readJpegSize(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 2;
+  while (offset + 1 < bytes.length) {
+    if (bytes[offset] !== 255)
+      return;
+    offset += 1;
+    while (offset < bytes.length && bytes[offset] === 255)
+      offset += 1;
+    if (offset >= bytes.length)
+      return;
+    const marker = bytes[offset] ?? 0;
+    offset += 1;
+    if (marker === 0)
+      return;
+    if (marker === 1 || marker === 217 || marker >= 208 && marker <= 216)
+      continue;
+    if (offset + 2 > bytes.length)
+      return;
+    const segmentLength = view.getUint16(offset);
+    if (segmentLength < 2)
+      return;
+    if (isJpegStartOfFrame(marker)) {
+      if (segmentLength < 7 || offset + 7 > bytes.length)
+        return;
+      return { width: view.getUint16(offset + 5), height: view.getUint16(offset + 3) };
+    }
+    if (marker === 218)
+      return;
+    const next = offset + segmentLength;
+    if (next <= offset || next > bytes.length)
+      return;
+    offset = next;
+  }
+  return;
+}
+function isJpegStartOfFrame(marker) {
+  return marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+}
+function readWebpSize(bytes) {
+  if (bytes.length < 20 || !asciiAt(bytes, 0, "RIFF") || !asciiAt(bytes, 8, "WEBP"))
+    return;
+  const chunkSize = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(16, true);
+  if (asciiAt(bytes, 12, "VP8X"))
+    return readVp8xSize(bytes, chunkSize);
+  if (asciiAt(bytes, 12, "VP8L"))
+    return readVp8lSize(bytes, chunkSize);
+  if (asciiAt(bytes, 12, "VP8 "))
+    return readVp8Size(bytes, chunkSize);
+  return;
+}
+function readVp8xSize(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 10))
+    return;
+  const payload = 20;
+  const width = 1 + readU24LE(bytes, payload + 4);
+  const height = 1 + readU24LE(bytes, payload + 7);
+  return { width, height };
+}
+function readVp8lSize(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 5) || bytes[20] !== 47)
+    return;
+  const b1 = bytes[21] ?? 0;
+  const b2 = bytes[22] ?? 0;
+  const b3 = bytes[23] ?? 0;
+  const b4 = bytes[24] ?? 0;
+  const width = 1 + (b1 | (b2 & 63) << 8);
+  const height = 1 + (b2 >> 6 | b3 << 2 | (b4 & 15) << 10);
+  return { width, height };
+}
+function readVp8Size(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 10) || (bytes[20] & 1) !== 0)
+    return;
+  if (bytes[23] !== 157 || bytes[24] !== 1 || bytes[25] !== 42)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint16(26, true) & 16383, height: view.getUint16(28, true) & 16383 };
+}
+function webpPayloadFits(bytes, chunkSize, needed) {
+  return chunkSize >= needed && bytes.length >= 20 + needed;
+}
+function readU24LE(bytes, offset) {
+  return (bytes[offset] ?? 0) | (bytes[offset + 1] ?? 0) << 8 | (bytes[offset + 2] ?? 0) << 16;
+}
+function asciiAt(bytes, offset, text) {
+  if (offset + text.length > bytes.length)
+    return false;
+  for (let index = 0;index < text.length; index += 1) {
+    if (bytes[offset + index] !== text.charCodeAt(index))
+      return false;
+  }
+  return true;
+}
+function withTimeout(operation, timeoutMs, onTimeout) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      onTimeout();
+      operation.cleanup.finally(() => reject(new Error(`OCR timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+    operation.result.then((value) => {
+      clearTimeout(timeout);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timeout);
+      operation.cleanup.then(() => reject(error), (cleanupError) => reject(cleanupError));
+    });
+  });
+}
+var TESSERACT_LANGUAGES, BUILTIN_OCR_LANGUAGES, DEFAULT_TESSERACT_TIMEOUT_MS = 30000, MIN_LEPTONICA_SIDE_PIXELS = 3;
+var init_ocr_engines = __esm(() => {
+  TESSERACT_LANGUAGES = {
+    ko: "kor",
+    en: "eng",
+    ja: "jpn",
+    "zh-hans": "chi_sim",
+    "zh-hant": "chi_tra",
+    fr: "fra",
+    de: "deu",
+    es: "spa",
+    ru: "rus",
+    it: "ita",
+    pt: "por",
+    vi: "vie",
+    th: "tha",
+    ar: "ara",
+    hi: "hin"
+  };
+  BUILTIN_OCR_LANGUAGES = new Set(["ko", "en"]);
+});
+
+// src/parser/xml-text.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { XMLParser } from "fast-xml-parser";
+import JSZip from "jszip";
+async function readZipXmlText(bytes, pathPattern) {
+  const zip = await JSZip.loadAsync(bytes);
+  const files = Object.values(zip.files).filter((file) => !file.dir && pathPattern.test(file.name)).sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+  if (files.length > MAX_XML_FILES) {
+    throw new Error(`archive XML file count exceeds limit of ${MAX_XML_FILES}`);
+  }
+  const chunks = [];
+  let totalXmlBytes = 0;
+  for (const file of files) {
+    const declaredSize = uncompressedSize(file);
+    if (declaredSize !== undefined && totalXmlBytes + declaredSize > MAX_XML_BYTES) {
+      throw new Error(`archive XML content exceeds limit of ${MAX_XML_BYTES} bytes`);
+    }
+    const xml = await readXmlFile(file, MAX_XML_BYTES - totalXmlBytes);
+    totalXmlBytes += Buffer2.byteLength(xml);
+    if (totalXmlBytes > MAX_XML_BYTES) {
+      throw new Error(`archive XML content exceeds limit of ${MAX_XML_BYTES} bytes`);
+    }
+    chunks.push(...extractTextFromXml(xml));
+    if (chunks.length > MAX_TEXT_CHUNKS) {
+      throw new Error(`archive text chunk count exceeds limit of ${MAX_TEXT_CHUNKS}`);
+    }
+  }
+  return chunks;
+}
+async function readXmlFile(file, remainingBytes) {
+  const stream = file.nodeStream("nodebuffer");
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let totalBytes = 0;
+    stream.on("data", (chunk) => {
+      const buffer = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
+      totalBytes += buffer.byteLength;
+      if (totalBytes > remainingBytes) {
+        destroyStream(stream);
+        reject(new Error(`archive XML content exceeds limit of ${MAX_XML_BYTES} bytes`));
+        return;
+      }
+      chunks.push(buffer);
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolve(Buffer2.concat(chunks).toString("utf8")));
+  });
+}
+function uncompressedSize(file) {
+  const data = Reflect.get(file, "_data");
+  if (!isRecord(data))
+    return;
+  const size = data.uncompressedSize;
+  return typeof size === "number" ? size : undefined;
+}
+function destroyStream(stream) {
+  if ("destroy" in stream && typeof stream.destroy === "function") {
+    stream.destroy();
+  }
+}
+function extractTextFromXml(xml) {
+  return collectText(parser.parse(xml));
+}
+function collectText(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  }
+  if (Array.isArray(value))
+    return value.flatMap((item) => collectText(item));
+  if (!isRecord(value))
+    return [];
+  const chunks = [];
+  for (const [key, child] of Object.entries(value)) {
+    if (key.startsWith("@_"))
+      continue;
+    if (isTextElement(key)) {
+      chunks.push(...collectText(child));
+      continue;
+    }
+    chunks.push(...collectText(child));
+  }
+  return chunks;
+}
+function isTextElement(key) {
+  return key === "t" || key.endsWith(":t");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+var parser, MAX_XML_FILES = 64, MAX_XML_BYTES = 5000000, MAX_TEXT_CHUNKS = 20000;
+var init_xml_text = __esm(() => {
+  parser = new XMLParser({
+    ignoreAttributes: false,
+    parseTagValue: false,
+    processEntities: true,
+    trimValues: false
+  });
+});
+
+// src/parser/office.ts
+var PptxParser;
+var init_office = __esm(() => {
+  init_errors();
+  init_text();
+  init_xml_text();
+  PptxParser = class PptxParser extends Parser {
+    name = "pptx";
+    extensions = [".pptx"];
+    async parse(input) {
+      try {
+        const chunks = await readZipXmlText(input.bytes, /^ppt\/(?:slides\/slide\d+|notesSlides\/notesSlide\d+)\.xml$/);
+        const markdown = normalizeMarkdown(chunks.filter((chunk) => chunk.trim().length > 0).join(`
+
+`));
+        return { markdown, metadata: { parser: this.name } };
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      }
+    }
+  };
+});
+
+// src/parser/plain-text.ts
+var PlainTextParser;
+var init_plain_text = __esm(() => {
+  init_text();
+  PlainTextParser = class PlainTextParser extends Parser {
+    name = "plain-text";
+    extensions = [".txt", ".text", ".md", ".markdown"];
+    async parse(input) {
+      return { markdown: decodeText(input.bytes), metadata: { parser: this.name } };
+    }
+  };
+});
+
+// src/parser/registry.ts
+import { extname } from "node:path";
+
+class ParserRegistry {
+  parsersByExtension = new Map;
+  constructor(parsers = []) {
+    for (const parser of parsers) {
+      this.register(parser);
+    }
+  }
+  register(parser) {
+    for (const extension of parser.extensions) {
+      const normalized = normalizeExtension(extension);
+      if (this.parsersByExtension.has(normalized)) {
+        throw new Error(`Parser extension "${normalized}" is already registered`);
+      }
+      this.parsersByExtension.set(normalized, parser);
+    }
+  }
+  getForVirtualPath(virtualPath) {
+    return this.parsersByExtension.get(normalizeExtension(extname(virtualPath)));
+  }
+  list() {
+    return Array.from(new Set(this.parsersByExtension.values()));
+  }
+}
+function normalizeExtension(extension) {
+  const lower = extension.toLowerCase();
+  return lower.startsWith(".") ? lower : `.${lower}`;
+}
+var init_registry = () => {};
+
+// src/parser/defaults.ts
+import { join as join2 } from "node:path";
+function tesseractCachePathFor(workspacePath) {
+  return join2(workspacePath, ".autorag", "models", "tessdata");
+}
+function resolveParserOptions(parserOptions, languages, workspacePath) {
+  const resolved = { ...parserOptions, languages: parserOptions?.languages ?? languages };
+  if (workspacePath === undefined || parserOptions?.ocr === undefined || parserOptions.ocr.cachePath !== undefined) {
+    return resolved;
+  }
+  return { ...resolved, ocr: { ...parserOptions.ocr, cachePath: tesseractCachePathFor(workspacePath) } };
+}
+function createDefaultParserRegistry(options = {}) {
+  const languages = options.languages ?? DEFAULT_LANGUAGES;
+  const ocrEnabled = options.ocr?.enabled === true;
+  const builtinCovers = languages.every((language) => BUILTIN_OCR_LANGUAGES.has(language));
+  const kordocOptions = {
+    ...options.kordoc,
+    images: ocrEnabled,
+    ...options.kordoc?.ocr === undefined ? {
+      ocr: !ocrEnabled ? false : builtinCovers ? true : createTesseractOcrProvider({
+        languages,
+        timeoutMs: options.ocr?.timeoutMs,
+        cachePath: options.ocr?.cachePath
+      })
+    } : {}
+  };
+  return new ParserRegistry([
+    new PlainTextParser,
+    new KordocParser(kordocOptions),
+    new PptxParser,
+    new EmlParser
+  ]);
+}
+var init_defaults = __esm(() => {
+  init_language();
+  init_eml();
+  init_kordoc();
+  init_ocr_engines();
+  init_office();
+  init_plain_text();
+  init_registry();
+});
+
+// src/parser/parse-worker.ts
+init_defaults();
+init_errors();
+import { parentPort, workerData } from "node:worker_threads";
+var registry = createDefaultParserRegistry(workerData);
+function describe(error) {
+  if (error instanceof Error)
+    return { message: error.message, ...error.stack === undefined ? {} : { stack: error.stack } };
+  return { message: typeof error === "string" ? error : "unknown parser failure" };
+}
+async function handle(request) {
+  const parser = registry.list().find((candidate) => candidate.name === request.parserName);
+  if (parser === undefined) {
+    return { id: request.id, ok: false, kind: "error", message: `Unknown parser "${request.parserName}"` };
+  }
+  try {
+    const output = await parser.parse({
+      virtualPath: request.virtualPath,
+      ...request.sourcePath === undefined ? {} : { sourcePath: request.sourcePath },
+      bytes: request.bytes
+    });
+    return { id: request.id, ok: true, output };
+  } catch (error) {
+    if (error instanceof ParseError) {
+      return {
+        id: request.id,
+        ok: false,
+        kind: "parse-error",
+        parserName: error.parserName,
+        ...describe(error.cause)
+      };
+    }
+    return { id: request.id, ok: false, kind: "error", ...describe(error) };
+  }
+}
+parentPort?.on("message", (request) => {
+  handle(request).then((response) => parentPort?.postMessage(response));
+});