kordoc 2.2.3 → 2.2.4

package/dist/index.cjs

@@ -121,7 +121,11 @@ __export(index_exports, {
   detectZipFormat: () => detectZipFormat,
   diffBlocks: () => diffBlocks,
   extractFormFields: () => extractFormFields,
+  fillForm: () => fillForm,
+  fillFormFields: () => fillFormFields,
+  fillHwpx: () => fillHwpx,
   isHwpxFile: () => isHwpxFile,
+  isLabelCell: () => isLabelCell,
   isOldHwpFile: () => isOldHwpFile,
   isPdfFile: () => isPdfFile,
   isZipFile: () => isZipFile,
@@ -183,7 +187,7 @@ var import_zlib = require("zlib");
 var import_xmldom = require("@xmldom/xmldom");
 
 // src/utils.ts
-var VERSION = true ? "2.2.3" : "0.0.0-dev";
+var VERSION = true ? "2.2.4" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -5608,21 +5612,21 @@ async function parseXlsxDocument(buffer, options) {
 var import_jszip4 = __toESM(require("jszip"), 1);
 var import_xmldom3 = require("@xmldom/xmldom");
 var MAX_DECOMPRESS_SIZE4 = 100 * 1024 * 1024;
-function getChildElements(parent, localName) {
+function getChildElements(parent, localName2) {
   const result = [];
   const children = parent.childNodes;
   for (let i = 0; i < children.length; i++) {
     const node = children[i];
     if (node.nodeType === 1) {
       const el = node;
-      if (el.localName === localName || el.tagName?.endsWith(`:${localName}`)) {
+      if (el.localName === localName2 || el.tagName?.endsWith(`:${localName2}`)) {
         result.push(el);
       }
     }
   }
   return result;
 }
-function findElements(parent, localName) {
+function findElements(parent, localName2) {
   const result = [];
   const walk = (node) => {
     const children = node.childNodes;
@@ -5630,7 +5634,7 @@ function findElements(parent, localName) {
       const child = children[i];
       if (child.nodeType === 1) {
         const el = child;
-        if (el.localName === localName || el.tagName?.endsWith(`:${localName}`)) {
+        if (el.localName === localName2 || el.tagName?.endsWith(`:${localName2}`)) {
           result.push(el);
         }
         walk(el);
@@ -5640,11 +5644,11 @@ function findElements(parent, localName) {
   walk(parent);
   return result;
 }
-function getAttr(el, localName) {
+function getAttr(el, localName2) {
   const attrs = el.attributes;
   for (let i = 0; i < attrs.length; i++) {
     const attr = attrs[i];
-    if (attr.localName === localName || attr.name === localName) return attr.value;
+    if (attr.localName === localName2 || attr.name === localName2) return attr.value;
   }
   return null;
 }
@@ -5991,11 +5995,11 @@ async function parseDocxDocument(buffer, options) {
     const node = children[i];
     if (node.nodeType !== 1) continue;
     const el = node;
-    const localName = el.localName ?? el.tagName?.split(":").pop();
-    if (localName === "p") {
+    const localName2 = el.localName ?? el.tagName?.split(":").pop();
+    if (localName2 === "p") {
       const block = parseParagraph(el, styles, numbering, footnotes, rels);
       if (block) blocks.push(block);
-    } else if (localName === "tbl") {
+    } else if (localName2 === "tbl") {
       const block = parseTable(el, styles, numbering, footnotes, rels);
       if (block) blocks.push(block);
     }
@@ -6033,183 +6037,6 @@ async function parseDocxDocument(buffer, options) {
   };
 }
 
-// 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();
-}
-var MAX_LEVENSHTEIN_LEN = 1e4;
-function levenshtein(a, b) {
-  if (a.length + b.length > MAX_LEVENSHTEIN_LEN) {
-    const sampleLen = Math.min(500, a.length, b.length);
-    let diffs = 0;
-    for (let i = 0; i < sampleLen; i++) if (a[i] !== b[i]) diffs++;
-    const sampleRate = sampleLen > 0 ? diffs / sampleLen : 1;
-    return Math.abs(a.length - b.length) + Math.round(Math.min(a.length, b.length) * sampleRate);
-  }
-  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.text !== void 0 && b.text !== void 0) {
-    return normalizedSimilarity(a.text || "", b.text || "");
-  }
-  if (a.type === "table" && a.table && b.table) {
-    return tableSimilarity(a.table, b.table);
-  }
-  if (a.type === b.type) return 1;
-  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",
@@ -6250,15 +6077,20 @@ var LABEL_KEYWORDS = /* @__PURE__ */ new Set([
   "\uB2E8\uAC00",
   "\uD569\uACC4",
   "\uACC4",
-  "\uC18C\uACC4"
+  "\uC18C\uACC4",
+  "\uB4F1\uB85D\uAE30\uC900\uC9C0",
+  "\uBCF8\uC801",
+  "\uC704\uC784\uC778",
+  "\uCCAD\uAD6C\uC0AC\uC720",
+  "\uC18C\uBA85\uC790\uB8CC"
 ]);
 function isLabelCell(text) {
-  const trimmed = text.trim();
+  const trimmed = text.trim().replace(/[¹²³⁴⁵⁶⁷⁸⁹⁰*※]+$/g, "").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 (/^[가-힣\s()（）·:：]+$/.test(trimmed) && trimmed.replace(/\s/g, "").length >= 2 && trimmed.replace(/\s/g, "").length <= 8 && !/\d/.test(trimmed)) return true;
   if (/^[가-힣A-Za-z\s]+[:：]$/.test(trimmed)) return true;
   return false;
 }
@@ -6281,63 +6113,572 @@ function extractFormFields(blocks) {
       fields.push(...inlineFields);
     }
   }
-  const confidence = totalTables > 0 ? formTables / totalTables : fields.length > 0 ? 0.3 : 0;
-  return { fields, confidence: Math.min(confidence, 1) };
+  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)) {
+          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/form/match.ts
+function normalizeLabel(label) {
+  return label.trim().replace(/[:：\s()（）·]/g, "");
+}
+function findMatchingKey(cellLabel, values) {
+  if (values.has(cellLabel)) return cellLabel;
+  let bestKey;
+  let bestLen = 0;
+  for (const key of values.keys()) {
+    if (cellLabel.startsWith(key)) {
+      if (key.length >= cellLabel.length * 0.6 && key.length > bestLen) {
+        bestLen = key.length;
+        bestKey = key;
+      }
+    } else if (key.startsWith(cellLabel)) {
+      if (cellLabel.length >= key.length * 0.6 && cellLabel.length > bestLen) {
+        bestLen = cellLabel.length;
+        bestKey = key;
+      }
+    }
+  }
+  return bestKey;
+}
+function isKeywordLabel(text) {
+  const trimmed = text.trim().replace(/[¹²³⁴⁵⁶⁷⁸⁹⁰*※]+$/g, "").trim();
+  if (!trimmed || trimmed.length > 15) return false;
+  for (const kw of LABEL_KEYWORDS) {
+    if (trimmed.includes(kw)) return true;
+  }
+  return false;
+}
+function fillInCellPatterns(cellText, values, matchedLabels) {
+  let text = cellText;
+  const matches = [];
+  text = text.replace(
+    /([가-힣A-Za-z]+)\(\s{1,}\)([가-힣A-Za-z]*)/g,
+    (match, prefix, suffix) => {
+      const label = prefix + suffix;
+      const normalizedLabel = normalizeLabel(label);
+      const matchKey = values.has(normalizedLabel) ? normalizedLabel : values.has(normalizeLabel(prefix)) ? normalizeLabel(prefix) : void 0;
+      if (matchKey === void 0) return match;
+      const newValue = values.get(matchKey);
+      matchedLabels.add(matchKey);
+      matches.push({ key: matchKey, label, value: newValue });
+      return `${prefix}(${newValue})${suffix}`;
+    }
+  );
+  text = text.replace(
+    /□([가-힣A-Za-z]+)/g,
+    (match, keyword) => {
+      const normalizedKw = normalizeLabel(keyword);
+      const matchKey = values.has(normalizedKw) ? normalizedKw : void 0;
+      if (matchKey === void 0) return match;
+      const val = values.get(matchKey);
+      const isTruthy = ["\u2611", "\u2713", "\u2714", "v", "V", "true", "1", "yes", "o", "O"].includes(val.trim()) || val.trim() === "";
+      if (!isTruthy) return match;
+      matchedLabels.add(matchKey);
+      matches.push({ key: matchKey, label: `\u25A1${keyword}`, value: "\u2611" });
+      return `\u2611${keyword}`;
+    }
+  );
+  text = text.replace(
+    /\(([가-힣A-Za-z]+)[:：]\s{1,}\)/g,
+    (match, keyword) => {
+      const normalizedKw = normalizeLabel(keyword);
+      const matchKey = values.has(normalizedKw) ? normalizedKw : void 0;
+      if (matchKey === void 0) return match;
+      const newValue = values.get(matchKey);
+      matchedLabels.add(matchKey);
+      matches.push({ key: matchKey, label: keyword, value: newValue });
+      return `(${keyword}\uFF1A${newValue})`;
+    }
+  );
+  return matches.length > 0 ? { text, matches } : null;
+}
+function normalizeValues(values) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [label, value] of Object.entries(values)) {
+    map.set(normalizeLabel(label), value);
+  }
+  return map;
+}
+function resolveUnmatched(normalizedValues, matchedLabels, originalValues) {
+  return [...normalizedValues.keys()].filter((k) => !matchedLabels.has(k)).map((k) => {
+    for (const orig of Object.keys(originalValues)) {
+      if (normalizeLabel(orig) === k) return orig;
+    }
+    return k;
+  });
+}
+
+// src/form/filler.ts
+function fillFormFields(blocks, values) {
+  const cloned = structuredClone(blocks);
+  const filled = [];
+  const matchedLabels = /* @__PURE__ */ new Set();
+  const normalizedValues = normalizeValues(values);
+  const patternFilledCells = /* @__PURE__ */ new Set();
+  for (const block of cloned) {
+    if (block.type !== "table" || !block.table) continue;
+    for (let r = 0; r < block.table.rows; r++) {
+      for (let c = 0; c < block.table.cols; c++) {
+        const cell = block.table.cells[r]?.[c];
+        if (!cell) continue;
+        const result = fillInCellPatterns(cell.text, normalizedValues, matchedLabels);
+        if (result) {
+          cell.text = result.text;
+          patternFilledCells.add(`${r},${c}`);
+          for (const m of result.matches) {
+            filled.push({ label: m.label, value: m.value, row: r, col: c });
+          }
+        }
+      }
+    }
+  }
+  for (const block of cloned) {
+    if (block.type !== "table" || !block.table) continue;
+    fillTable(block.table, normalizedValues, filled, matchedLabels, patternFilledCells);
+  }
+  for (const block of cloned) {
+    if (block.type !== "paragraph" || !block.text) continue;
+    const newText = fillInlineFields(block.text, normalizedValues, filled, matchedLabels);
+    if (newText !== block.text) block.text = newText;
+  }
+  const unmatched = resolveUnmatched(normalizedValues, matchedLabels, values);
+  return { blocks: cloned, filled, unmatched };
+}
+function fillTable(table, values, filled, matchedLabels, patternFilledCells) {
+  if (table.cols < 2) return;
+  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 (!labelCell || !valueCell) continue;
+      if (!isLabelCell(labelCell.text)) continue;
+      if (isKeywordLabel(valueCell.text)) continue;
+      const normalizedCellLabel = normalizeLabel(labelCell.text);
+      if (!normalizedCellLabel) continue;
+      const matchKey = findMatchingKey(normalizedCellLabel, values);
+      if (matchKey === void 0) continue;
+      const newValue = values.get(matchKey);
+      if (patternFilledCells?.has(`${r},${c + 1}`)) {
+        valueCell.text = newValue + " " + valueCell.text;
+      } else {
+        valueCell.text = newValue;
+      }
+      matchedLabels.add(matchKey);
+      filled.push({
+        label: labelCell.text.trim().replace(/[:：]\s*$/, ""),
+        value: newValue,
+        row: r,
+        col: c
+      });
+    }
+  }
+  if (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 && isLabelCell(t);
+    });
+    if (!allLabels) return;
+    for (let r = 1; r < table.rows; r++) {
+      for (let c = 0; c < table.cols; c++) {
+        const headerLabel = normalizeLabel(headerRow[c].text);
+        const matchKey = findMatchingKey(headerLabel, values);
+        if (matchKey === void 0) continue;
+        if (matchedLabels.has(matchKey)) continue;
+        const newValue = values.get(matchKey);
+        table.cells[r][c].text = newValue;
+        matchedLabels.add(matchKey);
+        filled.push({
+          label: headerRow[c].text.trim(),
+          value: newValue,
+          row: r,
+          col: c
+        });
+      }
+    }
+  }
+}
+function fillInlineFields(text, values, filled, matchedLabels) {
+  return text.replace(
+    /([가-힣A-Za-z]{2,10})\s*[:：]\s*([^\n,;]{0,100})/g,
+    (match, rawLabel, _oldValue) => {
+      const normalized = normalizeLabel(rawLabel);
+      const matchKey = findMatchingKey(normalized, values);
+      if (matchKey === void 0) return match;
+      const newValue = values.get(matchKey);
+      matchedLabels.add(matchKey);
+      filled.push({
+        label: rawLabel.trim(),
+        value: newValue,
+        row: -1,
+        col: -1
+      });
+      return `${rawLabel}: ${newValue}`;
+    }
+  );
+}
+
+// src/form/filler-hwpx.ts
+var import_jszip5 = __toESM(require("jszip"), 1);
+var import_xmldom4 = require("@xmldom/xmldom");
+async function fillHwpx(hwpxBuffer, values) {
+  const zip = await import_jszip5.default.loadAsync(hwpxBuffer);
+  const filled = [];
+  const matchedLabels = /* @__PURE__ */ new Set();
+  const normalizedValues = normalizeValues(values);
+  const sectionFiles = Object.keys(zip.files).filter((name) => /[Ss]ection\d+\.xml$/i.test(name)).sort();
+  if (sectionFiles.length === 0) {
+    throw new KordocError("HWPX\uC5D0\uC11C \uC139\uC158 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  }
+  const xmlParser = new import_xmldom4.DOMParser();
+  const xmlSerializer = new import_xmldom4.XMLSerializer();
+  for (const sectionPath of sectionFiles) {
+    const zipEntry = zip.file(sectionPath);
+    if (!zipEntry) continue;
+    const rawXml = await zipEntry.async("text");
+    const doc = xmlParser.parseFromString(stripDtd(rawXml), "text/xml");
+    if (!doc.documentElement) continue;
+    let modified = false;
+    const tables = findAllElements(doc.documentElement, "tbl");
+    const cellPatternApplied = /* @__PURE__ */ new Set();
+    for (const tblEl of tables) {
+      const allCells = findAllElements(tblEl, "tc");
+      for (const tcEl of allCells) {
+        const tNodes = collectCellTextNodes(tcEl);
+        const fullText = tNodes.map((n) => n.text).join("");
+        const result = fillInCellPatterns(fullText, normalizedValues, matchedLabels);
+        if (!result) continue;
+        applyTextReplacements(tNodes, fullText, result.text);
+        cellPatternApplied.add(tcEl);
+        for (const m of result.matches) {
+          filled.push({ label: m.label, value: m.value, row: -1, col: -1 });
+        }
+        modified = true;
+      }
+    }
+    for (const tblEl of tables) {
+      const rows = findDirectChildren(tblEl, "tr");
+      for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+        const trEl = rows[rowIdx];
+        const cells = findDirectChildren(trEl, "tc");
+        for (let colIdx = 0; colIdx < cells.length - 1; colIdx++) {
+          const labelText = extractCellText(cells[colIdx]);
+          if (!isLabelCell(labelText)) continue;
+          const valueCell = cells[colIdx + 1];
+          const valueText = extractCellText(valueCell);
+          if (isKeywordLabel(valueText)) continue;
+          const normalizedCellLabel = normalizeLabel(labelText);
+          if (!normalizedCellLabel) continue;
+          const matchKey = findMatchingKey(normalizedCellLabel, normalizedValues);
+          if (matchKey === void 0) continue;
+          const newValue = normalizedValues.get(matchKey);
+          if (cellPatternApplied.has(valueCell)) {
+            prependCellText(valueCell, newValue);
+          } else {
+            replaceCellText(valueCell, newValue);
+          }
+          matchedLabels.add(matchKey);
+          filled.push({
+            label: labelText.trim().replace(/[:：]\s*$/, ""),
+            value: newValue,
+            row: rowIdx,
+            col: colIdx
+          });
+          modified = true;
+        }
+      }
+      if (rows.length >= 2) {
+        const headerCells = findDirectChildren(rows[0], "tc");
+        const allLabels = headerCells.every((cell) => {
+          const t = extractCellText(cell).trim();
+          return t.length > 0 && t.length <= 20 && isLabelCell(t);
+        });
+        if (allLabels) {
+          for (let rowIdx = 1; rowIdx < rows.length; rowIdx++) {
+            const dataCells = findDirectChildren(rows[rowIdx], "tc");
+            for (let colIdx = 0; colIdx < Math.min(headerCells.length, dataCells.length); colIdx++) {
+              const headerLabel = normalizeLabel(extractCellText(headerCells[colIdx]));
+              const matchKey = findMatchingKey(headerLabel, normalizedValues);
+              if (matchKey === void 0) continue;
+              if (matchedLabels.has(matchKey)) continue;
+              const newValue = normalizedValues.get(matchKey);
+              replaceCellText(dataCells[colIdx], newValue);
+              matchedLabels.add(matchKey);
+              filled.push({
+                label: extractCellText(headerCells[colIdx]).trim(),
+                value: newValue,
+                row: rowIdx,
+                col: colIdx
+              });
+              modified = true;
+            }
+          }
+        }
+      }
+    }
+    const allParagraphs = findAllElements(doc.documentElement, "p");
+    for (const pEl of allParagraphs) {
+      if (isInsideTable(pEl)) continue;
+      const tNodes = collectTextNodes(pEl);
+      const fullText = tNodes.map((n) => n.text).join("");
+      const pattern = /([가-힣A-Za-z]{2,10})\s*[:：]\s*([^\n,;]{0,100})/g;
+      let match;
+      while ((match = pattern.exec(fullText)) !== null) {
+        const rawLabel = match[1];
+        const normalized = normalizeLabel(rawLabel);
+        const matchKey = findMatchingKey(normalized, normalizedValues);
+        if (matchKey === void 0) continue;
+        const newValue = normalizedValues.get(matchKey);
+        const valueStart = match.index + match[0].length - match[2].length;
+        const valueEnd = match.index + match[0].length;
+        replaceTextRange(tNodes, valueStart, valueEnd, newValue);
+        matchedLabels.add(matchKey);
+        filled.push({ label: rawLabel.trim(), value: newValue, row: -1, col: -1 });
+        modified = true;
+        break;
+      }
+    }
+    if (modified) {
+      const newXml = xmlSerializer.serializeToString(doc);
+      zip.file(sectionPath, newXml);
+    }
+  }
+  const unmatched = resolveUnmatched(normalizedValues, matchedLabels, values);
+  const buffer = await zip.generateAsync({ type: "arraybuffer" });
+  return { buffer, filled, unmatched };
+}
+function localName(el) {
+  return (el.tagName || el.localName || "").replace(/^[^:]+:/, "");
+}
+function findAllElements(node, tagLocalName) {
+  const result = [];
+  const walk = (n) => {
+    const children = n.childNodes;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType !== 1) continue;
+      if (localName(child) === tagLocalName) result.push(child);
+      walk(child);
+    }
+  };
+  walk(node);
+  return result;
+}
+function findDirectChildren(parent, tagLocalName) {
+  const result = [];
+  const children = parent.childNodes;
+  if (!children) return result;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (child.nodeType === 1 && localName(child) === tagLocalName) {
+      result.push(child);
+    }
+  }
+  return result;
+}
+function isInsideTable(el) {
+  let parent = el.parentNode;
+  while (parent) {
+    if (parent.nodeType === 1 && localName(parent) === "tbl") return true;
+    parent = parent.parentNode;
+  }
+  return false;
+}
+function extractCellText(tcEl) {
+  const parts = [];
+  const walk = (node) => {
+    const children = node.childNodes;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType === 3) {
+        parts.push(child.textContent || "");
+      } else if (child.nodeType === 1) {
+        const tag = localName(child);
+        if (tag === "t") walk(child);
+        else if (tag === "run" || tag === "r" || tag === "p" || tag === "subList") walk(child);
+        else if (tag === "tab") parts.push("	");
+        else if (tag === "br") parts.push("\n");
+      }
+    }
+  };
+  walk(tcEl);
+  return parts.join("");
+}
+function prependCellText(tcEl, text) {
+  const tElements = findAllElements(tcEl, "t");
+  if (tElements.length === 0) return;
+  const firstT = tElements[0];
+  const existing = firstT.textContent || "";
+  clearChildren(firstT);
+  firstT.appendChild(firstT.ownerDocument.createTextNode(text + " " + existing));
+}
+function replaceCellText(tcEl, newValue) {
+  const paragraphs = findAllElements(tcEl, "p");
+  if (paragraphs.length === 0) return;
+  const firstP = paragraphs[0];
+  const runs = findAllElements(firstP, "run").concat(findAllElements(firstP, "r"));
+  if (runs.length > 0) {
+    setRunText(runs[0], newValue);
+    for (let i = 1; i < runs.length; i++) {
+      setRunText(runs[i], "");
+    }
+  } else {
+    const tElements = findAllElements(firstP, "t");
+    if (tElements.length > 0) {
+      clearChildren(tElements[0]);
+      tElements[0].appendChild(tElements[0].ownerDocument.createTextNode(newValue));
+      for (let i = 1; i < tElements.length; i++) {
+        clearChildren(tElements[i]);
+      }
+    }
+  }
+  for (let i = 1; i < paragraphs.length; i++) {
+    const p = paragraphs[i];
+    if (p.parentNode) {
+      const pRuns = findAllElements(p, "run").concat(findAllElements(p, "r"));
+      for (const run of pRuns) setRunText(run, "");
+      const pTs = findAllElements(p, "t");
+      for (const t of pTs) clearChildren(t);
+    }
+  }
 }
-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
-          });
-        }
-      }
+function setRunText(runEl, text) {
+  const tElements = findAllElements(runEl, "t");
+  if (tElements.length > 0) {
+    clearChildren(tElements[0]);
+    tElements[0].appendChild(tElements[0].ownerDocument.createTextNode(text));
+    for (let i = 1; i < tElements.length; i++) {
+      clearChildren(tElements[i]);
     }
   }
-  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 });
-          }
-        }
-      }
-    }
+}
+function clearChildren(el) {
+  while (el.firstChild) el.removeChild(el.firstChild);
+}
+function collectTextNodes(pEl) {
+  const tElements = findAllElements(pEl, "t");
+  const result = [];
+  let offset = 0;
+  for (const t of tElements) {
+    const text = t.textContent || "";
+    result.push({ element: t, text, offset });
+    offset += text.length;
   }
-  return fields;
+  return result;
 }
-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 });
+function replaceTextRange(tNodes, globalStart, globalEnd, newValue) {
+  let replaced = false;
+  for (const node of tNodes) {
+    const nodeStart = node.offset;
+    const nodeEnd = node.offset + node.text.length;
+    if (nodeEnd <= globalStart || nodeStart >= globalEnd) continue;
+    const localStart = Math.max(0, globalStart - nodeStart);
+    const localEnd = Math.min(node.text.length, globalEnd - nodeStart);
+    if (!replaced) {
+      const before = node.text.slice(0, localStart);
+      const after = node.text.slice(localEnd);
+      const newText = before + newValue + after;
+      clearChildren(node.element);
+      node.element.appendChild(node.element.ownerDocument.createTextNode(newText));
+      replaced = true;
+    } else {
+      const before = node.text.slice(0, localStart);
+      const after = node.text.slice(localEnd);
+      const newText = before + after;
+      clearChildren(node.element);
+      node.element.appendChild(node.element.ownerDocument.createTextNode(newText));
     }
   }
-  return fields;
+}
+function collectCellTextNodes(tcEl) {
+  const tElements = findAllElements(tcEl, "t");
+  const result = [];
+  let offset = 0;
+  for (const t of tElements) {
+    const text = t.textContent || "";
+    result.push({ element: t, text, offset });
+    offset += text.length;
+  }
+  return result;
+}
+function applyTextReplacements(tNodes, originalFull, replacedFull) {
+  if (originalFull === replacedFull) return;
+  if (tNodes.length === 1) {
+    clearChildren(tNodes[0].element);
+    tNodes[0].element.appendChild(
+      tNodes[0].element.ownerDocument.createTextNode(replacedFull)
+    );
+    return;
+  }
+  let diffStart = 0;
+  while (diffStart < originalFull.length && diffStart < replacedFull.length && originalFull[diffStart] === replacedFull[diffStart]) {
+    diffStart++;
+  }
+  let diffEndOrig = originalFull.length;
+  let diffEndRepl = replacedFull.length;
+  while (diffEndOrig > diffStart && diffEndRepl > diffStart && originalFull[diffEndOrig - 1] === replacedFull[diffEndRepl - 1]) {
+    diffEndOrig--;
+    diffEndRepl--;
+  }
+  const newPart = replacedFull.slice(diffStart, diffEndRepl);
+  replaceTextRange(tNodes, diffStart, diffEndOrig, newPart);
 }
 
 // src/hwpx/generator.ts
-var import_jszip5 = __toESM(require("jszip"), 1);
+var import_jszip6 = __toESM(require("jszip"), 1);
 var NS_SECTION = "http://www.hancom.co.kr/hwpml/2011/section";
 var NS_PARA = "http://www.hancom.co.kr/hwpml/2011/paragraph";
 var NS_HEAD = "http://www.hancom.co.kr/hwpml/2011/head";
@@ -6364,7 +6705,7 @@ var PARA_LIST = 7;
 async function markdownToHwpx(markdown) {
   const blocks = parseMarkdownToBlocks(markdown);
   const sectionXml = blocksToSectionXml(blocks);
-  const zip = new import_jszip5.default();
+  const zip = new import_jszip6.default();
   zip.file("mimetype", "application/hwp+zip", { compression: "STORE" });
   zip.file("META-INF/container.xml", generateContainerXml());
   zip.file("Contents/content.hpf", generateManifest());
@@ -6724,6 +7065,183 @@ function blocksToSectionXml(blocks) {
 </hs:sec>`;
 }
 
+// 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();
+}
+var MAX_LEVENSHTEIN_LEN = 1e4;
+function levenshtein(a, b) {
+  if (a.length + b.length > MAX_LEVENSHTEIN_LEN) {
+    const sampleLen = Math.min(500, a.length, b.length);
+    let diffs = 0;
+    for (let i = 0; i < sampleLen; i++) if (a[i] !== b[i]) diffs++;
+    const sampleRate = sampleLen > 0 ? diffs / sampleLen : 1;
+    return Math.abs(a.length - b.length) + Math.round(Math.min(a.length, b.length) * sampleRate);
+  }
+  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.text !== void 0 && b.text !== void 0) {
+    return normalizedSimilarity(a.text || "", b.text || "");
+  }
+  if (a.type === "table" && a.table && b.table) {
+    return tableSimilarity(a.table, b.table);
+  }
+  if (a.type === b.type) return 1;
+  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/index.ts
 async function parse(input, options) {
   let buffer;
@@ -6800,6 +7318,45 @@ async function parseDocx(buffer, options) {
     return { success: false, fileType: "docx", error: err instanceof Error ? err.message : "DOCX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
+async function fillForm(input, values, outputFormat = "markdown") {
+  let buffer;
+  if (typeof input === "string") {
+    const buf = await (0, import_promises.readFile)(input);
+    buffer = toArrayBuffer(buf);
+  } else if (Buffer.isBuffer(input)) {
+    buffer = toArrayBuffer(input);
+  } else {
+    buffer = input;
+  }
+  if (outputFormat === "hwpx-preserve") {
+    const format = detectFormat(buffer);
+    if (format === "hwpx") {
+      const zipFormat = await detectZipFormat(buffer);
+      if (zipFormat !== "hwpx") {
+        throw new Error(`hwpx-preserve \uD3EC\uB9F7\uC740 HWPX \uC785\uB825\uB9CC \uC9C0\uC6D0\uD569\uB2C8\uB2E4 (\uAC10\uC9C0\uB41C \uD3EC\uB9F7: ${zipFormat})`);
+      }
+    } else {
+      throw new Error(`hwpx-preserve \uD3EC\uB9F7\uC740 HWPX \uC785\uB825\uB9CC \uC9C0\uC6D0\uD569\uB2C8\uB2E4 (\uAC10\uC9C0\uB41C \uD3EC\uB9F7: ${format})`);
+    }
+    const hwpxResult = await fillHwpx(buffer, values);
+    return {
+      output: hwpxResult.buffer,
+      format: "hwpx-preserve",
+      fill: { filled: hwpxResult.filled, unmatched: hwpxResult.unmatched }
+    };
+  }
+  const parsed = await parse(buffer);
+  if (!parsed.success) {
+    throw new Error(`\uC11C\uC2DD \uD30C\uC2F1 \uC2E4\uD328: ${parsed.error}`);
+  }
+  const fill = fillFormFields(parsed.blocks, values);
+  const markdown = blocksToMarkdown(fill.blocks);
+  if (outputFormat === "hwpx") {
+    const hwpxBuffer = await markdownToHwpx(markdown);
+    return { output: hwpxBuffer, format: "hwpx", fill };
+  }
+  return { output: markdown, format: "markdown", fill };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   VERSION,
@@ -6809,7 +7366,11 @@ async function parseDocx(buffer, options) {
   detectZipFormat,
   diffBlocks,
   extractFormFields,
+  fillForm,
+  fillFormFields,
+  fillHwpx,
   isHwpxFile,
+  isLabelCell,
   isOldHwpFile,
   isPdfFile,
   isZipFile,