kordoc 1.2.0 → 1.4.0

package/dist/index.js

@@ -1,3 +1,55 @@
+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 });
+};
+
+// src/ocr/provider.ts
+var provider_exports = {};
+__export(provider_exports, {
+  ocrPages: () => ocrPages
+});
+async function ocrPages(doc, provider, pageFilter, effectivePageCount) {
+  const blocks = [];
+  for (let i = 1; i <= effectivePageCount; i++) {
+    if (pageFilter && !pageFilter.has(i)) continue;
+    const page = await doc.getPage(i);
+    try {
+      const imageData = await renderPageToPng(page);
+      const text = await provider(imageData, i, "image/png");
+      if (text.trim()) {
+        blocks.push({ type: "paragraph", text: text.trim() });
+      }
+    } catch {
+    }
+  }
+  return blocks;
+}
+async function renderPageToPng(page) {
+  let createCanvas;
+  try {
+    const canvasModule = await import("canvas");
+    createCanvas = canvasModule.createCanvas;
+  } catch {
+    throw new Error("OCR\uC744 \uC0AC\uC6A9\uD558\uB824\uBA74 'canvas' \uD328\uD0A4\uC9C0\uB97C \uC124\uCE58\uD558\uC138\uC694: npm install canvas");
+  }
+  const scale = 2;
+  const viewport = page.getViewport({ scale });
+  const canvas = createCanvas(Math.floor(viewport.width), Math.floor(viewport.height));
+  const ctx = canvas.getContext("2d");
+  await page.render({ canvasContext: ctx, viewport }).promise;
+  return new Uint8Array(canvas.toBuffer("image/png"));
+}
+var init_provider = __esm({
+  "src/ocr/provider.ts"() {
+    "use strict";
+  }
+});
+
 // src/detect.ts
 function magicBytes(buffer) {
   return new Uint8Array(buffer, 0, Math.min(4, buffer.byteLength));
@@ -157,7 +209,7 @@ function tableToMarkdown(table) {
 }
 
 // src/utils.ts
-var VERSION = true ? "1.2.0" : "0.0.0-dev";
+var VERSION = true ? "1.4.0" : "0.0.0-dev";
 var KordocError = class extends Error {
   constructor(message) {
     super(message);
@@ -168,6 +220,47 @@ function isPathTraversal(name) {
   const normalized = name.replace(/\\/g, "/");
   return normalized.includes("..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
 }
+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";
+}
+
+// src/page-range.ts
+function parsePageRange(spec, maxPages) {
+  const result = /* @__PURE__ */ new Set();
+  if (maxPages <= 0) return result;
+  if (Array.isArray(spec)) {
+    for (const n of spec) {
+      const page = Math.round(n);
+      if (page >= 1 && page <= maxPages) result.add(page);
+    }
+    return result;
+  }
+  if (typeof spec !== "string" || spec.trim() === "") return result;
+  const parts = spec.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const rangeMatch = trimmed.match(/^(\d+)\s*-\s*(\d+)$/);
+    if (rangeMatch) {
+      const start = Math.max(1, parseInt(rangeMatch[1], 10));
+      const end = Math.min(maxPages, parseInt(rangeMatch[2], 10));
+      for (let i = start; i <= end; i++) result.add(i);
+    } else {
+      const page = parseInt(trimmed, 10);
+      if (!isNaN(page) && page >= 1 && page <= maxPages) result.add(page);
+    }
+  }
+  return result;
+}
 
 // src/hwpx/parser.ts
 var MAX_DECOMPRESS_SIZE = 100 * 1024 * 1024;
@@ -178,7 +271,7 @@ function clampSpan(val, max) {
 function stripDtd(xml) {
   return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
 }
-async function parseHwpxDocument(buffer) {
+async function parseHwpxDocument(buffer, options) {
   const precheck = precheckZipSize(buffer);
   if (precheck.totalUncompressed > MAX_DECOMPRESS_SIZE) {
     throw new KordocError("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
@@ -196,19 +289,62 @@ async function parseHwpxDocument(buffer) {
   if (actualEntryCount > MAX_ZIP_ENTRIES) {
     throw new KordocError("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
   }
+  const metadata = {};
+  await extractHwpxMetadata(zip, metadata);
   const sectionPaths = await resolveSectionPaths(zip);
   if (sectionPaths.length === 0) throw new KordocError("HWPX\uC5D0\uC11C \uC139\uC158 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  metadata.pageCount = sectionPaths.length;
+  const pageFilter = options?.pages ? parsePageRange(options.pages, sectionPaths.length) : null;
   let totalDecompressed = 0;
   const blocks = [];
-  for (const path of sectionPaths) {
-    const file = zip.file(path);
+  for (let si = 0; si < sectionPaths.length; si++) {
+    if (pageFilter && !pageFilter.has(si + 1)) continue;
+    const file = zip.file(sectionPaths[si]);
     if (!file) continue;
     const xml = await file.async("text");
     totalDecompressed += xml.length * 2;
     if (totalDecompressed > MAX_DECOMPRESS_SIZE) throw new KordocError("ZIP \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
     blocks.push(...parseSectionXml(xml));
   }
-  return blocksToMarkdown(blocks);
+  const markdown = blocksToMarkdown(blocks);
+  return { markdown, blocks, metadata };
+}
+async function extractHwpxMetadata(zip, metadata) {
+  try {
+    const metaPaths = ["meta.xml", "META-INF/meta.xml", "docProps/core.xml"];
+    for (const mp of metaPaths) {
+      const file = zip.file(mp) || Object.values(zip.files).find((f) => f.name.toLowerCase() === mp.toLowerCase()) || null;
+      if (!file) continue;
+      const xml = await file.async("text");
+      parseDublinCoreMetadata(xml, metadata);
+      if (metadata.title || metadata.author) return;
+    }
+  } catch {
+  }
+}
+function parseDublinCoreMetadata(xml, metadata) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(stripDtd(xml), "text/xml");
+  if (!doc.documentElement) return;
+  const getText = (tagNames) => {
+    for (const tag of tagNames) {
+      const els = doc.getElementsByTagName(tag);
+      if (els.length > 0) {
+        const text = els[0].textContent?.trim();
+        if (text) return text;
+      }
+    }
+    return void 0;
+  };
+  metadata.title = metadata.title || getText(["dc:title", "title"]);
+  metadata.author = metadata.author || getText(["dc:creator", "creator", "cp:lastModifiedBy"]);
+  metadata.description = metadata.description || getText(["dc:description", "description", "dc:subject", "subject"]);
+  metadata.createdAt = metadata.createdAt || getText(["dcterms:created", "meta:creation-date"]);
+  metadata.modifiedAt = metadata.modifiedAt || getText(["dcterms:modified", "meta:date"]);
+  const keywords = getText(["dc:keyword", "cp:keywords", "meta:keyword"]);
+  if (keywords && !metadata.keywords) {
+    metadata.keywords = keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean);
+  }
 }
 function precheckZipSize(buffer) {
   try {
@@ -247,7 +383,7 @@ function extractFromBrokenZip(buffer) {
   const data = new Uint8Array(buffer);
   const view = new DataView(buffer);
   let pos = 0;
-  const texts = [];
+  const blocks = [];
   let totalDecompressed = 0;
   let entryCount = 0;
   while (pos < data.length - 30) {
@@ -288,14 +424,14 @@ function extractFromBrokenZip(buffer) {
       }
       totalDecompressed += content.length * 2;
       if (totalDecompressed > MAX_DECOMPRESS_SIZE) throw new KordocError("\uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC");
-      const sectionText = blocksToMarkdown(parseSectionXml(content));
-      if (sectionText) texts.push(sectionText);
+      blocks.push(...parseSectionXml(content));
     } catch {
       continue;
     }
   }
-  if (texts.length === 0) throw new KordocError("\uC190\uC0C1\uB41C HWPX\uC5D0\uC11C \uC139\uC158 \uB370\uC774\uD130\uB97C \uBCF5\uAD6C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
-  return texts.join("\n\n");
+  if (blocks.length === 0) throw new KordocError("\uC190\uC0C1\uB41C HWPX\uC5D0\uC11C \uC139\uC158 \uB370\uC774\uD130\uB97C \uBCF5\uAD6C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  const markdown = blocksToMarkdown(blocks);
+  return { markdown, blocks };
 }
 async function resolveSectionPaths(zip) {
   const manifestPaths = ["Contents/content.hpf", "content.hpf"];
@@ -567,7 +703,7 @@ var require2 = createRequire(import.meta.url);
 var CFB = require2("cfb");
 var MAX_SECTIONS = 100;
 var MAX_TOTAL_DECOMPRESS = 100 * 1024 * 1024;
-function parseHwp5Document(buffer) {
+function parseHwp5Document(buffer, options) {
   const cfb = CFB.parse(buffer);
   const headerEntry = CFB.find(cfb, "/FileHeader");
   if (!headerEntry?.content) throw new KordocError("FileHeader \uC2A4\uD2B8\uB9BC \uC5C6\uC74C");
@@ -576,18 +712,59 @@ function parseHwp5Document(buffer) {
   if (header.flags & FLAG_ENCRYPTED) throw new KordocError("\uC554\uD638\uD654\uB41C HWP\uB294 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
   if (header.flags & FLAG_DRM) throw new KordocError("DRM \uBCF4\uD638\uB41C HWP\uB294 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
   const compressed = (header.flags & FLAG_COMPRESSED) !== 0;
+  const metadata = {
+    version: `${header.versionMajor}.x`
+  };
+  extractHwp5Metadata(cfb, metadata);
   const sections = findSections(cfb);
   if (sections.length === 0) throw new KordocError("\uC139\uC158 \uC2A4\uD2B8\uB9BC\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  metadata.pageCount = sections.length;
+  const pageFilter = options?.pages ? parsePageRange(options.pages, sections.length) : null;
   const blocks = [];
   let totalDecompressed = 0;
-  for (const sectionData of sections) {
+  for (let si = 0; si < sections.length; si++) {
+    if (pageFilter && !pageFilter.has(si + 1)) continue;
+    const sectionData = sections[si];
     const data = compressed ? decompressStream(Buffer.from(sectionData)) : Buffer.from(sectionData);
     totalDecompressed += data.length;
     if (totalDecompressed > MAX_TOTAL_DECOMPRESS) throw new KordocError("\uCD1D \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (decompression bomb \uC758\uC2EC)");
     const records = readRecords(data);
     blocks.push(...parseSection(records));
   }
-  return blocksToMarkdown(blocks);
+  const markdown = blocksToMarkdown(blocks);
+  return { markdown, blocks, metadata };
+}
+function extractHwp5Metadata(cfb, metadata) {
+  try {
+    const summaryEntry = CFB.find(cfb, "/HwpSummaryInformation") || CFB.find(cfb, "/SummaryInformation");
+    if (!summaryEntry?.content) return;
+    const data = Buffer.from(summaryEntry.content);
+    if (data.length < 48) return;
+    const numSets = data.readUInt32LE(24);
+    if (numSets === 0) return;
+    const setOffset = data.readUInt32LE(44);
+    if (setOffset >= data.length - 8) return;
+    const numProps = data.readUInt32LE(setOffset + 4);
+    if (numProps === 0 || numProps > 100) return;
+    for (let i = 0; i < numProps; i++) {
+      const entryOffset = setOffset + 8 + i * 8;
+      if (entryOffset + 8 > data.length) break;
+      const propId = data.readUInt32LE(entryOffset);
+      const propOffset = setOffset + data.readUInt32LE(entryOffset + 4);
+      if (propOffset + 8 > data.length) continue;
+      if (propId !== 2 && propId !== 4 && propId !== 6) continue;
+      const propType = data.readUInt32LE(propOffset);
+      if (propType !== 30) continue;
+      const strLen = data.readUInt32LE(propOffset + 4);
+      if (strLen === 0 || strLen > 1e4 || propOffset + 8 + strLen > data.length) continue;
+      const str = data.subarray(propOffset + 8, propOffset + 8 + strLen).toString("utf8").replace(/\0+$/, "").trim();
+      if (!str) continue;
+      if (propId === 2) metadata.title = str;
+      else if (propId === 4) metadata.author = str;
+      else if (propId === 6) metadata.description = str;
+    }
+  } catch {
+  }
 }
 function findSections(cfb) {
   const sections = [];
@@ -727,33 +904,30 @@ function arrangeCells(rows, cols, cells) {
   return grid.map((row) => row.map((c) => c || { text: "", colSpan: 1, rowSpan: 1 }));
 }
 
+// src/pdf/polyfill.ts
+import * as pdfjsWorker from "pdfjs-dist/legacy/build/pdf.worker.mjs";
+var g = globalThis;
+if (typeof g.DOMMatrix === "undefined") {
+  g.DOMMatrix = class DOMMatrix {
+    m = [1, 0, 0, 1, 0, 0];
+    constructor(init) {
+      if (init) this.m = init;
+    }
+  };
+}
+if (typeof g.Path2D === "undefined") {
+  g.Path2D = class Path2D {
+  };
+}
+g.pdfjsWorker = pdfjsWorker;
+
 // src/pdf/parser.ts
-import { createRequire as createRequire2 } from "module";
-import { pathToFileURL } from "url";
+import { getDocument, GlobalWorkerOptions } from "pdfjs-dist/legacy/build/pdf.mjs";
+GlobalWorkerOptions.workerSrc = "";
 var MAX_PAGES = 5e3;
 var MAX_TOTAL_TEXT = 100 * 1024 * 1024;
-var pdfjsModule = null;
-async function loadPdfjs() {
-  if (pdfjsModule) return pdfjsModule;
-  try {
-    const mod = await import("pdfjs-dist/legacy/build/pdf.mjs");
-    const req = createRequire2(import.meta.url);
-    const workerPath = req.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
-    mod.GlobalWorkerOptions.workerSrc = pathToFileURL(workerPath).href;
-    pdfjsModule = mod;
-    return mod;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("Cannot find") || msg.includes("MODULE_NOT_FOUND")) return null;
-    throw new KordocError(`pdfjs-dist \uB85C\uB529 \uC2E4\uD328: ${msg}`);
-  }
-}
-async function parsePdfDocument(buffer) {
-  const pdfjs = await loadPdfjs();
-  if (!pdfjs) {
-    return { success: false, fileType: "pdf", pageCount: 0, error: "pdfjs-dist\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. npm install pdfjs-dist" };
-  }
-  const doc = await pdfjs.getDocument({
+async function parsePdfDocument(buffer, options) {
+  const doc = await getDocument({
     data: new Uint8Array(buffer),
     useSystemFonts: true,
     disableFontFace: true,
@@ -761,12 +935,17 @@ async function parsePdfDocument(buffer) {
   }).promise;
   try {
     const pageCount = doc.numPages;
-    if (pageCount === 0) return { success: false, fileType: "pdf", pageCount: 0, error: "PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." };
+    if (pageCount === 0) return { success: false, fileType: "pdf", pageCount: 0, error: "PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", blocks: [] };
+    const metadata = { pageCount };
+    await extractPdfMetadata(doc, metadata);
     const pageTexts = [];
+    const blocks = [];
     let totalChars = 0;
     let totalTextBytes = 0;
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
+    const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
     for (let i = 1; i <= effectivePageCount; i++) {
+      if (pageFilter && !pageFilter.has(i)) continue;
       const page = await doc.getPage(i);
       const tc = await page.getTextContent();
       const pageText = extractPageContent(tc.items);
@@ -774,18 +953,54 @@ async function parsePdfDocument(buffer) {
       totalTextBytes += pageText.length * 2;
       if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
       pageTexts.push(pageText);
+      blocks.push({ type: "paragraph", text: pageText });
     }
-    if (totalChars / effectivePageCount < 10) {
-      return { success: false, fileType: "pdf", pageCount, isImageBased: true, error: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)` };
+    const parsedPageCount = pageFilter ? pageFilter.size : effectivePageCount;
+    if (totalChars / Math.max(parsedPageCount, 1) < 10) {
+      if (options?.ocr) {
+        try {
+          const { ocrPages: ocrPages2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+          const ocrBlocks = await ocrPages2(doc, options.ocr, pageFilter, effectivePageCount);
+          if (ocrBlocks.length > 0) {
+            const ocrMarkdown = ocrBlocks.map((b) => b.text || "").filter(Boolean).join("\n\n");
+            return { success: true, fileType: "pdf", markdown: ocrMarkdown, pageCount: parsedPageCount, blocks: ocrBlocks, metadata, isImageBased: true };
+          }
+        } catch {
+        }
+      }
+      return { success: false, fileType: "pdf", pageCount, isImageBased: true, error: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`, code: "IMAGE_BASED_PDF" };
     }
     let markdown = pageTexts.filter((t) => t.trim()).join("\n\n");
     markdown = cleanPdfText(markdown);
-    return { success: true, fileType: "pdf", markdown, pageCount: effectivePageCount };
+    return { success: true, fileType: "pdf", markdown, pageCount: parsedPageCount, blocks, metadata };
   } finally {
     await doc.destroy().catch(() => {
     });
   }
 }
+async function extractPdfMetadata(doc, metadata) {
+  try {
+    const result = await doc.getMetadata();
+    if (!result?.info) return;
+    const info = result.info;
+    if (typeof info.Title === "string" && info.Title.trim()) metadata.title = info.Title.trim();
+    if (typeof info.Author === "string" && info.Author.trim()) metadata.author = info.Author.trim();
+    if (typeof info.Creator === "string" && info.Creator.trim()) metadata.creator = info.Creator.trim();
+    if (typeof info.Subject === "string" && info.Subject.trim()) metadata.description = info.Subject.trim();
+    if (typeof info.Keywords === "string" && info.Keywords.trim()) {
+      metadata.keywords = info.Keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean);
+    }
+    if (typeof info.CreationDate === "string") metadata.createdAt = parsePdfDate(info.CreationDate);
+    if (typeof info.ModDate === "string") metadata.modifiedAt = parsePdfDate(info.ModDate);
+  } catch {
+  }
+}
+function parsePdfDate(dateStr) {
+  const m = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
+  if (!m) return void 0;
+  const [, year, month = "01", day = "01", hour = "00", min = "00", sec = "00"] = m;
+  return `${year}-${month}-${day}T${hour}:${min}:${sec}`;
+}
 function extractPageContent(rawItems) {
   const items = normalizeItems(rawItems);
   if (items.length === 0) return "";
@@ -1058,52 +1273,446 @@ function mergeKoreanLines(text) {
   return result.join("\n");
 }
 
+// src/diff/text-diff.ts
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (!a || !b) return 0;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a, b) / maxLen;
+}
+function normalizedSimilarity(a, b) {
+  return similarity(normalize(a), normalize(b));
+}
+function normalize(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function levenshtein(a, b) {
+  if (a.length > b.length) [a, b] = [b, a];
+  const m = a.length;
+  const n = b.length;
+  let prev = Array.from({ length: m + 1 }, (_, i) => i);
+  let curr = new Array(m + 1);
+  for (let j = 1; j <= n; j++) {
+    curr[0] = j;
+    for (let i = 1; i <= m; i++) {
+      if (a[i - 1] === b[j - 1]) {
+        curr[i] = prev[i - 1];
+      } else {
+        curr[i] = 1 + Math.min(prev[i - 1], prev[i], curr[i - 1]);
+      }
+    }
+    ;
+    [prev, curr] = [curr, prev];
+  }
+  return prev[m];
+}
+
+// src/diff/compare.ts
+var SIMILARITY_THRESHOLD = 0.4;
+async function compare(bufferA, bufferB, options) {
+  const [resultA, resultB] = await Promise.all([
+    parse(bufferA, options),
+    parse(bufferB, options)
+  ]);
+  if (!resultA.success) throw new Error(`\uBB38\uC11CA \uD30C\uC2F1 \uC2E4\uD328: ${resultA.error}`);
+  if (!resultB.success) throw new Error(`\uBB38\uC11CB \uD30C\uC2F1 \uC2E4\uD328: ${resultB.error}`);
+  return diffBlocks(resultA.blocks, resultB.blocks);
+}
+function diffBlocks(blocksA, blocksB) {
+  const aligned = alignBlocks(blocksA, blocksB);
+  const stats = { added: 0, removed: 0, modified: 0, unchanged: 0 };
+  const diffs = [];
+  for (const [a, b] of aligned) {
+    if (a && b) {
+      const sim = blockSimilarity(a, b);
+      if (sim >= 0.99) {
+        diffs.push({ type: "unchanged", before: a, after: b, similarity: 1 });
+        stats.unchanged++;
+      } else {
+        const diff = { type: "modified", before: a, after: b, similarity: sim };
+        if (a.type === "table" && b.type === "table" && a.table && b.table) {
+          diff.cellDiffs = diffTableCells(a.table, b.table);
+        }
+        diffs.push(diff);
+        stats.modified++;
+      }
+    } else if (a) {
+      diffs.push({ type: "removed", before: a });
+      stats.removed++;
+    } else if (b) {
+      diffs.push({ type: "added", after: b });
+      stats.added++;
+    }
+  }
+  return { stats, diffs };
+}
+function alignBlocks(a, b) {
+  const m = a.length, n = b.length;
+  if (m * n > 1e7) return fallbackAlign(a, b);
+  const simCache = /* @__PURE__ */ new Map();
+  const getSim = (i2, j2) => {
+    const key = `${i2},${j2}`;
+    let v = simCache.get(key);
+    if (v === void 0) {
+      v = blockSimilarity(a[i2], b[j2]);
+      simCache.set(key, v);
+    }
+    return v;
+  };
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (getSim(i2 - 1, j2 - 1) >= SIMILARITY_THRESHOLD) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const pairs = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (getSim(i - 1, j - 1) >= SIMILARITY_THRESHOLD && dp[i][j] === dp[i - 1][j - 1] + 1) {
+      pairs.push([i - 1, j - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  pairs.reverse();
+  const result = [];
+  let ai = 0, bi = 0;
+  for (const [pi, pj] of pairs) {
+    while (ai < pi) result.push([a[ai++], null]);
+    while (bi < pj) result.push([null, b[bi++]]);
+    result.push([a[ai++], b[bi++]]);
+  }
+  while (ai < m) result.push([a[ai++], null]);
+  while (bi < n) result.push([null, b[bi++]]);
+  return result;
+}
+function fallbackAlign(a, b) {
+  const result = [];
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    result.push([a[i] || null, b[i] || null]);
+  }
+  return result;
+}
+function blockSimilarity(a, b) {
+  if (a.type !== b.type) return 0;
+  if (a.type === "paragraph") {
+    return normalizedSimilarity(a.text || "", b.text || "");
+  }
+  if (a.type === "table" && a.table && b.table) {
+    return tableSimilarity(a.table, b.table);
+  }
+  return 0;
+}
+function tableSimilarity(a, b) {
+  const dimSim = 1 - Math.abs(a.rows * a.cols - b.rows * b.cols) / Math.max(a.rows * a.cols, b.rows * b.cols, 1);
+  const textsA = a.cells.flat().map((c) => c.text).join(" ");
+  const textsB = b.cells.flat().map((c) => c.text).join(" ");
+  const contentSim = normalizedSimilarity(textsA, textsB);
+  return dimSim * 0.3 + contentSim * 0.7;
+}
+function diffTableCells(a, b) {
+  const maxRows = Math.max(a.rows, b.rows);
+  const maxCols = Math.max(a.cols, b.cols);
+  const result = [];
+  for (let r = 0; r < maxRows; r++) {
+    const row = [];
+    for (let c = 0; c < maxCols; c++) {
+      const cellA = r < a.rows && c < a.cols ? a.cells[r][c].text : void 0;
+      const cellB = r < b.rows && c < b.cols ? b.cells[r][c].text : void 0;
+      let type;
+      if (cellA === void 0) type = "added";
+      else if (cellB === void 0) type = "removed";
+      else if (cellA === cellB) type = "unchanged";
+      else type = "modified";
+      row.push({ type, before: cellA, after: cellB });
+    }
+    result.push(row);
+  }
+  return result;
+}
+
+// src/form/recognize.ts
+var LABEL_KEYWORDS = /* @__PURE__ */ new Set([
+  "\uC131\uBA85",
+  "\uC774\uB984",
+  "\uC8FC\uC18C",
+  "\uC804\uD654",
+  "\uC804\uD654\uBC88\uD638",
+  "\uD734\uB300\uD3F0",
+  "\uD578\uB4DC\uD3F0",
+  "\uC5F0\uB77D\uCC98",
+  "\uC0DD\uB144\uC6D4\uC77C",
+  "\uC8FC\uBBFC\uB4F1\uB85D\uBC88\uD638",
+  "\uC18C\uC18D",
+  "\uC9C1\uC704",
+  "\uC9C1\uAE09",
+  "\uBD80\uC11C",
+  "\uC774\uBA54\uC77C",
+  "\uD329\uC2A4",
+  "\uD559\uAD50",
+  "\uD559\uB144",
+  "\uBC18",
+  "\uBC88\uD638",
+  "\uC2E0\uCCAD\uC778",
+  "\uB300\uD45C\uC790",
+  "\uB2F4\uB2F9\uC790",
+  "\uC791\uC131\uC790",
+  "\uD655\uC778\uC790",
+  "\uC2B9\uC778\uC790",
+  "\uC77C\uC2DC",
+  "\uB0A0\uC9DC",
+  "\uAE30\uAC04",
+  "\uC7A5\uC18C",
+  "\uBAA9\uC801",
+  "\uC0AC\uC720",
+  "\uBE44\uACE0",
+  "\uAE08\uC561",
+  "\uC218\uB7C9",
+  "\uB2E8\uAC00",
+  "\uD569\uACC4",
+  "\uACC4",
+  "\uC18C\uACC4"
+]);
+function isLabelCell(text) {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.length > 30) return false;
+  for (const kw of LABEL_KEYWORDS) {
+    if (trimmed.includes(kw)) return true;
+  }
+  if (/^[가-힣\s()·:]{2,8}$/.test(trimmed) && !/\d/.test(trimmed)) return true;
+  if (/^[가-힣A-Za-z\s]+[:：]$/.test(trimmed)) return true;
+  return false;
+}
+function extractFormFields(blocks) {
+  const fields = [];
+  let totalTables = 0;
+  let formTables = 0;
+  for (const block of blocks) {
+    if (block.type !== "table" || !block.table) continue;
+    totalTables++;
+    const tableFields = extractFromTable(block.table);
+    if (tableFields.length > 0) {
+      formTables++;
+      fields.push(...tableFields);
+    }
+  }
+  for (const block of blocks) {
+    if (block.type === "paragraph" && block.text) {
+      const inlineFields = extractInlineFields(block.text);
+      fields.push(...inlineFields);
+    }
+  }
+  const confidence = totalTables > 0 ? formTables / totalTables : fields.length > 0 ? 0.3 : 0;
+  return { fields, confidence: Math.min(confidence, 1) };
+}
+function extractFromTable(table) {
+  const fields = [];
+  if (table.cols >= 2) {
+    for (let r = 0; r < table.rows; r++) {
+      for (let c = 0; c < table.cols - 1; c++) {
+        const labelCell = table.cells[r][c];
+        const valueCell = table.cells[r][c + 1];
+        if (isLabelCell(labelCell.text) && valueCell.text.trim()) {
+          fields.push({
+            label: labelCell.text.trim().replace(/[:：]\s*$/, ""),
+            value: valueCell.text.trim(),
+            row: r,
+            col: c
+          });
+        }
+      }
+    }
+  }
+  if (fields.length === 0 && table.rows >= 2 && table.cols >= 2) {
+    const headerRow = table.cells[0];
+    const allLabels = headerRow.every((cell) => {
+      const t = cell.text.trim();
+      return t.length > 0 && t.length <= 20;
+    });
+    if (allLabels) {
+      for (let r = 1; r < table.rows; r++) {
+        for (let c = 0; c < table.cols; c++) {
+          const label = headerRow[c].text.trim();
+          const value = table.cells[r][c].text.trim();
+          if (label && value) {
+            fields.push({ label, value, row: r, col: c });
+          }
+        }
+      }
+    }
+  }
+  return fields;
+}
+function extractInlineFields(text) {
+  const fields = [];
+  const pattern = /([가-힣A-Za-z]{2,10})\s*[:：]\s*([^\n,;]{1,100})/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const label = match[1].trim();
+    const value = match[2].trim();
+    if (value) {
+      fields.push({ label, value, row: -1, col: -1 });
+    }
+  }
+  return fields;
+}
+
+// src/hwpx/generator.ts
+import JSZip2 from "jszip";
+var HWPML_NS = "http://www.hancom.co.kr/hwpml/2016/HwpMl";
+async function markdownToHwpx(markdown) {
+  const blocks = parseMarkdownToBlocks(markdown);
+  const sectionXml = blocksToSectionXml(blocks);
+  const zip = new JSZip2();
+  zip.file("mimetype", "application/hwp+zip", { compression: "STORE" });
+  zip.file("Contents/content.hpf", generateManifest());
+  zip.file("Contents/section0.xml", sectionXml);
+  return await zip.generateAsync({ type: "arraybuffer" });
+}
+function parseMarkdownToBlocks(md) {
+  const lines = md.split("\n");
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      blocks.push({ type: "heading", text: headingMatch[2].trim(), level: headingMatch[1].length });
+      i++;
+      continue;
+    }
+    if (line.trimStart().startsWith("|")) {
+      const tableRows = [];
+      while (i < lines.length && lines[i].trimStart().startsWith("|")) {
+        const row = lines[i];
+        if (/^\|[\s\-:]+\|/.test(row) && !row.includes("---") === false && /^[\s|:\-]+$/.test(row)) {
+          i++;
+          continue;
+        }
+        const cells = row.split("|").slice(1, -1).map((c) => c.trim());
+        if (cells.length > 0) tableRows.push(cells);
+        i++;
+      }
+      if (tableRows.length > 0) {
+        blocks.push({ type: "table", rows: tableRows });
+      }
+      continue;
+    }
+    blocks.push({ type: "paragraph", text: line.trim() });
+    i++;
+  }
+  return blocks;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateParagraph(text) {
+  return `<hp:p><hp:run><hp:t>${escapeXml(text)}</hp:t></hp:run></hp:p>`;
+}
+function generateTable(rows) {
+  const trElements = rows.map((row) => {
+    const tdElements = row.map(
+      (cell) => `<hp:tc><hp:cellSpan colSpan="1" rowSpan="1"/>${generateParagraph(cell)}</hp:tc>`
+    ).join("");
+    return `<hp:tr>${tdElements}</hp:tr>`;
+  }).join("");
+  return `<hp:tbl>${trElements}</hp:tbl>`;
+}
+function blocksToSectionXml(blocks) {
+  const body = blocks.map((block) => {
+    switch (block.type) {
+      case "heading":
+        return generateParagraph(block.text || "");
+      case "table":
+        return block.rows ? generateTable(block.rows) : "";
+      case "paragraph":
+        return generateParagraph(block.text || "");
+      default:
+        return "";
+    }
+  }).join("\n  ");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<hs:sec xmlns:hs="${HWPML_NS}" xmlns:hp="${HWPML_NS}">
+  ${body}
+</hs:sec>`;
+}
+function generateManifest() {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<opf:package xmlns:opf="http://www.idpf.org/2007/opf">
+  <opf:manifest>
+    <opf:item id="s0" href="section0.xml" media-type="application/xml"/>
+  </opf:manifest>
+  <opf:spine>
+    <opf:itemref idref="s0"/>
+  </opf:spine>
+</opf:package>`;
+}
+
 // src/index.ts
-async function parse(buffer) {
+async function parse(buffer, options) {
   if (!buffer || buffer.byteLength === 0) {
-    return { success: false, fileType: "unknown", error: "\uBE48 \uBC84\uD37C\uC774\uAC70\uB098 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC785\uB825\uC785\uB2C8\uB2E4." };
+    return { success: false, fileType: "unknown", error: "\uBE48 \uBC84\uD37C\uC774\uAC70\uB098 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC785\uB825\uC785\uB2C8\uB2E4.", code: "EMPTY_INPUT" };
   }
   const format = detectFormat(buffer);
   switch (format) {
     case "hwpx":
-      return parseHwpx(buffer);
+      return parseHwpx(buffer, options);
     case "hwp":
-      return parseHwp(buffer);
+      return parseHwp(buffer, options);
     case "pdf":
-      return parsePdf(buffer);
+      return parsePdf(buffer, options);
     default:
-      return { success: false, fileType: "unknown", error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4." };
+      return { success: false, fileType: "unknown", error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4.", code: "UNSUPPORTED_FORMAT" };
   }
 }
-async function parseHwpx(buffer) {
+async function parseHwpx(buffer, options) {
   try {
-    const markdown = await parseHwpxDocument(buffer);
-    return { success: true, fileType: "hwpx", markdown };
+    const { markdown, blocks, metadata } = await parseHwpxDocument(buffer, options);
+    return { success: true, fileType: "hwpx", markdown, blocks, metadata };
   } catch (err) {
-    return { success: false, fileType: "hwpx", error: err instanceof Error ? err.message : "HWPX \uD30C\uC2F1 \uC2E4\uD328" };
+    return { success: false, fileType: "hwpx", error: err instanceof Error ? err.message : "HWPX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
-async function parseHwp(buffer) {
+async function parseHwp(buffer, options) {
   try {
-    const markdown = parseHwp5Document(Buffer.from(buffer));
-    return { success: true, fileType: "hwp", markdown };
+    const { markdown, blocks, metadata } = parseHwp5Document(Buffer.from(buffer), options);
+    return { success: true, fileType: "hwp", markdown, blocks, metadata };
   } catch (err) {
-    return { success: false, fileType: "hwp", error: err instanceof Error ? err.message : "HWP \uD30C\uC2F1 \uC2E4\uD328" };
+    return { success: false, fileType: "hwp", error: err instanceof Error ? err.message : "HWP \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
-async function parsePdf(buffer) {
+async function parsePdf(buffer, options) {
   try {
-    return await parsePdfDocument(buffer);
+    return await parsePdfDocument(buffer, options);
   } catch (err) {
-    return { success: false, fileType: "pdf", error: err instanceof Error ? err.message : "PDF \uD30C\uC2F1 \uC2E4\uD328" };
+    return { success: false, fileType: "pdf", error: err instanceof Error ? err.message : "PDF \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
 export {
   VERSION,
+  blocksToMarkdown,
+  compare,
   detectFormat,
+  diffBlocks,
+  extractFormFields,
   isHwpxFile,
   isOldHwpFile,
   isPdfFile,
+  markdownToHwpx,
   parse,
   parseHwp,
   parseHwpx,