@clazic/kordoc 2.5.2 → 2.6.0

package/dist/index.cjs

@@ -33,6 +33,118 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  KordocError: () => KordocError,
+  VERSION: () => VERSION,
+  classifyError: () => classifyError,
+  isPathTraversal: () => isPathTraversal,
+  normalizeKordocError: () => normalizeKordocError,
+  precheckZipSize: () => precheckZipSize,
+  sanitizeError: () => sanitizeError,
+  sanitizeHref: () => sanitizeHref,
+  toArrayBuffer: () => toArrayBuffer
+});
+function toArrayBuffer(buf) {
+  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+function sanitizeError(err) {
+  if (err instanceof KordocError) return err.message;
+  return "\uBB38\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4";
+}
+function isPathTraversal(name) {
+  if (name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  return normalized.includes("..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
+}
+function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
+  try {
+    const data = new DataView(buffer);
+    const len = buffer.byteLength;
+    let eocdOffset = -1;
+    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
+      if (data.getUint32(i, true) === 101010256) {
+        eocdOffset = i;
+        break;
+      }
+    }
+    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
+    const entryCount = data.getUint16(eocdOffset + 10, true);
+    if (entryCount > maxEntries) {
+      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
+    }
+    const cdSize = data.getUint32(eocdOffset + 12, true);
+    const cdOffset = data.getUint32(eocdOffset + 16, true);
+    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
+    let totalUncompressed = 0;
+    let pos = cdOffset;
+    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
+      if (data.getUint32(pos, true) !== 33639248) break;
+      totalUncompressed += data.getUint32(pos + 24, true);
+      const nameLen = data.getUint16(pos + 28, true);
+      const extraLen = data.getUint16(pos + 30, true);
+      const commentLen = data.getUint16(pos + 32, true);
+      pos += 46 + nameLen + extraLen + commentLen;
+    }
+    if (totalUncompressed > maxUncompressedSize) {
+      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
+    }
+    return { totalUncompressed, entryCount };
+  } catch (err) {
+    if (err instanceof KordocError) throw err;
+    return { totalUncompressed: 0, entryCount: 0 };
+  }
+}
+function sanitizeHref(href) {
+  const trimmed = href.trim();
+  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
+  return trimmed;
+}
+function classifyError(err) {
+  if (!(err instanceof Error)) return "PARSE_ERROR";
+  const msg = err.message;
+  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
+  if (msg.includes("DRM")) return "DRM_PROTECTED";
+  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
+  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
+  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
+  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
+  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
+  return "PARSE_ERROR";
+}
+function normalizeKordocError(err, fallbackMessage, stage = "unknown", fallbackCode = "PARSE_ERROR") {
+  if (err instanceof KordocError) {
+    if (!err.stage) err.stage = stage;
+    if (!err.code) err.code = fallbackCode;
+    return err;
+  }
+  const message = err instanceof Error ? err.message : fallbackMessage;
+  const code = err instanceof Error ? classifyError(err) : fallbackCode;
+  return new KordocError(message || fallbackMessage, { code, stage });
+}
+var VERSION, KordocError, SAFE_HREF_RE;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    VERSION = true ? "2.5.2" : "0.0.0-dev";
+    KordocError = class extends Error {
+      code;
+      stage;
+      constructor(message, opts = {}) {
+        super(message);
+        this.name = "KordocError";
+        this.code = opts.code;
+        this.stage = opts.stage;
+      }
+    };
+    SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
+  }
+});
+
 // src/page-range.ts
 var page_range_exports = {};
 __export(page_range_exports, {
@@ -3062,6 +3174,9 @@ __export(index_exports, {
   VERSION: () => VERSION,
   blocksToMarkdown: () => blocksToMarkdown,
   compare: () => compare,
+  convertHwpToPdf: () => convertHwpToPdf,
+  convertHwpxToPdf: () => convertHwpxToPdf,
+  convertToPdf: () => convertToPdf,
   detectFormat: () => detectFormat,
   detectZipFormat: () => detectZipFormat,
   diffBlocks: () => diffBlocks,
@@ -3081,7 +3196,7 @@ __export(index_exports, {
   runUnifiedOcrPipeline: () => runUnifiedOcrPipeline
 });
 module.exports = __toCommonJS(index_exports);
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 
 // src/detect.ts
 var import_jszip = __toESM(require("jszip"), 1);
@@ -3133,97 +3248,8 @@ async function detectZipFormat(buffer) {
 var import_jszip2 = __toESM(require("jszip"), 1);
 var import_xmldom = require("@xmldom/xmldom");
 
-// src/utils.ts
-var VERSION = true ? "2.5.1" : "0.0.0-dev";
-function toArrayBuffer(buf) {
-  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
-    return buf.buffer;
-  }
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-}
-var KordocError = class extends Error {
-  code;
-  stage;
-  constructor(message, opts = {}) {
-    super(message);
-    this.name = "KordocError";
-    this.code = opts.code;
-    this.stage = opts.stage;
-  }
-};
-function isPathTraversal(name) {
-  if (name.includes("\0")) return true;
-  const normalized = name.replace(/\\/g, "/");
-  return normalized.includes("..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
-}
-function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
-  try {
-    const data = new DataView(buffer);
-    const len = buffer.byteLength;
-    let eocdOffset = -1;
-    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
-      if (data.getUint32(i, true) === 101010256) {
-        eocdOffset = i;
-        break;
-      }
-    }
-    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
-    const entryCount = data.getUint16(eocdOffset + 10, true);
-    if (entryCount > maxEntries) {
-      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
-    }
-    const cdSize = data.getUint32(eocdOffset + 12, true);
-    const cdOffset = data.getUint32(eocdOffset + 16, true);
-    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
-    let totalUncompressed = 0;
-    let pos = cdOffset;
-    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
-      if (data.getUint32(pos, true) !== 33639248) break;
-      totalUncompressed += data.getUint32(pos + 24, true);
-      const nameLen = data.getUint16(pos + 28, true);
-      const extraLen = data.getUint16(pos + 30, true);
-      const commentLen = data.getUint16(pos + 32, true);
-      pos += 46 + nameLen + extraLen + commentLen;
-    }
-    if (totalUncompressed > maxUncompressedSize) {
-      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
-    }
-    return { totalUncompressed, entryCount };
-  } catch (err) {
-    if (err instanceof KordocError) throw err;
-    return { totalUncompressed: 0, entryCount: 0 };
-  }
-}
-var SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
-function sanitizeHref(href) {
-  const trimmed = href.trim();
-  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
-  return trimmed;
-}
-function classifyError(err) {
-  if (!(err instanceof Error)) return "PARSE_ERROR";
-  const msg = err.message;
-  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
-  if (msg.includes("DRM")) return "DRM_PROTECTED";
-  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
-  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
-  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
-  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
-  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
-  return "PARSE_ERROR";
-}
-function normalizeKordocError(err, fallbackMessage, stage = "unknown", fallbackCode = "PARSE_ERROR") {
-  if (err instanceof KordocError) {
-    if (!err.stage) err.stage = stage;
-    if (!err.code) err.code = fallbackCode;
-    return err;
-  }
-  const message = err instanceof Error ? err.message : fallbackMessage;
-  const code = err instanceof Error ? classifyError(err) : fallbackCode;
-  return new KordocError(message || fallbackMessage, { code, stage });
-}
-
 // src/table/builder.ts
+init_utils();
 var MAX_COLS = 200;
 var MAX_ROWS = 1e4;
 function buildTable(rows) {
@@ -3483,6 +3509,8 @@ var HEADING_RATIO_H2 = 1.3;
 var HEADING_RATIO_H3 = 1.15;
 
 // src/hwpx/parser.ts
+init_utils();
+init_utils();
 init_page_range();
 init_logger();
 var MAX_DECOMPRESS_SIZE = 500 * 1024 * 1024;
@@ -4325,6 +4353,7 @@ function extractTextFromNode(node) {
 
 // src/hwp5/record.ts
 var import_zlib = require("zlib");
+init_utils();
 var TAG_PARA_HEADER = 66;
 var TAG_PARA_TEXT = 67;
 var TAG_CHAR_SHAPE = 68;
@@ -5374,6 +5403,7 @@ function parseLenientCfb(data) {
 }
 
 // src/hwp5/parser.ts
+init_utils();
 init_page_range();
 init_logger();
 var CFB = __toESM(require_cfb(), 1);
@@ -6029,6 +6059,7 @@ function arrangeCells(rows, cols, cells) {
 }
 
 // src/pdf/parser.ts
+init_utils();
 init_page_range();
 var import_module = require("module");
 var import_path4 = require("path");
@@ -7922,6 +7953,7 @@ function mergeKoreanLines(text) {
 // src/xlsx/parser.ts
 var import_jszip3 = __toESM(require("jszip"), 1);
 var import_xmldom2 = require("@xmldom/xmldom");
+init_utils();
 init_logger();
 var MAX_SHEETS = 100;
 var MAX_DECOMPRESS_SIZE3 = 500 * 1024 * 1024;
@@ -8250,6 +8282,7 @@ async function parseXlsxDocument(buffer, options, existingZip) {
 // src/docx/parser.ts
 var import_jszip4 = __toESM(require("jszip"), 1);
 var import_xmldom3 = require("@xmldom/xmldom");
+init_utils();
 init_logger();
 var MAX_DECOMPRESS_SIZE4 = 500 * 1024 * 1024;
 function getChildElements(parent, localName) {
@@ -8729,6 +8762,7 @@ async function parseDocxDocument(buffer, options, existingZip) {
 }
 
 // src/index.ts
+init_utils();
 init_cli_provider();
 init_markdown_to_blocks();
 init_logger();
@@ -11230,6 +11264,187 @@ async function markdownToXlsx(markdown, options) {
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 }
 
+// src/convert/index.ts
+var import_promises2 = require("fs/promises");
+init_utils();
+
+// src/convert/libreoffice.ts
+var import_libreoffice_convert = __toESM(require("libreoffice-convert"), 1);
+
+// src/convert/error.ts
+var ConvertError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConvertError";
+  }
+};
+
+// src/convert/libreoffice.ts
+var libreConvert = import_libreoffice_convert.default.convert;
+async function assertSofficeAvailable() {
+  const { runCommand: runCommand2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  try {
+    await runCommand2("soffice", ["--version"]);
+  } catch {
+    throw new ConvertError(
+      "SOFFICE_NOT_FOUND",
+      "soffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694."
+    );
+  }
+}
+async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(() => {
+      reject(
+        new ConvertError("TIMEOUT", `\uBCC0\uD658 \uD0C0\uC784\uC544\uC6C3 (${timeoutMs}ms \uCD08\uACFC)`)
+      );
+    }, timeoutMs);
+    libreConvert(buffer, targetExt, void 0, (err, done) => {
+      clearTimeout(timer);
+      if (err || !done) {
+        reject(
+          new ConvertError(
+            "CONVERT_FAILED",
+            err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"
+          )
+        );
+        return;
+      }
+      resolve4(done);
+    });
+  });
+}
+
+// src/convert/index.ts
+var isConverting = false;
+var queue = [];
+async function acquireConvertLock() {
+  if (!isConverting) {
+    isConverting = true;
+    return () => {
+      isConverting = false;
+      const next = queue.shift();
+      next?.();
+    };
+  }
+  return new Promise((resolve4) => {
+    queue.push(() => {
+      isConverting = true;
+      resolve4(() => {
+        isConverting = false;
+        const next = queue.shift();
+        next?.();
+      });
+    });
+  });
+}
+async function convertToPdf(input, options) {
+  let buffer;
+  try {
+    if (typeof input === "string") {
+      buffer = await (0, import_promises2.readFile)(input);
+    } else if (Buffer.isBuffer(input)) {
+      buffer = input;
+    } else {
+      buffer = Buffer.from(input);
+    }
+  } catch (err) {
+    return {
+      success: false,
+      code: "PARSE_ERROR",
+      error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
+      stage: "detect"
+    };
+  }
+  const MAX_FILE_SIZE = 500 * 1024 * 1024;
+  if (buffer.length > MAX_FILE_SIZE) {
+    return {
+      success: false,
+      code: "FILE_TOO_LARGE",
+      error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`,
+      stage: "detect"
+    };
+  }
+  const format = detectFormat(toArrayBuffer(buffer));
+  if (format !== "hwp" && format !== "hwpx") {
+    return {
+      success: false,
+      code: "UNSUPPORTED_FORMAT",
+      error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
+      stage: "detect"
+    };
+  }
+  try {
+    await assertSofficeAvailable();
+  } catch (err) {
+    if (err instanceof ConvertError) {
+      return {
+        success: false,
+        code: err.code,
+        error: err.message,
+        stage: "validate"
+      };
+    }
+    throw err;
+  }
+  const releaseLock = await acquireConvertLock();
+  try {
+    options?.onProgress?.(10, "convert");
+    const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
+    options?.onProgress?.(100, "done");
+    return {
+      success: true,
+      pdf: new Uint8Array(pdf),
+      sourceFormat: format
+    };
+  } catch (err) {
+    if (err instanceof ConvertError) {
+      return {
+        success: false,
+        code: err.code,
+        error: err.message,
+        stage: "convert"
+      };
+    }
+    return {
+      success: false,
+      code: classifyError(err),
+      error: err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328",
+      stage: "convert"
+    };
+  } finally {
+    releaseLock();
+  }
+}
+async function convertHwpToPdf(input, options) {
+  const result = await convertToPdf(input, options);
+  if (result.success && result.sourceFormat !== "hwp") {
+    return {
+      success: false,
+      code: "UNSUPPORTED_FORMAT",
+      error: `HWP 5.x \uD3EC\uB9F7\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${result.sourceFormat}`,
+      stage: "detect"
+    };
+  }
+  return result;
+}
+async function convertHwpxToPdf(input, options) {
+  const result = await convertToPdf(input, options);
+  if (result.success && result.sourceFormat !== "hwpx") {
+    return {
+      success: false,
+      code: "UNSUPPORTED_FORMAT",
+      error: `HWPX \uD3EC\uB9F7\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${result.sourceFormat}`,
+      stage: "detect"
+    };
+  }
+  return result;
+}
+
+// src/index.ts
+init_utils();
+
 // src/ocr/api-key-rotation.ts
 var AllKeysCoolingDownError = class extends Error {
   waitMs;
@@ -11324,11 +11539,10 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
 };
 
 // src/pipeline/unified-ocr.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_path5 = require("path");
 var import_child_process4 = require("child_process");
 var import_node_perf_hooks = require("perf_hooks");
-var import_libreoffice_convert = __toESM(require("libreoffice-convert"), 1);
 init_logger();
 
 // src/pipeline/bounded-queue.ts
@@ -11390,7 +11604,6 @@ var BoundedQueue = class {
 };
 
 // src/pipeline/unified-ocr.ts
-var libreConvert = import_libreoffice_convert.default.convert;
 var UnifiedOcrError = class extends Error {
   code;
   stage;
@@ -11484,9 +11697,9 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const keyPool = ApiKeyRotationPool.fromEnv();
   const runId = options.runId ?? generateRunId("ocr");
   const logger = (options.logger ?? createLoggerFromEnv()).withRun(runId).child({ component: "pipeline/unified-ocr.ts" });
-  await (0, import_promises2.mkdir)(imagesDir, { recursive: true });
-  await (0, import_promises2.mkdir)(rawDir, { recursive: true });
-  await (0, import_promises2.mkdir)(diffDir, { recursive: true });
+  await (0, import_promises3.mkdir)(imagesDir, { recursive: true });
+  await (0, import_promises3.mkdir)(rawDir, { recursive: true });
+  await (0, import_promises3.mkdir)(diffDir, { recursive: true });
   const timingsMs = {};
   const markStageStart = (stage, message) => emitProgress(options.onEvent, stage, 0, stageWeights, { message, type: "stage_start" });
   const markStageProgress = (stage, stagePercent, current, total, message, model) => emitProgress(options.onEvent, stage, stagePercent, stageWeights, { type: "stage_progress", current, total, message, model });
@@ -11505,9 +11718,9 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     if ((0, import_path5.extname)(absInput).toLowerCase() !== ".pdf") {
       await assertSofficeAvailable();
       workingPdfPath = (0, import_path5.join)(workspaceDir, `${stem}.pdf`);
-      const inputBuffer = await (0, import_promises2.readFile)(absInput);
-      const out = await convertWithLibreOffice(inputBuffer, ".pdf");
-      await (0, import_promises2.writeFile)(workingPdfPath, out);
+      const inputBuffer = await (0, import_promises3.readFile)(absInput);
+      const out = await convertBuffer(inputBuffer, ".pdf");
+      await (0, import_promises3.writeFile)(workingPdfPath, out);
     }
     timingsMs.convert = elapsedMs(convertStart);
     markStageDone("convert", "PDF \uBCC0\uD658 \uC644\uB8CC");
@@ -11519,7 +11732,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     markStageStart("render", "PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC911");
     logStage("info", "render", "start", "PDF \uD398\uC774\uC9C0 \uB80C\uB354\uB9C1 \uC2DC\uC791", { pdf: workingPdfPath, dpi, totalPages });
     await runCommand("pdftoppm", ["-png", "-r", String(dpi), "-f", "1", "-l", "1", workingPdfPath, (0, import_path5.join)(imagesDir, "page")]);
-    const firstFiles = (await (0, import_promises2.readdir)(imagesDir)).filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
+    const firstFiles = (await (0, import_promises3.readdir)(imagesDir)).filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
     if (firstFiles.length === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uCCAB \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC2E4\uD328");
     const probeImage = (0, import_path5.join)(imagesDir, firstFiles[0]);
     markStageProgress("render", Math.round(1 / totalPages * 100), 1, totalPages, `\uD398\uC774\uC9C0 1/${totalPages} \uB80C\uB354\uB9C1`);
@@ -11557,7 +11770,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const keyCount = keyPool.snapshot().length;
     const workerCount = Math.max(1, keyCount * concurrencyPerKey);
     const queueCapacity = workerCount * 2;
-    const queue = new BoundedQueue(queueCapacity);
+    const queue2 = new BoundedQueue(queueCapacity);
     const ocrStart = import_node_perf_hooks.performance.now();
     currentStage = "ocr";
     markStageStart("ocr", `OCR \uC9C4\uD589 \uC911 (\uC6CC\uCEE4 ${workerCount}\uAC1C)`);
@@ -11565,17 +11778,17 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     let renderDone = 1;
     const renderProducer = (async () => {
       try {
-        await queue.enqueue({ pageNumber: 1, imagePath: probeImage });
+        await queue2.enqueue({ pageNumber: 1, imagePath: probeImage });
         if (totalPages > 1) {
           for await (const item of renderPdfToPngStream(workingPdfPath, (0, import_path5.join)(imagesDir, "page"), dpi, totalPages, 2)) {
-            await queue.enqueue(item);
+            await queue2.enqueue(item);
             renderDone++;
             markStageProgress("render", Math.round(renderDone / totalPages * 100), renderDone, totalPages, `\uD398\uC774\uC9C0 ${renderDone}/${totalPages} \uB80C\uB354\uB9C1`);
             logStage("debug", "render", "progress", "\uD398\uC774\uC9C0 \uB80C\uB354 \uC644\uB8CC", { page: item.pageNumber });
           }
         }
       } finally {
-        queue.close();
+        queue2.close();
         timingsMs.render = elapsedMs(renderStart);
         markStageDone("render", "\uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC");
         logStage("info", "render", "done", "\uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC", { pages: renderDone, elapsedMs: timingsMs.render });
@@ -11584,7 +11797,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const [, pageResultsMap] = await Promise.all([
       renderProducer,
       ocrWorkerPool({
-        queue,
+        queue: queue2,
         workerCount,
         totalPages,
         ocrInput: {
@@ -11618,7 +11831,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const rawPagePaths = [];
     for (const [pageNum, markdown] of sortedEntries) {
       const pagePath = (0, import_path5.join)(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
-      await (0, import_promises2.writeFile)(pagePath, markdown, "utf-8");
+      await (0, import_promises3.writeFile)(pagePath, markdown, "utf-8");
       rawPagePaths.push(pagePath);
     }
     const mergeStart = import_node_perf_hooks.performance.now();
@@ -11626,7 +11839,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     markStageStart("merge", "\uCD5C\uC885 Markdown \uBCD1\uD569 \uC911");
     logStage("info", "merge", "start", "\uCD5C\uC885 \uBCD1\uD569 \uC2DC\uC791", { pages: rawPagePaths.length });
     const merged = await mergeMarkdownPages(rawPagePaths);
-    await (0, import_promises2.writeFile)(outputPath, merged, "utf-8");
+    await (0, import_promises3.writeFile)(outputPath, merged, "utf-8");
     timingsMs.merge = elapsedMs(mergeStart);
     markStageDone("merge", "\uBCD1\uD569 \uC644\uB8CC");
     logStage("info", "merge", "done", "\uCD5C\uC885 \uBCD1\uD569 \uC644\uB8CC", { outputPath, elapsedMs: timingsMs.merge });
@@ -11642,7 +11855,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       timingsMs,
       modelCachePath
     };
-    await (0, import_promises2.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf-8");
+    await (0, import_promises3.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf-8");
     logStage("info", "finalize", "done", "run-report \uC800\uC7A5 \uC644\uB8CC", { reportPath });
     return { outputPath, reportPath, selectedModel };
   } catch (err) {
@@ -11704,17 +11917,6 @@ function emitProgress(cb, stage, stagePercent, weights, extra) {
     model: extra.model
   });
 }
-async function convertWithLibreOffice(buffer, ext) {
-  return await new Promise((resolvePromise, reject) => {
-    libreConvert(buffer, ext, void 0, (err, done) => {
-      if (err || !done) {
-        reject(new UnifiedOcrError("CONVERT_FAILED", "convert", err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"));
-        return;
-      }
-      resolvePromise(done);
-    });
-  });
-}
 async function getPdfPageCount(pdfPath) {
   const stdout = await runCommandWithStdout("pdfinfo", [pdfPath]);
   const m = stdout.match(/^\s*Pages:\s*(\d+)\s*$/mi);
@@ -11742,7 +11944,7 @@ async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, start
         pdfPath,
         prefixPath
       ]);
-      const files = await (0, import_promises2.readdir)(imagesDir);
+      const files = await (0, import_promises3.readdir)(imagesDir);
       const pageFiles = files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
       const imagePath = (0, import_path5.join)(imagesDir, pageFiles[pageFiles.length - 1]);
       yield { pageNumber: page, imagePath };
@@ -11787,13 +11989,6 @@ async function runCommandWithStdout(cmd, args) {
     });
   });
 }
-async function assertSofficeAvailable() {
-  try {
-    await runCommand("soffice", ["--version"]);
-  } catch {
-    throw new UnifiedOcrError("SOFFICE_NOT_FOUND", "convert", "soffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.");
-  }
-}
 function naturalPageSort(a, b) {
   const na = Number((a.match(/\d+/g) || ["0"]).at(-1) || 0);
   const nb = Number((b.match(/\d+/g) || ["0"]).at(-1) || 0);
@@ -11867,7 +12062,7 @@ function startParallelProbeRuns(input) {
 }
 async function loadModelCache(path) {
   try {
-    const raw = await (0, import_promises2.readFile)(path, "utf-8");
+    const raw = await (0, import_promises3.readFile)(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -11898,15 +12093,15 @@ async function updateModelCache(path, probes) {
     }
   }
   current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await (0, import_promises2.writeFile)(path, JSON.stringify(current, null, 2), "utf-8");
+  await (0, import_promises3.writeFile)(path, JSON.stringify(current, null, 2), "utf-8");
 }
 async function ocrWorkerPool(input) {
-  const { queue, workerCount, ocrInput, onPageDone } = input;
+  const { queue: queue2, workerCount, ocrInput, onPageDone } = input;
   const results = /* @__PURE__ */ new Map();
   let completedCount = 0;
   async function worker() {
     while (true) {
-      const item = await queue.dequeue();
+      const item = await queue2.dequeue();
       if (item === QUEUE_DONE) break;
       const { pageNumber, imagePath, error } = item;
       if (imagePath === null) {
@@ -11958,7 +12153,7 @@ async function ocrImageWithFallback(input) {
 async function mergeMarkdownPages(paths) {
   const out = [];
   for (let i = 0; i < paths.length; i++) {
-    const txt = (await (0, import_promises2.readFile)(paths[i], "utf-8")).trim();
+    const txt = (await (0, import_promises3.readFile)(paths[i], "utf-8")).trim();
     if (!txt) continue;
     out.push(txt);
   }
@@ -12074,7 +12269,7 @@ async function ocrImageViaNim(input) {
   throw new UnifiedOcrError("OCR_FAILED", "ocr", `OCR \uC7AC\uC2DC\uB3C4 \uCD08\uACFC: ${lastErr}`);
 }
 async function encodeBase64(path) {
-  const b = await (0, import_promises2.readFile)(path);
+  const b = await (0, import_promises3.readFile)(path);
   return b.toString("base64");
 }
 function stripCodeFence3(text) {
@@ -12113,7 +12308,7 @@ async function parse2(input, options) {
   let buffer;
   if (typeof input === "string") {
     try {
-      const buf = await (0, import_promises3.readFile)(input);
+      const buf = await (0, import_promises4.readFile)(input);
       buffer = toArrayBuffer(buf);
     } catch (err) {
       const msg = err instanceof Error && "code" in err && err.code === "ENOENT" ? `\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${input}` : `\uD30C\uC77C \uC77D\uAE30 \uC2E4\uD328: ${input}`;
@@ -12273,6 +12468,9 @@ async function parseDocx(buffer, options, zip) {
   VERSION,
   blocksToMarkdown,
   compare,
+  convertHwpToPdf,
+  convertHwpxToPdf,
+  convertToPdf,
   detectFormat,
   detectZipFormat,
   diffBlocks,