kordoc 2.2.3 → 2.2.5

package/dist/{chunk-AIG7SDWU.js → chunk-RQWICKON.js}

@@ -3,448 +3,32 @@ import {
   detectFormat,
   detectZipFormat
 } from "./chunk-5Y2Q3BRW.js";
+import {
+  HEADING_RATIO_H1,
+  HEADING_RATIO_H2,
+  HEADING_RATIO_H3,
+  KordocError,
+  MAX_COLS,
+  MAX_ROWS,
+  blocksToMarkdown,
+  buildTable,
+  classifyError,
+  convertTableToText,
+  flattenLayoutTables,
+  isPathTraversal,
+  precheckZipSize,
+  sanitizeHref,
+  stripDtd,
+  toArrayBuffer
+} from "./chunk-JH5XLWJQ.js";
 import {
   parsePageRange
 } from "./chunk-MOL7MDBG.js";
 
-// src/utils.ts
-var VERSION = true ? "2.2.3" : "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 {
-  constructor(message) {
-    super(message);
-    this.name = "KordocError";
-  }
-};
-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, "/");
-  const segments = normalized.split("/");
-  return segments.some((s) => s === "..") || 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 stripDtd(xml) {
-  return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
-}
-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 safeMin(arr) {
-  let min = Infinity;
-  for (let i = 0; i < arr.length; i++) if (arr[i] < min) min = arr[i];
-  return min;
-}
-function safeMax(arr) {
-  let max = -Infinity;
-  for (let i = 0; i < arr.length; i++) if (arr[i] > max) max = arr[i];
-  return max;
-}
-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/table/builder.ts
-var MAX_COLS = 200;
-var MAX_ROWS = 1e4;
-function buildTable(rows) {
-  if (rows.length > MAX_ROWS) rows = rows.slice(0, MAX_ROWS);
-  const numRows = rows.length;
-  const hasAddr = rows.some((row) => row.some((c) => c.colAddr !== void 0 && c.rowAddr !== void 0));
-  if (hasAddr) return buildTableDirect(rows, numRows);
-  let maxCols = 0;
-  const tempOccupied = Array.from({ length: numRows }, () => []);
-  for (let rowIdx = 0; rowIdx < numRows; rowIdx++) {
-    let colIdx = 0;
-    for (const cell of rows[rowIdx]) {
-      while (colIdx < MAX_COLS && tempOccupied[rowIdx][colIdx]) colIdx++;
-      if (colIdx >= MAX_COLS) break;
-      for (let r = rowIdx; r < Math.min(rowIdx + cell.rowSpan, numRows); r++) {
-        for (let c = colIdx; c < Math.min(colIdx + cell.colSpan, MAX_COLS); c++) {
-          tempOccupied[r][c] = true;
-        }
-      }
-      colIdx += cell.colSpan;
-      if (colIdx > maxCols) maxCols = colIdx;
-    }
-  }
-  if (maxCols === 0) return { rows: 0, cols: 0, cells: [], hasHeader: false };
-  const grid = Array.from(
-    { length: numRows },
-    () => Array.from({ length: maxCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
-  );
-  const occupied = Array.from({ length: numRows }, () => Array(maxCols).fill(false));
-  for (let rowIdx = 0; rowIdx < numRows; rowIdx++) {
-    let colIdx = 0;
-    let cellIdx = 0;
-    while (colIdx < maxCols && cellIdx < rows[rowIdx].length) {
-      while (colIdx < maxCols && occupied[rowIdx][colIdx]) colIdx++;
-      if (colIdx >= maxCols) break;
-      const cell = rows[rowIdx][cellIdx];
-      grid[rowIdx][colIdx] = {
-        text: cell.text.trim(),
-        colSpan: cell.colSpan,
-        rowSpan: cell.rowSpan
-      };
-      for (let r = rowIdx; r < Math.min(rowIdx + cell.rowSpan, numRows); r++) {
-        for (let c = colIdx; c < Math.min(colIdx + cell.colSpan, maxCols); c++) {
-          occupied[r][c] = true;
-        }
-      }
-      colIdx += cell.colSpan;
-      cellIdx++;
-    }
-  }
-  return trimAndReturn(grid, numRows, maxCols);
-}
-function buildTableDirect(rows, numRows) {
-  let maxCols = 0;
-  for (const row of rows) {
-    for (const cell of row) {
-      const end = (cell.colAddr ?? 0) + cell.colSpan;
-      if (end > maxCols) maxCols = end;
-    }
-  }
-  if (maxCols > MAX_COLS) maxCols = MAX_COLS;
-  if (maxCols === 0) return { rows: 0, cols: 0, cells: [], hasHeader: false };
-  const grid = Array.from(
-    { length: numRows },
-    () => Array.from({ length: maxCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
-  );
-  for (const row of rows) {
-    for (const cell of row) {
-      const r = cell.rowAddr ?? 0;
-      const c = cell.colAddr ?? 0;
-      if (r >= numRows || c >= maxCols || r < 0 || c < 0) continue;
-      grid[r][c] = { text: cell.text.trim(), colSpan: cell.colSpan, rowSpan: cell.rowSpan };
-      for (let dr = 0; dr < cell.rowSpan; dr++) {
-        for (let dc = 0; dc < cell.colSpan; dc++) {
-          if (dr === 0 && dc === 0) continue;
-          if (r + dr < numRows && c + dc < maxCols) {
-            grid[r + dr][c + dc] = { text: "", colSpan: 1, rowSpan: 1 };
-          }
-        }
-      }
-    }
-  }
-  return trimAndReturn(grid, numRows, maxCols);
-}
-function trimAndReturn(grid, numRows, maxCols) {
-  let effectiveCols = maxCols;
-  while (effectiveCols > 0) {
-    const colEmpty = grid.every((row) => !row[effectiveCols - 1]?.text?.trim());
-    if (!colEmpty) break;
-    effectiveCols--;
-  }
-  if (effectiveCols < maxCols && effectiveCols > 0) {
-    const trimmed = grid.map((row) => row.slice(0, effectiveCols));
-    return { rows: numRows, cols: effectiveCols, cells: trimmed, hasHeader: numRows > 1 };
-  }
-  return { rows: numRows, cols: maxCols, cells: grid, hasHeader: numRows > 1 };
-}
-function convertTableToText(rows) {
-  return rows.map(
-    (row) => row.map((c) => c.text.trim().replace(/\n/g, " ").replace(/\|/g, "\\|")).filter(Boolean).join(" / ")
-  ).filter(Boolean).join("\n");
-}
-function escapeGfm(text) {
-  return text.replace(/~/g, "\\~");
-}
-var HWP_SHAPE_ALT_TEXT_RE = /(?:모서리가 둥근 |둥근 )?(?:사각형|직사각형|정사각형|원|타원|삼각형|이등변 삼각형|직각 삼각형|선|직선|곡선|화살표|굵은 화살표|이중 화살표|오각형|육각형|팔각형|별|[4-8]점별|십자|십자형|구름|구름형|마름모|도넛|평행사변형|사다리꼴|부채꼴|호|반원|물결|번개|하트|빗금|블록 화살표|수식|표|그림|개체|그리기\s?개체|묶음\s?개체|글상자|수식\s?개체|OLE\s?개체)\s?입니다\.?/g;
-function sanitizeText(text) {
-  let result = text.replace(/[\u{F0000}-\u{FFFFD}]/gu, "").replace(HWP_SHAPE_ALT_TEXT_RE, "").replace(/  +/g, " ").trim();
-  if (result.length <= 30 && result.includes(" ")) {
-    const tokens = result.split(" ");
-    const koreanSingleCharCount = tokens.filter((t) => t.length === 1 && /[\uAC00-\uD7AF\u3131-\u318E]/.test(t)).length;
-    if (tokens.length >= 3 && koreanSingleCharCount / tokens.length >= 0.7) {
-      result = tokens.join("");
-    }
-  }
-  return result;
-}
-function flattenLayoutTables(blocks) {
-  const result = [];
-  for (const block of blocks) {
-    if (block.type !== "table" || !block.table) {
-      result.push(block);
-      continue;
-    }
-    const { rows: numRows, cols: numCols, cells } = block.table;
-    if (numRows === 1 && numCols === 1) {
-      result.push(block);
-      continue;
-    }
-    if (numRows <= 3) {
-      let totalNewlines = 0;
-      let totalTextLen = 0;
-      for (let r = 0; r < numRows; r++) {
-        for (let c = 0; c < numCols; c++) {
-          const t = cells[r]?.[c]?.text || "";
-          totalNewlines += (t.match(/\n/g) || []).length;
-          totalTextLen += t.length;
-        }
-      }
-      if (totalNewlines > 5 || numRows <= 2 && totalTextLen > 300) {
-        for (let r = 0; r < numRows; r++) {
-          for (let c = 0; c < numCols; c++) {
-            const cellText = cells[r]?.[c]?.text?.trim();
-            if (!cellText) continue;
-            for (const line of cellText.split("\n")) {
-              const trimmed = line.trim();
-              if (!trimmed) continue;
-              result.push({ type: "paragraph", text: trimmed, pageNumber: block.pageNumber });
-            }
-          }
-        }
-        continue;
-      }
-    }
-    result.push(block);
-  }
-  return result;
-}
-function blocksToMarkdown(blocks) {
-  const lines = [];
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (block.type === "heading" && block.text) {
-      const prefix = "#".repeat(Math.min(block.level || 2, 6));
-      const headingText = sanitizeText(block.text);
-      if (headingText) lines.push("", `${prefix} ${headingText}`, "");
-      continue;
-    }
-    if (block.type === "image" && block.text) {
-      lines.push("", `![image](${block.text})`, "");
-      continue;
-    }
-    if (block.type === "separator") {
-      lines.push("", "---", "");
-      continue;
-    }
-    if (block.type === "list" && block.text) {
-      const listText = sanitizeText(block.text);
-      if (!listText) continue;
-      const alreadyNumbered = block.listType === "ordered" && /^\d+\.\s/.test(listText);
-      const prefix = alreadyNumbered ? "" : block.listType === "ordered" ? "1. " : "- ";
-      lines.push(`${prefix}${listText}`);
-      if (block.children) {
-        for (const child of block.children) {
-          const childPrefix = child.listType === "ordered" ? "1." : "-";
-          lines.push(`  ${childPrefix} ${child.text || ""}`);
-        }
-      }
-      continue;
-    }
-    if (block.type === "paragraph" && block.text) {
-      let text = sanitizeText(block.text);
-      if (!text) continue;
-      if (/^\[별표\s*\d+/.test(text)) {
-        const nextBlock = blocks[i + 1];
-        if (nextBlock?.type === "paragraph" && nextBlock.text && /관련\)?$/.test(nextBlock.text)) {
-          lines.push("", `## ${text} ${nextBlock.text}`, "");
-          i++;
-        } else {
-          lines.push("", `## ${text}`, "");
-        }
-        continue;
-      }
-      if (/^\([^)]*조[^)]*관련\)$/.test(text)) {
-        lines.push(`*${text}*`, "");
-        continue;
-      }
-      if (block.href) {
-        const href = sanitizeHref(block.href);
-        if (href) text = `[${text}](${href})`;
-      }
-      if (block.footnoteText) {
-        text += ` (\uC8FC: ${block.footnoteText})`;
-      }
-      lines.push(escapeGfm(text), "");
-    } else if (block.type === "table" && block.table) {
-      if (lines.length > 0 && lines[lines.length - 1] !== "") {
-        lines.push("");
-      }
-      const tableMd = tableToMarkdown(block.table);
-      if (tableMd) {
-        lines.push(tableMd);
-        lines.push("");
-      }
-    }
-  }
-  return lines.join("\n").trim();
-}
-function hasMergedCells(table) {
-  for (const row of table.cells) {
-    for (const cell of row) {
-      if (cell.colSpan > 1 || cell.rowSpan > 1) return true;
-    }
-  }
-  return false;
-}
-function tableToHtml(table) {
-  const { cells, rows: numRows, cols: numCols } = table;
-  const skip = /* @__PURE__ */ new Set();
-  const lines = ["<table>"];
-  for (let r = 0; r < numRows; r++) {
-    const tag = r === 0 ? "th" : "td";
-    const rowHtml = [];
-    for (let c = 0; c < numCols; c++) {
-      if (skip.has(`${r},${c}`)) continue;
-      const cell = cells[r]?.[c];
-      if (!cell) continue;
-      for (let dr = 0; dr < cell.rowSpan; dr++) {
-        for (let dc = 0; dc < cell.colSpan; dc++) {
-          if (dr === 0 && dc === 0) continue;
-          if (r + dr < numRows && c + dc < numCols) skip.add(`${r + dr},${c + dc}`);
-        }
-      }
-      const text = sanitizeText(cell.text).replace(/\n/g, "<br>");
-      const attrs = [];
-      if (cell.colSpan > 1) attrs.push(`colspan="${cell.colSpan}"`);
-      if (cell.rowSpan > 1) attrs.push(`rowspan="${cell.rowSpan}"`);
-      const attrStr = attrs.length ? " " + attrs.join(" ") : "";
-      rowHtml.push(`<${tag}${attrStr}>${text}</${tag}>`);
-    }
-    if (rowHtml.length) lines.push(`<tr>${rowHtml.join("")}</tr>`);
-  }
-  lines.push("</table>");
-  return lines.join("\n");
-}
-function tableToMarkdown(table) {
-  if (table.rows === 0 || table.cols === 0) return "";
-  const { cells, rows: numRows, cols: numCols } = table;
-  if (hasMergedCells(table)) return tableToHtml(table);
-  if (numRows === 1 && numCols === 1) {
-    const content = sanitizeText(cells[0][0].text);
-    if (!content) return "";
-    return content.split(/\n/).map((line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return "";
-      if (/^\d+\.\s/.test(trimmed)) return `**${escapeGfm(trimmed)}**`;
-      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${escapeGfm(trimmed)}`;
-      return escapeGfm(trimmed);
-    }).filter(Boolean).join("\n");
-  }
-  if (numCols === 1 && numRows >= 2) {
-    return cells.map((row) => escapeGfm(sanitizeText(row[0].text)).replace(/\n/g, " ")).filter(Boolean).join("\n");
-  }
-  const display = Array.from({ length: numRows }, () => Array(numCols).fill(""));
-  const skip = /* @__PURE__ */ new Set();
-  for (let r = 0; r < numRows; r++) {
-    for (let c = 0; c < numCols; c++) {
-      if (skip.has(`${r},${c}`)) continue;
-      const cell = cells[r]?.[c];
-      if (!cell) continue;
-      display[r][c] = escapeGfm(sanitizeText(cell.text)).replace(/\|/g, "\\|").replace(/\n/g, "<br>");
-      for (let dr = 0; dr < cell.rowSpan; dr++) {
-        for (let dc = 0; dc < cell.colSpan; dc++) {
-          if (dr === 0 && dc === 0) continue;
-          if (r + dr < numRows && c + dc < numCols) {
-            skip.add(`${r + dr},${c + dc}`);
-          }
-        }
-      }
-      c += cell.colSpan - 1;
-    }
-  }
-  const uniqueRows = [];
-  let pendingFirstCol = "";
-  for (let r = 0; r < display.length; r++) {
-    const row = display[r];
-    const isEmptyPlaceholder = row.every((cell) => cell === "");
-    if (isEmptyPlaceholder) continue;
-    const nonEmptyCols = row.filter((cell) => cell !== "");
-    const hasSkipInRow = row.some((_, c) => skip.has(`${r},${c}`));
-    if (!hasSkipInRow && nonEmptyCols.length === 1 && row[0] !== "" && row.slice(1).every((c) => c === "")) {
-      pendingFirstCol = row[0];
-      continue;
-    }
-    if (pendingFirstCol && row[0] === "") {
-      row[0] = pendingFirstCol;
-      pendingFirstCol = "";
-    } else {
-      pendingFirstCol = "";
-    }
-    uniqueRows.push(row);
-  }
-  if (uniqueRows.length === 0) return "";
-  const md = [];
-  md.push("| " + uniqueRows[0].join(" | ") + " |");
-  md.push("| " + uniqueRows[0].map(() => "---").join(" | ") + " |");
-  for (let i = 1; i < uniqueRows.length; i++) {
-    md.push("| " + uniqueRows[i].join(" | ") + " |");
-  }
-  return md.join("\n");
-}
-
 // src/hwpx/parser.ts
 import JSZip from "jszip";
 import { inflateRawSync } from "zlib";
 import { DOMParser } from "@xmldom/xmldom";
-
-// src/types.ts
-var HEADING_RATIO_H1 = 1.5;
-var HEADING_RATIO_H2 = 1.3;
-var HEADING_RATIO_H3 = 1.15;
-
-// src/hwpx/parser.ts
 var MAX_DECOMPRESS_SIZE = 100 * 1024 * 1024;
 var MAX_ZIP_ENTRIES = 500;
 function clampSpan(val, max) {
@@ -2929,2272 +2513,1040 @@ function arrangeCells(rows, cols, cells) {
   return grid.map((row) => row.map((c) => c || { text: "", colSpan: 1, rowSpan: 1 }));
 }
 
-// src/pdf/line-detector.ts
-import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
-var ORIENTATION_TOL = 2;
-var MIN_LINE_LENGTH = 15;
-var MAX_LINE_WIDTH = 5;
-var CONNECT_TOL = 5;
-var CELL_PADDING = 2;
-var MIN_COL_WIDTH = 15;
-var MIN_ROW_HEIGHT = 6;
-var VERTEX_MERGE_FACTOR = 4;
-var MIN_COORD_MERGE_TOL = 8;
-function extractLines(fnArray, argsArray) {
-  const horizontals = [];
-  const verticals = [];
-  let lineWidth = 1;
-  let currentPath = [];
-  let pathStartX = 0, pathStartY = 0;
-  let curX = 0, curY = 0;
-  function pushRectangle(path, rx, ry, rw, rh) {
-    if (Math.abs(rh) < ORIENTATION_TOL * 2) {
-      path.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
-    } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
-      path.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
-    } else {
-      path.push(
-        { x1: rx, y1: ry, x2: rx + rw, y2: ry },
-        { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
-        { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
-        { x1: rx, y1: ry + rh, x2: rx, y2: ry }
-      );
-    }
+// 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",
+  "\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().replace(/[¹²³⁴⁵⁶⁷⁸⁹⁰*※]+$/g, "").trim();
+  if (!trimmed || trimmed.length > 30) return false;
+  for (const kw of LABEL_KEYWORDS) {
+    if (trimmed.includes(kw)) return true;
   }
-  function flushPath(isStroke) {
-    if (!isStroke) {
-      currentPath = [];
-      return;
+  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;
+}
+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 seg of currentPath) {
-      classifyAndAdd(seg, lineWidth, horizontals, verticals);
+  }
+  for (const block of blocks) {
+    if (block.type === "paragraph" && block.text) {
+      const inlineFields = extractInlineFields(block.text);
+      fields.push(...inlineFields);
     }
-    currentPath = [];
   }
-  for (let i = 0; i < fnArray.length; i++) {
-    const op = fnArray[i];
-    const args = argsArray[i];
-    switch (op) {
-      case OPS.setLineWidth:
-        lineWidth = args[0] || 1;
-        break;
-      case OPS.constructPath: {
-        const arg0 = args[0];
-        if (Array.isArray(arg0)) {
-          const subOps = arg0;
-          const coords = args[1];
-          let ci = 0;
-          for (const subOp of subOps) {
-            if (subOp === OPS.moveTo) {
-              curX = coords[ci++];
-              curY = coords[ci++];
-              pathStartX = curX;
-              pathStartY = curY;
-            } else if (subOp === OPS.lineTo) {
-              const x2 = coords[ci++], y2 = coords[ci++];
-              currentPath.push({ x1: curX, y1: curY, x2, y2 });
-              curX = x2;
-              curY = y2;
-            } else if (subOp === OPS.rectangle) {
-              const rx = coords[ci++], ry = coords[ci++];
-              const rw = coords[ci++], rh = coords[ci++];
-              pushRectangle(currentPath, rx, ry, rw, rh);
-            } else if (subOp === OPS.closePath) {
-              if (curX !== pathStartX || curY !== pathStartY) {
-                currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
-              }
-              curX = pathStartX;
-              curY = pathStartY;
-            } else if (subOp === OPS.curveTo) {
-              ci += 6;
-            } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
-              ci += 4;
-            }
-          }
-        } else {
-          const afterOp = arg0;
-          const dataArr = args[1];
-          const pathData = dataArr?.[0];
-          if (pathData && typeof pathData === "object") {
-            const len = Object.keys(pathData).length;
-            let di = 0;
-            while (di < len) {
-              const drawOp = pathData[di++];
-              if (drawOp === 0 /* moveTo */) {
-                curX = pathData[di++];
-                curY = pathData[di++];
-                pathStartX = curX;
-                pathStartY = curY;
-              } else if (drawOp === 1 /* lineTo */) {
-                const x2 = pathData[di++], y2 = pathData[di++];
-                currentPath.push({ x1: curX, y1: curY, x2, y2 });
-                curX = x2;
-                curY = y2;
-              } else if (drawOp === 2 /* curveTo */) {
-                di += 6;
-              } else if (drawOp === 3 /* quadraticCurveTo */) {
-                di += 4;
-              } else if (drawOp === 4 /* closePath */) {
-                if (curX !== pathStartX || curY !== pathStartY) {
-                  currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
-                }
-                curX = pathStartX;
-                curY = pathStartY;
-              } else {
-                break;
-              }
-            }
-          }
-          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
-            flushPath(true);
-          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill || afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
-            flushPath(true);
-          } else if (afterOp === OPS.endPath) {
-            flushPath(false);
-          }
+  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
+          });
         }
-        break;
       }
-      case OPS.stroke:
-      case OPS.closeStroke:
-        flushPath(true);
-        break;
-      case OPS.fill:
-      case OPS.eoFill:
-      case OPS.fillStroke:
-      case OPS.eoFillStroke:
-      case OPS.closeFillStroke:
-      case OPS.closeEOFillStroke:
-        flushPath(true);
-        break;
-      case OPS.endPath:
-        flushPath(false);
-        break;
     }
   }
-  return { horizontals, verticals };
-}
-function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
-  const dx = Math.abs(seg.x2 - seg.x1);
-  const dy = Math.abs(seg.y2 - seg.y1);
-  const length = Math.sqrt(dx * dx + dy * dy);
-  if (length < MIN_LINE_LENGTH) return;
-  if (dy <= ORIENTATION_TOL) {
-    const y = (seg.y1 + seg.y2) / 2;
-    const x1 = Math.min(seg.x1, seg.x2);
-    const x2 = Math.max(seg.x1, seg.x2);
-    horizontals.push({ x1, y1: y, x2, y2: y, lineWidth });
-  } else if (dx <= ORIENTATION_TOL) {
-    const x = (seg.x1 + seg.x2) / 2;
-    const y1 = Math.min(seg.y1, seg.y2);
-    const y2 = Math.max(seg.y1, seg.y2);
-    verticals.push({ x1: x, y1, x2: x, y2, lineWidth });
-  }
-}
-function preprocessLines(horizontals, verticals) {
-  let h = horizontals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
-  let v = verticals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
-  h = mergeParallelLines(h, "h");
-  v = mergeParallelLines(v, "v");
-  return { horizontals: h, verticals: v };
-}
-function mergeParallelLines(lines, dir) {
-  if (lines.length <= 1) return lines;
-  const sorted = [...lines].sort((a, b) => {
-    const posA = dir === "h" ? a.y1 : a.x1;
-    const posB = dir === "h" ? b.y1 : b.x1;
-    if (Math.abs(posA - posB) > 0.1) return posA - posB;
-    return dir === "h" ? a.x1 - b.x1 : a.y1 - b.y1;
-  });
-  const MERGE_TOL = 3;
-  const result = [sorted[0]];
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = sorted[i];
-    const prevPos = dir === "h" ? prev.y1 : prev.x1;
-    const currPos = dir === "h" ? curr.y1 : curr.x1;
-    if (Math.abs(prevPos - currPos) <= MERGE_TOL) {
-      const prevStart = dir === "h" ? prev.x1 : prev.y1;
-      const prevEnd = dir === "h" ? prev.x2 : prev.y2;
-      const currStart = dir === "h" ? curr.x1 : curr.y1;
-      const currEnd = dir === "h" ? curr.x2 : curr.y2;
-      const overlap = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
-      const minLen = Math.min(prevEnd - prevStart, currEnd - currStart);
-      if (overlap > minLen * 0.3) {
-        if (dir === "h") {
-          prev.x1 = Math.min(prev.x1, curr.x1);
-          prev.x2 = Math.max(prev.x2, curr.x2);
-          prev.y1 = (prev.y1 + curr.y1) / 2;
-          prev.y2 = prev.y1;
-        } else {
-          prev.y1 = Math.min(prev.y1, curr.y1);
-          prev.y2 = Math.max(prev.y2, curr.y2);
-          prev.x1 = (prev.x1 + curr.x1) / 2;
-          prev.x2 = prev.x1;
+  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 });
+          }
         }
-        prev.lineWidth = Math.max(prev.lineWidth, curr.lineWidth);
-        continue;
       }
     }
-    result.push(curr);
   }
-  return result;
-}
-function filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight) {
-  const margin = 5;
-  return {
-    horizontals: horizontals.filter(
-      (l) => !(Math.abs(l.y1) < margin || Math.abs(l.y1 - pageHeight) < margin) || l.x2 - l.x1 < pageWidth * 0.9
-    ),
-    verticals: verticals.filter(
-      (l) => !(Math.abs(l.x1) < margin || Math.abs(l.x1 - pageWidth) < margin) || l.y2 - l.y1 < pageHeight * 0.9
-    )
-  };
+  return fields;
 }
-function buildVertices(horizontals, verticals) {
-  const vertices = [];
-  const tol = CONNECT_TOL;
-  for (const h of horizontals) {
-    for (const v of verticals) {
-      if (v.x1 >= h.x1 - tol && v.x1 <= h.x2 + tol && h.y1 >= v.y1 - tol && h.y1 <= v.y2 + tol) {
-        const radius = Math.max(h.lineWidth, v.lineWidth, 1);
-        vertices.push({ x: v.x1, y: h.y1, radius });
-      }
+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 vertices;
-}
-function mergeVertices(vertices) {
-  if (vertices.length <= 1) return vertices;
-  const merged = [];
-  const used = new Array(vertices.length).fill(false);
-  for (let i = 0; i < vertices.length; i++) {
-    if (used[i]) continue;
-    let sumX = vertices[i].x, sumY = vertices[i].y;
-    let maxRadius = vertices[i].radius;
-    let count = 1;
-    for (let j = i + 1; j < vertices.length; j++) {
-      if (used[j]) continue;
-      const mergeTol = VERTEX_MERGE_FACTOR * Math.max(maxRadius, vertices[j].radius);
-      if (Math.abs(vertices[i].x - vertices[j].x) <= mergeTol && Math.abs(vertices[i].y - vertices[j].y) <= mergeTol) {
-        sumX += vertices[j].x;
-        sumY += vertices[j].y;
-        maxRadius = Math.max(maxRadius, vertices[j].radius);
-        count++;
-        used[j] = true;
+  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;
       }
     }
-    merged.push({ x: sumX / count, y: sumY / count, radius: maxRadius });
   }
-  return merged;
+  return bestKey;
 }
-function buildTableGrids(horizontals, verticals) {
-  if (horizontals.length < 2 || verticals.length < 2) return [];
-  const allVertices = buildVertices(horizontals, verticals);
-  const vertices = mergeVertices(allVertices);
-  if (vertices.length < 4) return [];
-  const globalRadius = vertices.reduce((max, v) => Math.max(max, v.radius), 1);
-  const allLines = [
-    ...horizontals.map((l, i) => ({ ...l, type: "h", id: i })),
-    ...verticals.map((l, i) => ({ ...l, type: "v", id: i + horizontals.length }))
-  ];
-  const groups = groupConnectedLines(allLines);
-  const grids = [];
-  for (const group of groups) {
-    const hLines = group.filter((l) => l.type === "h");
-    const vLines = group.filter((l) => l.type === "v");
-    if (hLines.length < 2 || vLines.length < 2) continue;
-    let gx1 = Infinity, gy1 = Infinity, gx2 = -Infinity, gy2 = -Infinity;
-    for (const l of vLines) {
-      if (l.x1 < gx1) gx1 = l.x1;
-      if (l.x1 > gx2) gx2 = l.x1;
-    }
-    for (const l of hLines) {
-      if (l.y1 < gy1) gy1 = l.y1;
-      if (l.y1 > gy2) gy2 = l.y1;
-    }
-    const groupBbox = {
-      x1: gx1 - CONNECT_TOL,
-      y1: gy1 - CONNECT_TOL,
-      x2: gx2 + CONNECT_TOL,
-      y2: gy2 + CONNECT_TOL
-    };
-    const groupVertices = vertices.filter(
-      (v) => v.x >= groupBbox.x1 && v.x <= groupBbox.x2 && v.y >= groupBbox.y1 && v.y <= groupBbox.y2
-    );
-    const groupRadius = groupVertices.length > 0 ? groupVertices.reduce((max, v) => Math.max(max, v.radius), 1) : globalRadius;
-    const coordMergeTol = Math.max(VERTEX_MERGE_FACTOR * groupRadius, MIN_COORD_MERGE_TOL);
-    const rawYs = [
-      ...hLines.map((l) => l.y1),
-      ...groupVertices.map((v) => v.y)
-    ];
-    const rowYs = clusterCoordinates(rawYs, coordMergeTol).sort((a, b) => b - a);
-    const rawXs = [
-      ...vLines.map((l) => l.x1),
-      ...groupVertices.map((v) => v.x)
-    ];
-    const colXs = clusterCoordinates(rawXs, coordMergeTol).sort((a, b) => a - b);
-    if (rowYs.length < 2 || colXs.length < 2) continue;
-    const validColXs = enforceMinWidth(colXs, MIN_COL_WIDTH);
-    const validRowYs = enforceMinHeight(rowYs, MIN_ROW_HEIGHT);
-    if (validRowYs.length < 2 || validColXs.length < 2) continue;
-    const bbox = {
-      x1: validColXs[0],
-      y1: validRowYs[validRowYs.length - 1],
-      x2: validColXs[validColXs.length - 1],
-      y2: validRowYs[0]
-    };
-    grids.push({ rowYs: validRowYs, colXs: validColXs, bbox, vertexRadius: groupRadius });
+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 mergeAdjacentGrids(grids);
+  return false;
 }
-function enforceMinWidth(colXs, minWidth) {
-  if (colXs.length <= 2) return colXs;
-  const result = [colXs[0]];
-  for (let i = 1; i < colXs.length; i++) {
-    const prevX = result[result.length - 1];
-    if (colXs[i] - prevX < minWidth && i < colXs.length - 1) {
-      continue;
+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}`;
     }
-    result.push(colXs[i]);
-  }
-  return result;
-}
-function enforceMinHeight(rowYs, minHeight) {
-  if (rowYs.length <= 2) return rowYs;
-  const result = [rowYs[0]];
-  for (let i = 1; i < rowYs.length; i++) {
-    const prevY = result[result.length - 1];
-    if (prevY - rowYs[i] < minHeight && i < rowYs.length - 1) {
-      continue;
+  );
+  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}`;
     }
-    result.push(rowYs[i]);
-  }
-  return result;
-}
-function mergeAdjacentGrids(grids) {
-  if (grids.length <= 1) return grids;
-  const sorted = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
-  const merged = [sorted[0]];
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = merged[merged.length - 1];
-    const curr = sorted[i];
-    if (prev.colXs.length === curr.colXs.length) {
-      const mergeTol = Math.max(VERTEX_MERGE_FACTOR * Math.max(prev.vertexRadius, curr.vertexRadius), 6) * 3;
-      const colMatch = prev.colXs.every((x, ci) => Math.abs(x - curr.colXs[ci]) <= mergeTol);
-      const verticalGap = prev.bbox.y1 - curr.bbox.y2;
-      if (colMatch && verticalGap >= -CONNECT_TOL && verticalGap <= 20) {
-        const allRowYs = [.../* @__PURE__ */ new Set([...prev.rowYs, ...curr.rowYs])].sort((a, b) => b - a);
-        merged[merged.length - 1] = {
-          rowYs: allRowYs,
-          colXs: prev.colXs,
-          bbox: {
-            x1: Math.min(prev.bbox.x1, curr.bbox.x1),
-            y1: Math.min(prev.bbox.y1, curr.bbox.y1),
-            x2: Math.max(prev.bbox.x2, curr.bbox.x2),
-            y2: Math.max(prev.bbox.y2, curr.bbox.y2)
-          },
-          vertexRadius: Math.max(prev.vertexRadius, curr.vertexRadius)
-        };
-        continue;
-      }
+  );
+  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})`;
     }
-    merged.push(curr);
-  }
-  return merged;
+  );
+  return matches.length > 0 ? { text, matches } : null;
 }
-function clusterCoordinates(values, tolerance) {
-  if (values.length === 0) return [];
-  const sorted = [...values].sort((a, b) => a - b);
-  const clusters = [{ sum: sorted[0], count: 1 }];
-  for (let i = 1; i < sorted.length; i++) {
-    const last = clusters[clusters.length - 1];
-    const avg = last.sum / last.count;
-    if (Math.abs(sorted[i] - avg) <= tolerance) {
-      last.sum += sorted[i];
-      last.count++;
-    } else {
-      clusters.push({ sum: sorted[i], count: 1 });
-    }
+function normalizeValues(values) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [label, value] of Object.entries(values)) {
+    map.set(normalizeLabel(label), value);
   }
-  return clusters.map((c) => c.sum / c.count);
+  return map;
 }
-function groupConnectedLines(lines) {
-  const parent = lines.map((_, i) => i);
-  function find(x) {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
-  }
-  function union(a, b) {
-    const ra = find(a), rb = find(b);
-    if (ra !== rb) parent[ra] = rb;
-  }
-  for (let i = 0; i < lines.length; i++) {
-    for (let j = i + 1; j < lines.length; j++) {
-      if (linesIntersect(lines[i], lines[j])) {
-        union(i, j);
-      }
+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;
     }
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (let i = 0; i < lines.length; i++) {
-    const root = find(i);
-    if (!groups.has(root)) groups.set(root, []);
-    groups.get(root).push(lines[i]);
-  }
-  return [...groups.values()];
+    return k;
+  });
 }
-function linesIntersect(a, b) {
-  if (a.type === b.type) {
-    if (a.type === "h") {
-      if (Math.abs(a.y1 - b.y1) > CONNECT_TOL) return false;
-      return Math.min(a.x2, b.x2) >= Math.max(a.x1, b.x1) - CONNECT_TOL;
-    } else {
-      if (Math.abs(a.x1 - b.x1) > CONNECT_TOL) return false;
-      return Math.min(a.y2, b.y2) >= Math.max(a.y1, b.y1) - CONNECT_TOL;
-    }
-  }
-  const h = a.type === "h" ? a : b;
-  const v = a.type === "h" ? b : a;
-  const tol = CONNECT_TOL;
-  return v.x1 >= h.x1 - tol && v.x1 <= h.x2 + tol && h.y1 >= v.y1 - tol && h.y1 <= v.y2 + tol;
-}
-function extractCells(grid, horizontals, verticals) {
-  const { rowYs, colXs } = grid;
-  const numRows = rowYs.length - 1;
-  const numCols = colXs.length - 1;
-  if (numRows <= 0 || numCols <= 0) return [];
-  const vBorders = Array.from(
-    { length: numRows },
-    (_, r) => Array.from(
-      { length: numCols + 1 },
-      (_2, c) => hasVerticalLine(verticals, colXs[c], rowYs[r], rowYs[r + 1], grid.vertexRadius)
-    )
-  );
-  const hBorders = Array.from(
-    { length: numRows + 1 },
-    (_, r) => Array.from(
-      { length: numCols },
-      (_2, c) => hasHorizontalLine(horizontals, rowYs[r], colXs[c], colXs[c + 1], grid.vertexRadius)
-    )
-  );
-  const occupied = Array.from({ length: numRows }, () => Array(numCols).fill(false));
-  const cells = [];
-  for (let r = 0; r < numRows; r++) {
-    for (let c = 0; c < numCols; c++) {
-      if (occupied[r][c]) continue;
-      let colSpan = 1;
-      let rowSpan = 1;
-      while (c + colSpan < numCols && !vBorders[r][c + colSpan]) {
-        let canExpand = true;
-        for (let dr = 0; dr < rowSpan; dr++) {
-          if (vBorders[r + dr][c + colSpan]) {
-            canExpand = false;
-            break;
-          }
-        }
-        if (!canExpand) break;
-        colSpan++;
-      }
-      while (r + rowSpan < numRows) {
-        let hasLine = false;
-        for (let dc = 0; dc < colSpan; dc++) {
-          if (hBorders[r + rowSpan][c + dc]) {
-            hasLine = true;
-            break;
+
+// 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 });
           }
         }
-        if (hasLine) break;
-        rowSpan++;
-      }
-      for (let dr = 0; dr < rowSpan; dr++) {
-        for (let dc = 0; dc < colSpan; dc++) {
-          occupied[r + dr][c + dc] = true;
-        }
       }
-      cells.push({
-        row: r,
-        col: c,
-        rowSpan,
-        colSpan,
-        bbox: {
-          x1: colXs[c],
-          y1: rowYs[r + rowSpan],
-          x2: colXs[c + colSpan],
-          y2: rowYs[r]
-        }
-      });
-    }
-  }
-  return cells;
-}
-function hasVerticalLine(verticals, x, topY, botY, vertexRadius) {
-  const tol = Math.max(VERTEX_MERGE_FACTOR * vertexRadius, 4);
-  for (const v of verticals) {
-    if (Math.abs(v.x1 - x) <= tol) {
-      const cellH = Math.abs(topY - botY);
-      if (cellH < 0.1) continue;
-      const overlapTop = Math.min(v.y2, topY);
-      const overlapBot = Math.max(v.y1, botY);
-      const overlap = overlapTop - overlapBot;
-      if (overlap >= cellH * 0.75) return true;
-    }
-  }
-  return false;
-}
-function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
-  const tol = Math.max(VERTEX_MERGE_FACTOR * vertexRadius, 4);
-  for (const h of horizontals) {
-    if (Math.abs(h.y1 - y) <= tol) {
-      const cellW = Math.abs(rightX - leftX);
-      if (cellW < 0.1) continue;
-      const overlapLeft = Math.max(h.x1, leftX);
-      const overlapRight = Math.min(h.x2, rightX);
-      const overlap = overlapRight - overlapLeft;
-      if (overlap >= cellW * 0.75) return true;
     }
   }
-  return false;
-}
-function mapTextToCells(items, cells) {
-  const result = /* @__PURE__ */ new Map();
-  for (const cell of cells) {
-    result.set(cell, []);
+  for (const block of cloned) {
+    if (block.type !== "table" || !block.table) continue;
+    fillTable(block.table, normalizedValues, filled, matchedLabels, patternFilledCells);
   }
-  for (const item of items) {
-    const pad = CELL_PADDING;
-    let bestCell = null;
-    let bestScore = 0;
-    for (const cell of cells) {
-      const ix1 = Math.max(item.x, cell.bbox.x1 - pad);
-      const ix2 = Math.min(item.x + item.w, cell.bbox.x2 + pad);
-      const iy1 = Math.max(item.y, cell.bbox.y1 - pad);
-      const iy2 = Math.min(item.y + (item.h || item.fontSize), cell.bbox.y2 + pad);
-      if (ix1 >= ix2 || iy1 >= iy2) continue;
-      const intersectArea = (ix2 - ix1) * (iy2 - iy1);
-      const itemArea = Math.max(item.w, 1) * Math.max(item.h || item.fontSize, 1);
-      const score = intersectArea / itemArea;
-      if (score > bestScore) {
-        bestScore = score;
-        bestCell = cell;
-      }
-    }
-    if (bestCell && bestScore > 0.3) {
-      result.get(bestCell).push(item);
-    }
+  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;
   }
-  return result;
+  const unmatched = resolveUnmatched(normalizedValues, matchedLabels, values);
+  return { blocks: cloned, filled, unmatched };
 }
-function cellTextToString(items) {
-  if (items.length === 0) return "";
-  if (items.length === 1) return items[0].text;
-  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
-  const lines = [];
-  let curLine = [sorted[0]];
-  let curY = sorted[0].y;
-  for (let i = 1; i < sorted.length; i++) {
-    const tol = Math.max(3, Math.min(sorted[i].fontSize, curLine[0].fontSize) * 0.6);
-    if (Math.abs(sorted[i].y - curY) <= tol) {
-      curLine.push(sorted[i]);
-    } else {
-      lines.push(curLine);
-      curLine = [sorted[i]];
-      curY = sorted[i].y;
-    }
-  }
-  lines.push(curLine);
-  const textLines = lines.map((line) => {
-    const s = line.sort((a, b) => a.x - b.x);
-    if (s.length === 1) return s[0].text;
-    const evenSpaced = detectEvenSpacedItems(s);
-    let result = s[0].text;
-    for (let j = 1; j < s.length; j++) {
-      if (evenSpaced[j]) {
-        result += s[j].text;
-        continue;
-      }
-      const gap = s[j].x - (s[j - 1].x + s[j - 1].w);
-      const avgFs = (s[j].fontSize + s[j - 1].fontSize) / 2;
-      const prevIsKorean = /[가-힣]$/.test(result);
-      const currIsKorean = /^[가-힣]/.test(s[j].text);
-      if (gap < avgFs * 0.15) {
-        result += s[j].text;
-      } else if (gap < avgFs * 0.35 && (prevIsKorean || currIsKorean)) {
-        result += s[j].text;
+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 {
-        result += " " + s[j].text;
-      }
-    }
-    return result;
-  });
-  return mergeCellTextLines(textLines);
-}
-function detectEvenSpacedItems(items) {
-  const result = new Array(items.length).fill(false);
-  if (items.length < 3) return result;
-  let runStart = -1;
-  for (let i = 0; i < items.length; i++) {
-    const isShortKorean = /^[가-힣]{1}$/.test(items[i].text) || /^[\d]{1}$/.test(items[i].text);
-    if (isShortKorean && runStart >= 0 && i > 0) {
-      const gap = items[i].x - (items[i - 1].x + items[i - 1].w);
-      const maxRunGap = Math.max(items[i].fontSize * 3, 30);
-      if (gap > maxRunGap) {
-        if (i - runStart >= 3) markEvenRun(items, result, runStart, i);
-        runStart = i;
-        continue;
+        valueCell.text = newValue;
       }
+      matchedLabels.add(matchKey);
+      filled.push({
+        label: labelCell.text.trim().replace(/[:：]\s*$/, ""),
+        value: newValue,
+        row: r,
+        col: c
+      });
     }
-    if (isShortKorean) {
-      if (runStart < 0) runStart = i;
-    } else {
-      if (runStart >= 0 && i - runStart >= 3) {
-        markEvenRun(items, result, runStart, i);
+  }
+  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
+        });
       }
-      runStart = -1;
     }
   }
-  if (runStart >= 0 && items.length - runStart >= 3) {
-    markEvenRun(items, result, runStart, items.length);
-  }
-  return result;
 }
-function markEvenRun(items, result, start, end) {
-  const gaps = [];
-  for (let i = start + 1; i < end; i++) {
-    gaps.push(items[i].x - (items[i - 1].x + items[i - 1].w));
-  }
-  const posGaps = gaps.filter((g2) => g2 > 0);
-  if (posGaps.length < 2) return;
-  let minGap = Infinity, maxGap = -Infinity;
-  for (const g2 of posGaps) {
-    if (g2 < minGap) minGap = g2;
-    if (g2 > maxGap) maxGap = g2;
-  }
-  const avgFs = items[start].fontSize;
-  if (minGap >= avgFs * 0.1 && maxGap <= avgFs * 3 && maxGap / Math.max(minGap, 0.1) <= 3) {
-    for (let i = start + 1; i < end; i++) {
-      result[i] = true;
-    }
-  }
-}
-function mergeCellTextLines(textLines) {
-  if (textLines.length <= 1) return textLines[0] || "";
-  const merged = [textLines[0]];
-  for (let i = 1; i < textLines.length; i++) {
-    const prev = merged[merged.length - 1];
-    const curr = textLines[i];
-    if (/[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 8 && !curr.includes(" ")) {
-      merged[merged.length - 1] = prev + curr;
-    } else if (curr.trim().length <= 3 && /^[)\]%}]/.test(curr.trim())) {
-      merged[merged.length - 1] = prev + curr.trim();
-    } else if (/[,(]$/.test(prev.trim()) && curr.trim().length <= 15) {
-      merged[merged.length - 1] = prev + curr.trim();
-    } else if (/[\d,]$/.test(prev) && /^[\d,]+[)\]]?$/.test(curr.trim()) && curr.trim().length <= 10) {
-      merged[merged.length - 1] = prev + curr.trim();
-    } else {
-      merged.push(curr);
+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}`;
     }
-  }
-  return merged.join("\n");
+  );
 }
 
-// src/pdf/cluster-detector.ts
-var Y_TOL = 3;
-var COL_CLUSTER_TOL = 15;
-var MIN_ROWS = 3;
-var MIN_COLS = 2;
-var MIN_GAP_FACTOR = 2;
-var MIN_GAP_ABSOLUTE = 20;
-var MIN_COL_FILL_RATIO = 0.4;
-function detectClusterTables(items, pageNum) {
-  if (items.length < MIN_ROWS * MIN_COLS) return [];
-  const { merged, originMap } = mergeEvenSpacedClusters(items);
-  const rows = groupByBaseline(merged);
-  if (rows.length < MIN_ROWS) return [];
-  const results = [];
-  const headerResult = detectHeaderRow(rows);
-  if (headerResult) {
-    const { columns, headerIdx } = headerResult;
-    const headerRow = rows[headerIdx];
-    const headerItems = [...headerRow.items].sort((a, b) => a.x - b.x);
-    const headerAndBelow = rows.slice(headerIdx);
-    const mergedRows = mergeMultiLineRows(headerAndBelow, columns);
-    const tableRegions = findTableRegionsByHeader(mergedRows, columns, headerItems);
-    for (const region of tableRegions) {
-      const table = buildClusterTable(region.rows, columns, pageNum);
-      if (table) {
-        expandUsedItems(table.usedItems, originMap);
-        results.push(table);
+// src/form/filler-hwpx.ts
+import JSZip2 from "jszip";
+import { DOMParser as DOMParser2, XMLSerializer } from "@xmldom/xmldom";
+async function fillHwpx(hwpxBuffer, values) {
+  const zip = await JSZip2.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 DOMParser2();
+  const xmlSerializer = new 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;
       }
     }
-  }
-  if (results.length === 0) {
-    const suspiciousRows = rows.filter((row) => hasSuspiciousGaps(row));
-    if (suspiciousRows.length >= MIN_ROWS) {
-      const columns = extractColumnClusters(suspiciousRows);
-      if (columns.length >= MIN_COLS) {
-        const tableRegions = findTableRegions(rows, columns);
-        for (const region of tableRegions) {
-          const mergedRows = mergeMultiLineRows(region.rows, columns);
-          const table = buildClusterTable(mergedRows, columns, pageNum);
-          if (table) {
-            expandUsedItems(table.usedItems, originMap);
-            results.push(table);
+    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;
         }
       }
-    }
-  }
-  return results;
-}
-function mergeEvenSpacedClusters(items) {
-  const originMap = /* @__PURE__ */ new Map();
-  const rows = groupByBaseline(items);
-  const merged = [];
-  for (const row of rows) {
-    const sorted = [...row.items].sort((a, b) => a.x - b.x);
-    let i = 0;
-    while (i < sorted.length) {
-      if (/^[가-힣\d]$/.test(sorted[i].text)) {
-        let runEnd = i + 1;
-        while (runEnd < sorted.length && /^[가-힣\d]$/.test(sorted[runEnd].text)) {
-          const gap = sorted[runEnd].x - (sorted[runEnd - 1].x + sorted[runEnd - 1].w);
-          const fs = sorted[runEnd].fontSize;
-          if (gap < fs * 0.1 || gap > fs * 3) break;
-          runEnd++;
-        }
-        if (runEnd - i >= 3) {
-          const gaps = [];
-          for (let g2 = i + 1; g2 < runEnd; g2++) {
-            gaps.push(sorted[g2].x - (sorted[g2 - 1].x + sorted[g2 - 1].w));
-          }
-          let minG = Infinity, maxG = -Infinity;
-          for (const g2 of gaps) {
-            if (g2 < minG) minG = g2;
-            if (g2 > maxG) maxG = g2;
-          }
-          if (minG > 0 && maxG / minG <= 3) {
-            const run = sorted.slice(i, runEnd);
-            const text = run.map((r) => r.text).join("");
-            const first = run[0], last = run[runEnd - i - 1];
-            const item = {
-              text,
-              x: first.x,
-              y: first.y,
-              w: last.x + last.w - first.x,
-              h: first.h,
-              fontSize: first.fontSize,
-              fontName: first.fontName
-            };
-            originMap.set(item, run);
-            merged.push(item);
-            i = runEnd;
-            continue;
+      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;
+            }
           }
         }
       }
-      merged.push(sorted[i]);
-      i++;
     }
-  }
-  return { merged, originMap };
-}
-function expandUsedItems(usedItems, originMap) {
-  const toAdd = [];
-  for (const item of usedItems) {
-    const origins = originMap.get(item);
-    if (origins) for (const o of origins) toAdd.push(o);
-  }
-  for (const a of toAdd) usedItems.add(a);
-}
-function detectHeaderRow(rows) {
-  const allItems = rows.flatMap((r) => r.items);
-  if (allItems.length === 0) return null;
-  let allMinX = Infinity, allMaxX = -Infinity;
-  for (const i of allItems) {
-    if (i.x < allMinX) allMinX = i.x;
-    const r = i.x + i.w;
-    if (r > allMaxX) allMaxX = r;
-  }
-  const pageSpan = allMaxX - allMinX;
-  if (pageSpan <= 0) return null;
-  for (let ri = 0; ri < rows.length; ri++) {
-    const row = rows[ri];
-    if (row.items.length < MIN_COLS || row.items.length > 6) continue;
-    if (row.items.some((i) => i.text.length > 8)) continue;
-    if (!row.items.some((i) => /[가-힣]/.test(i.text))) continue;
-    if (row.items.some((i) => /^[□■○●·※▶▷◆◇\-]/.test(i.text))) continue;
-    const sorted = [...row.items].sort((a, b) => a.x - b.x);
-    const xSpan = sorted[sorted.length - 1].x + sorted[sorted.length - 1].w - sorted[0].x;
-    if (xSpan / pageSpan < 0.4) continue;
-    const avgFs = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
-    let hasLargeGap = false;
-    for (let i = 1; i < sorted.length; i++) {
-      const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
-      if (gap >= avgFs * 2.5) {
-        hasLargeGap = 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 (!hasLargeGap) continue;
-    const columns = sorted.map((item) => ({ x: item.x, count: 0 }));
-    let matchCount = 0;
-    for (let j = ri + 1; j < rows.length && matchCount < MIN_ROWS + 2; j++) {
-      const matched = countMatchedColumnsRange(rows[j], columns, sorted);
-      if (matched >= MIN_COLS) matchCount++;
-    }
-    if (matchCount < MIN_ROWS) continue;
-    return { columns, headerIdx: ri };
-  }
-  return null;
-}
-function mergeMultiLineRows(rows, columns) {
-  if (rows.length <= 1) return rows;
-  const result = [rows[0]];
-  const allFontSizes = rows.flatMap((r) => r.items).map((i) => i.fontSize);
-  const avgFontSize = allFontSizes.length > 0 ? allFontSizes.reduce((s, v) => s + v, 0) / allFontSizes.length : 12;
-  for (let i = 1; i < rows.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = rows[i];
-    const yGap = Math.abs(prev.y - curr.y);
-    const matchedCols = countMatchedColumns(curr, columns);
-    if (yGap < avgFontSize * 1.8 && curr.items.length <= 2 && (matchedCols < MIN_COLS || curr.items.length === 1)) {
-      result[result.length - 1] = {
-        y: prev.y,
-        items: [...prev.items, ...curr.items]
-      };
-    } else {
-      result.push(curr);
-    }
-  }
-  return result;
-}
-function groupByBaseline(items) {
-  if (items.length === 0) return [];
-  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
-  const rows = [];
-  let curItems = [sorted[0]];
-  let curY = sorted[0].y;
-  for (let i = 1; i < sorted.length; i++) {
-    if (Math.abs(sorted[i].y - curY) <= Y_TOL) {
-      curItems.push(sorted[i]);
-    } else {
-      rows.push({ y: curY, items: curItems });
-      curItems = [sorted[i]];
-      curY = sorted[i].y;
-    }
-  }
-  if (curItems.length > 0) rows.push({ y: curY, items: curItems });
-  return rows;
-}
-function hasSuspiciousGaps(row) {
-  if (row.items.length < 2) return false;
-  const sorted = [...row.items].sort((a, b) => a.x - b.x);
-  if (sorted.length === 2 && sorted[1].text.length > 20) return false;
-  const avgFontSize = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
-  const minGap = Math.max(avgFontSize * MIN_GAP_FACTOR, MIN_GAP_ABSOLUTE);
-  for (let i = 1; i < sorted.length; i++) {
-    const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
-    if (gap >= minGap) return true;
-  }
-  return false;
-}
-function extractColumnClusters(rows) {
-  const allX = [];
-  for (const row of rows) {
-    for (const item of row.items) allX.push(item.x);
-  }
-  if (allX.length === 0) return [];
-  allX.sort((a, b) => a - b);
-  const clusters = [];
-  let clusterStart = 0;
-  for (let i = 1; i <= allX.length; i++) {
-    if (i === allX.length || allX[i] - allX[i - 1] > COL_CLUSTER_TOL) {
-      const slice = allX.slice(clusterStart, i);
-      const avg = Math.round(slice.reduce((s, v) => s + v, 0) / slice.length);
-      clusters.push({ x: avg, count: slice.length });
-      clusterStart = i;
-    }
-  }
-  const minCount = Math.max(2, Math.floor(rows.length * MIN_COL_FILL_RATIO));
-  return clusters.filter((c) => c.count >= minCount).sort((a, b) => a.x - b.x);
-}
-function findTableRegionsByHeader(allRows, columns, headerItems) {
-  const regions = [];
-  let currentRegion = [];
-  let missStreak = 0;
-  for (const row of allRows) {
-    const matchedCols = countMatchedColumnsRange(row, columns, headerItems);
-    if (matchedCols >= MIN_COLS) {
-      currentRegion.push(row);
-      missStreak = 0;
-    } else if (currentRegion.length > 0 && (row.items.length <= 2 || missStreak === 0)) {
-      currentRegion.push(row);
-      missStreak++;
-    } else {
-      while (currentRegion.length > 0) {
-        const last = currentRegion[currentRegion.length - 1];
-        if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
-        currentRegion.pop();
-      }
-      if (currentRegion.length >= MIN_ROWS) {
-        regions.push({ rows: [...currentRegion] });
-      }
-      currentRegion = [];
-      missStreak = 0;
-    }
-  }
-  while (currentRegion.length > 0) {
-    const last = currentRegion[currentRegion.length - 1];
-    if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
-    currentRegion.pop();
-  }
-  if (currentRegion.length >= MIN_ROWS) {
-    regions.push({ rows: currentRegion });
-  }
-  return regions;
-}
-function findTableRegions(allRows, columns) {
-  const regions = [];
-  let currentRegion = [];
-  for (const row of allRows) {
-    const matchedCols = countMatchedColumns(row, columns);
-    if (matchedCols >= MIN_COLS) {
-      currentRegion.push(row);
-    } else if (row.items.length === 1) {
-      if (currentRegion.length > 0) {
-        currentRegion.push(row);
-      }
-    } else {
-      if (currentRegion.length >= MIN_ROWS) {
-        regions.push({ rows: [...currentRegion] });
-      }
-      currentRegion = [];
-    }
-  }
-  if (currentRegion.length >= MIN_ROWS) {
-    regions.push({ rows: currentRegion });
-  }
-  return regions;
-}
-function countMatchedColumns(row, columns) {
-  const matched = /* @__PURE__ */ new Set();
-  for (const item of row.items) {
-    for (let ci = 0; ci < columns.length; ci++) {
-      if (Math.abs(item.x - columns[ci].x) <= COL_CLUSTER_TOL * 2) {
-        matched.add(ci);
-        break;
-      }
+    if (modified) {
+      const newXml = xmlSerializer.serializeToString(doc);
+      zip.file(sectionPath, newXml);
     }
   }
-  return matched.size;
+  const unmatched = resolveUnmatched(normalizedValues, matchedLabels, values);
+  const buffer = await zip.generateAsync({ type: "arraybuffer" });
+  return { buffer, filled, unmatched };
 }
-function countMatchedColumnsRange(row, columns, headerItems) {
-  const boundaries = [];
-  for (let ci = 0; ci < headerItems.length; ci++) {
-    const left = ci === 0 ? 0 : (headerItems[ci - 1].x + headerItems[ci - 1].w + headerItems[ci].x) / 2;
-    const right = ci === headerItems.length - 1 ? Infinity : (headerItems[ci].x + headerItems[ci].w + headerItems[ci + 1].x) / 2;
-    boundaries.push({ left, right });
-  }
-  const matched = /* @__PURE__ */ new Set();
-  for (const item of row.items) {
-    for (let ci = 0; ci < boundaries.length; ci++) {
-      if (item.x >= boundaries[ci].left && item.x < boundaries[ci].right) {
-        matched.add(ci);
-        break;
-      }
-    }
-  }
-  return matched.size;
+function localName(el) {
+  return (el.tagName || el.localName || "").replace(/^[^:]+:/, "");
 }
-function assignRowItems(items, columns, numCols) {
-  if (items.length === 0) return [];
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  const colCenters = columns.map((c) => c.x);
-  const gaps = [];
-  for (let i = 1; i < sorted.length; i++) {
-    gaps.push({ idx: i, size: sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w) });
-  }
-  const gapSizes = gaps.map((g2) => g2.size).sort((a, b) => a - b);
-  const medianGap = gapSizes.length > 0 ? gapSizes[Math.floor(gapSizes.length / 2)] : 0;
-  const gapThreshold = sorted.length <= numCols + 1 ? 12 : Math.max(medianGap * 2.5, 12);
-  const significantGaps = gaps.filter((g2) => g2.size >= gapThreshold).sort((a, b) => b.size - a.size).slice(0, numCols - 1).sort((a, b) => a.idx - b.idx);
-  const groups = [];
-  let start = 0;
-  for (const gap of significantGaps) {
-    groups.push(sorted.slice(start, gap.idx));
-    start = gap.idx;
-  }
-  groups.push(sorted.slice(start));
+function findAllElements(node, tagLocalName) {
   const result = [];
-  const usedCols = /* @__PURE__ */ new Set();
-  const groupCenters = groups.map((g2) => {
-    let minX = Infinity, maxX = -Infinity;
-    for (const i of g2) {
-      if (i.x < minX) minX = i.x;
-      const r = i.x + i.w;
-      if (r > maxX) maxX = r;
-    }
-    return (minX + maxX) / 2;
-  });
-  const assignments = [];
-  for (let gi = 0; gi < groups.length; gi++) {
-    for (let ci = 0; ci < numCols; ci++) {
-      assignments.push({ gi, ci, dist: Math.abs(groupCenters[gi] - colCenters[ci]) });
-    }
-  }
-  assignments.sort((a, b) => a.dist - b.dist);
-  const assignedGroups = /* @__PURE__ */ new Set();
-  for (const { gi, ci } of assignments) {
-    if (assignedGroups.has(gi) || usedCols.has(ci)) continue;
-    result.push({ col: ci, items: groups[gi] });
-    assignedGroups.add(gi);
-    usedCols.add(ci);
-  }
-  for (let gi = 0; gi < groups.length; gi++) {
-    if (assignedGroups.has(gi)) continue;
-    let bestCol = 0, bestDist = Infinity;
-    for (let ci = 0; ci < numCols; ci++) {
-      const d = Math.abs(groupCenters[gi] - colCenters[ci]);
-      if (d < bestDist) {
-        bestDist = d;
-        bestCol = ci;
-      }
-    }
-    result.push({ col: bestCol, items: groups[gi] });
-  }
-  return result;
-}
-function buildClusterTable(rows, columns, pageNum) {
-  const numCols = columns.length;
-  const numRows = rows.length;
-  if (numRows < MIN_ROWS || numCols < MIN_COLS) return null;
-  const cells = Array.from(
-    { length: numRows },
-    () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
-  );
-  const usedItems = /* @__PURE__ */ new Set();
-  for (let r = 0; r < numRows; r++) {
-    const row = rows[r];
-    if (row.items.length === 1 && numCols > 1) {
-      cells[r][0] = { text: row.items[0].text, colSpan: numCols, rowSpan: 1 };
-      usedItems.add(row.items[0]);
-      continue;
-    }
-    const assignments = assignRowItems(row.items, columns, numCols);
-    for (const { col, items } of assignments) {
-      const text = items.map((i) => i.text).join(" ");
-      const existing = cells[r][col].text;
-      cells[r][col].text = existing ? existing + " " + text : text;
-      for (const item of items) usedItems.add(item);
-    }
-  }
-  let emptyRows = 0;
-  for (const row of cells) {
-    if (row.every((c) => c.text === "")) emptyRows++;
-  }
-  if (emptyRows > numRows * 0.5) return null;
-  for (let c = 0; c < numCols; c++) {
-    const hasValue = cells.some((row) => row[c].text !== "");
-    if (!hasValue) return null;
-  }
-  for (let r = numRows - 1; r >= 1; r--) {
-    const nonEmptyCols = cells[r].filter((c) => c.text.trim()).length;
-    if (nonEmptyCols !== 1) continue;
-    if (cells[r][0].text.trim() !== "") continue;
-    const contentText = cells[r].find((c) => c.text.trim())?.text.trim() || "";
-    if (/^[○●▶\-·]/.test(contentText)) continue;
-    for (let pr = r - 1; pr >= 0; pr--) {
-      if (cells[pr].some((c) => c.text.trim())) {
-        for (let c = 0; c < numCols; c++) {
-          const prev = cells[pr][c].text.trim();
-          const curr = cells[r][c].text.trim();
-          if (curr) cells[pr][c].text = prev ? prev + " " + curr : curr;
-        }
-        for (let c = 0; c < numCols; c++) cells[r][c].text = "";
-        break;
-      }
-    }
-  }
-  for (let r = 0; r < cells.length - 1; r++) {
-    const row = cells[r];
-    const hasCol0 = row[0].text.trim() !== "";
-    const hasColLast = numCols > 1 && row[numCols - 1].text.trim() !== "";
-    const midEmpty = row.slice(1, numCols - 1).every((c) => c.text.trim() === "");
-    if (hasCol0 && hasColLast && midEmpty) {
-      const next = cells[r + 1];
-      if (next[0].text.trim() === "" && next.some((c) => c.text.trim())) {
-        for (let c = 1; c < numCols; c++) {
-          const curr = next[c].text.trim();
-          if (curr) row[c].text = row[c].text.trim() ? row[c].text.trim() + " " + curr : curr;
-        }
-        for (let c = 0; c < numCols; c++) next[c].text = "";
-      }
-    }
-  }
-  const filteredCells = cells.filter((row) => row.some((c) => c.text.trim()));
-  const finalRowCount = filteredCells.length;
-  if (finalRowCount < MIN_ROWS) return null;
-  const irTable = {
-    rows: finalRowCount,
-    cols: numCols,
-    cells: filteredCells,
-    hasHeader: finalRowCount > 1
-  };
-  const allItems = rows.flatMap((r) => r.items);
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const i of allItems) {
-    if (i.x < minX) minX = i.x;
-    if (i.y < minY) minY = i.y;
-    if (i.x + i.w > maxX) maxX = i.x + i.w;
-    const h = i.h > 0 ? i.h : i.fontSize;
-    if (i.y + h > maxY) maxY = i.y + h;
-  }
-  return {
-    table: irTable,
-    bbox: { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY },
-    usedItems
-  };
-}
-
-// 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;
+  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);
     }
   };
-}
-if (typeof g.Path2D === "undefined") {
-  g.Path2D = class Path2D {
-  };
-}
-g.pdfjsWorker = pdfjsWorker;
-
-// src/pdf/parser.ts
-import { getDocument, GlobalWorkerOptions } from "pdfjs-dist/legacy/build/pdf.mjs";
-GlobalWorkerOptions.workerSrc = "";
-var MAX_PAGES = 5e3;
-var MAX_TOTAL_TEXT = 100 * 1024 * 1024;
-var PDF_LOAD_TIMEOUT_MS = 3e4;
-async function loadPdfWithTimeout(buffer) {
-  const loadingTask = getDocument({
-    data: new Uint8Array(buffer),
-    useSystemFonts: true,
-    disableFontFace: true,
-    isEvalSupported: false
-  });
-  let timer;
-  try {
-    return await Promise.race([
-      loadingTask.promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          loadingTask.destroy();
-          reject(new KordocError("PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (30\uCD08 \uCD08\uACFC)"));
-        }, PDF_LOAD_TIMEOUT_MS);
-      })
-    ]);
-  } finally {
-    if (timer !== void 0) clearTimeout(timer);
-  }
-}
-async function parsePdfDocument(buffer, options) {
-  const doc = await loadPdfWithTimeout(buffer);
-  try {
-    const pageCount = doc.numPages;
-    if (pageCount === 0) throw new KordocError("PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    const metadata = { pageCount };
-    await extractPdfMetadata(doc, metadata);
-    const blocks = [];
-    const warnings = [];
-    let totalChars = 0;
-    let totalTextBytes = 0;
-    const effectivePageCount = Math.min(pageCount, MAX_PAGES);
-    const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
-    const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
-    const fontSizeFreq = /* @__PURE__ */ new Map();
-    const pageHeights = /* @__PURE__ */ new Map();
-    let parsedPages = 0;
-    for (let i = 1; i <= effectivePageCount; i++) {
-      if (pageFilter && !pageFilter.has(i)) continue;
-      try {
-        const page = await doc.getPage(i);
-        const tc = await page.getTextContent();
-        const viewport = page.getViewport({ scale: 1 });
-        pageHeights.set(i, viewport.height);
-        const rawItems = tc.items;
-        const items = normalizeItems(rawItems);
-        const { visible, hiddenCount } = filterHiddenText(items, viewport.width, viewport.height);
-        if (hiddenCount > 0) {
-          warnings.push({ page: i, message: `${hiddenCount}\uAC1C \uC228\uACA8\uC9C4 \uD14D\uC2A4\uD2B8 \uC694\uC18C \uD544\uD130\uB9C1\uB428`, code: "HIDDEN_TEXT_FILTERED" });
-        }
-        for (const item of visible) {
-          if (item.fontSize > 0) fontSizeFreq.set(item.fontSize, (fontSizeFreq.get(item.fontSize) || 0) + 1);
-        }
-        const opList = await page.getOperatorList();
-        const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
-        for (const b of pageBlocks) blocks.push(b);
-        for (const b of pageBlocks) {
-          const t = b.text || "";
-          totalChars += t.replace(/\s/g, "").length;
-          totalTextBytes += t.length * 2;
-        }
-        if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
-        parsedPages++;
-        options?.onProgress?.(parsedPages, totalTarget);
-      } catch (pageErr) {
-        if (pageErr instanceof KordocError) throw pageErr;
-        warnings.push({ page: i, message: `\uD398\uC774\uC9C0 ${i} \uD30C\uC2F1 \uC2E4\uD328: ${pageErr instanceof Error ? pageErr.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`, code: "PARTIAL_PARSE" });
-      }
-    }
-    const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
-    if (totalChars / Math.max(parsedPageCount, 1) < 10) {
-      if (options?.ocr) {
-        try {
-          const { ocrPages } = await import("./provider-7H4CPZYS.js");
-          const ocrBlocks = await ocrPages(doc, options.ocr, pageFilter, effectivePageCount);
-          if (ocrBlocks.length > 0) {
-            const ocrMarkdown = ocrBlocks.map((b) => b.text || "").filter(Boolean).join("\n\n");
-            return { markdown: ocrMarkdown, blocks: ocrBlocks, metadata, warnings, isImageBased: true };
-          }
-        } catch {
-        }
-      }
-      throw Object.assign(new KordocError(`\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`), { isImageBased: true });
-    }
-    if (options?.removeHeaderFooter !== false && parsedPageCount >= 3) {
-      const removed = removeHeaderFooterBlocks(blocks, pageHeights, warnings);
-      for (let ri = removed.length - 1; ri >= 0; ri--) {
-        blocks.splice(removed[ri], 1);
-      }
-    }
-    const medianFontSize = computeMedianFontSizeFromFreq(fontSizeFreq);
-    if (medianFontSize > 0) {
-      detectHeadings(blocks, medianFontSize);
-    }
-    detectMarkerHeadings(blocks);
-    const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
-    let markdown = cleanPdfText(blocksToMarkdown(blocks));
-    return { markdown, blocks, metadata, outline: outline.length > 0 ? outline : void 0, warnings: warnings.length > 0 ? warnings : void 0 };
-  } 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}`;
-}
-async function extractPdfMetadataOnly(buffer) {
-  const doc = await loadPdfWithTimeout(buffer);
-  try {
-    const metadata = { pageCount: doc.numPages };
-    await extractPdfMetadata(doc, metadata);
-    return metadata;
-  } finally {
-    await doc.destroy().catch(() => {
-    });
-  }
-}
-function filterHiddenText(items, pageWidth, pageHeight) {
-  let hiddenCount = 0;
-  const visible = [];
-  for (const item of items) {
-    if (item.isHidden) {
-      hiddenCount++;
-      continue;
-    }
-    const margin = Math.max(pageWidth, pageHeight) * 0.1;
-    if (item.x < -margin || item.x > pageWidth + margin || item.y < -margin || item.y > pageHeight + margin) {
-      hiddenCount++;
-      continue;
-    }
-    visible.push(item);
-  }
-  return { visible, hiddenCount };
-}
-function computeMedianFontSizeFromFreq(freq) {
-  if (freq.size === 0) return 0;
-  let total = 0;
-  for (const count of freq.values()) total += count;
-  const sorted = [...freq.entries()].sort((a, b) => a[0] - b[0]);
-  const mid = Math.floor(total / 2);
-  let cumulative = 0;
-  for (const [size, count] of sorted) {
-    cumulative += count;
-    if (cumulative > mid) return size;
-  }
-  return sorted[sorted.length - 1][0];
-}
-function detectHeadings(blocks, medianFontSize) {
-  for (const block of blocks) {
-    if (block.type !== "paragraph" || !block.text || !block.style?.fontSize) continue;
-    const text = block.text.trim();
-    if (text.length === 0 || text.length > 200) continue;
-    if (/^\d+$/.test(text)) continue;
-    const ratio = block.style.fontSize / medianFontSize;
-    let level = 0;
-    if (ratio >= HEADING_RATIO_H1) level = 1;
-    else if (ratio >= HEADING_RATIO_H2) level = 2;
-    else if (ratio >= HEADING_RATIO_H3) level = 3;
-    if (level > 0) {
-      block.type = "heading";
-      block.level = level;
-      block.text = collapseEvenSpacing(text);
-    }
-  }
-}
-function collapseEvenSpacing(text) {
-  const tokens = text.split(" ");
-  const singleCharCount = tokens.filter((t) => t.length === 1).length;
-  if (tokens.length >= 3 && singleCharCount / tokens.length >= 0.7) {
-    return tokens.join("");
-  }
-  return text.replace(
-    /(?<![가-힣])[가-힣](?: [가-힣\d]){2,}(?![가-힣])/g,
-    (match) => match.replace(/ /g, "")
-  );
-}
-function shouldDemoteTable(table) {
-  const allCells = table.cells.flatMap((row) => row.map((c) => c.text.trim())).filter(Boolean);
-  const allText = allCells.join(" ");
-  if (table.rows <= 3 && table.cols <= 3) {
-    const totalCells2 = table.rows * table.cols;
-    const emptyCells2 = totalCells2 - allCells.length;
-    if (emptyCells2 >= totalCells2 * 0.3) return true;
-    if (/[□■◆○●▶ㅇ]/.test(allText)) return true;
-    if (/<[^>]+>/.test(allText)) return true;
-  }
-  if (allText.length > 200) return false;
-  if (/[□■◆○●▶]/.test(allText) && table.rows <= 3) return true;
-  const totalCells = table.rows * table.cols;
-  const emptyCells = totalCells - allCells.length;
-  if (table.rows <= 2 && emptyCells > totalCells * 0.5) return true;
-  if (table.rows === 1 && !/\d{2,}/.test(allText)) return true;
-  return false;
-}
-function demoteTableToText(table) {
-  const lines = [];
-  for (let r = 0; r < table.rows; r++) {
-    const cells = table.cells[r].map((c) => c.text.trim()).filter(Boolean);
-    if (cells.length === 0) continue;
-    if (table.cols === 2 && cells.length === 2) {
-      lines.push(`${cells[0]} : ${cells[1]}`);
-    } else {
-      lines.push(cells.join(" "));
-    }
-  }
-  return lines.join("\n");
-}
-function detectMarkerHeadings(blocks) {
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (block.type !== "paragraph" || !block.text) continue;
-    const text = block.text.trim();
-    if (text.length < 50 && /^[□■◆◇▶]\s*[가-힣]/.test(text)) {
-      block.type = "heading";
-      block.level = 4;
-      continue;
-    }
-    if (/^[가-힣]{2,6}$/.test(text) && block.style?.fontSize) {
-      const prev = blocks[i - 1];
-      const next = blocks[i + 1];
-      const prevIsStructural = !prev || prev.type === "table" || prev.type === "heading" || prev.type === "separator";
-      const nextIsStructural = !next || next.type === "table" || next.type === "heading" || next.type === "paragraph" && next.text && /^[□■◆○●]/.test(next.text.trim());
-      if (prevIsStructural || nextIsStructural) {
-        block.type = "heading";
-        block.level = 3;
-      }
-    }
-  }
-}
-var MAX_XYCUT_DEPTH = 50;
-function xyCutOrder(items, gapThreshold, depth = 0) {
-  if (items.length === 0) return [];
-  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return [items];
-  const region = computeRegion(items);
-  const ySplit = findYSplit(items, region, gapThreshold);
-  if (ySplit !== null) {
-    const upper = items.filter((i) => i.y > ySplit);
-    const lower = items.filter((i) => i.y <= ySplit);
-    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
-      return [...xyCutOrder(upper, gapThreshold, depth + 1), ...xyCutOrder(lower, gapThreshold, depth + 1)];
-    }
-  }
-  const xSplit = findXSplit(items, region, gapThreshold);
-  if (xSplit !== null) {
-    const left = items.filter((i) => i.x + i.w / 2 < xSplit);
-    const right = items.filter((i) => i.x + i.w / 2 >= xSplit);
-    if (left.length > 0 && right.length > 0 && left.length < items.length) {
-      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
-    }
-  }
-  return [items];
-}
-function computeRegion(items) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const i of items) {
-    if (i.x < minX) minX = i.x;
-    if (i.y < minY) minY = i.y;
-    if (i.x + i.w > maxX) maxX = i.x + i.w;
-    if (i.y + i.h > maxY) maxY = i.y + i.h;
-  }
-  return { items, minX, minY, maxX, maxY };
-}
-function findYSplit(items, _region, gapThreshold) {
-  const sorted = [...items].sort((a, b) => b.y - a.y);
-  let bestGap = gapThreshold;
-  let bestSplit = null;
-  for (let i = 1; i < sorted.length; i++) {
-    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
-    const currTop = sorted[i].y;
-    const gap = prevBottom - currTop;
-    if (gap > bestGap) {
-      bestGap = gap;
-      bestSplit = (prevBottom + currTop) / 2;
-    }
-  }
-  return bestSplit;
-}
-function findXSplit(items, _region, gapThreshold) {
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  let bestGap = gapThreshold;
-  let bestSplit = null;
-  for (let i = 1; i < sorted.length; i++) {
-    const prevRight = sorted[i - 1].x + sorted[i - 1].w;
-    const currLeft = sorted[i].x;
-    const gap = currLeft - prevRight;
-    if (gap > bestGap) {
-      bestGap = gap;
-      bestSplit = (prevRight + currLeft) / 2;
-    }
-  }
-  return bestSplit;
-}
-function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight) {
-  if (items.length === 0) return [];
-  let { horizontals, verticals } = extractLines(opList.fnArray, opList.argsArray);
-  ({ horizontals, verticals } = filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight));
-  ({ horizontals, verticals } = preprocessLines(horizontals, verticals));
-  const grids = buildTableGrids(horizontals, verticals);
-  if (grids.length > 0) {
-    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
-  }
-  return extractPageBlocksFallback(items, pageNum);
-}
-function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
-  const blocks = [];
-  const usedItems = /* @__PURE__ */ new Set();
-  const sortedGrids = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
-  for (const grid of sortedGrids) {
-    const numGridRows = grid.rowYs.length - 1;
-    const numGridCols = grid.colXs.length - 1;
-    if (numGridRows === 1 && numGridCols >= 2) continue;
-    const tableItems = [];
-    const pad = 3;
-    const gridW = grid.bbox.x2 - grid.bbox.x1;
-    for (const item of items) {
-      if (usedItems.has(item)) continue;
-      if (item.y < grid.bbox.y1 - pad || item.y > grid.bbox.y2 + pad) continue;
-      if (item.x < grid.bbox.x1 - pad || item.x + item.w > grid.bbox.x2 + pad) continue;
-      if (gridW < 120 && item.x + item.w > grid.bbox.x2 - 2) continue;
-      tableItems.push(item);
-      usedItems.add(item);
-    }
-    const cells = extractCells(grid, horizontals, verticals);
-    if (cells.length === 0) continue;
-    const textItems = tableItems.map((i) => ({
-      text: i.text,
-      x: i.x,
-      y: i.y,
-      w: i.w,
-      h: i.h,
-      fontSize: i.fontSize,
-      fontName: i.fontName
-    }));
-    const cellTextMap = mapTextToCells(textItems, cells);
-    const numRows = grid.rowYs.length - 1;
-    const numCols = grid.colXs.length - 1;
-    const irGrid = Array.from(
-      { length: numRows },
-      () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
-    );
-    for (const cell of cells) {
-      const cellItems = cellTextMap.get(cell) || [];
-      let text = cellTextToString(cellItems);
-      text = text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
-      text = text.split("\n").map((line) => collapseEvenSpacing(line)).join("\n");
-      irGrid[cell.row][cell.col] = {
-        text,
-        colSpan: cell.colSpan,
-        rowSpan: cell.rowSpan
-      };
-    }
-    const irTable = {
-      rows: numRows,
-      cols: numCols,
-      cells: irGrid,
-      hasHeader: numRows > 1
-    };
-    const hasContent = irGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
-    if (!hasContent) continue;
-    const tableBbox = {
-      page: pageNum,
-      x: grid.bbox.x1,
-      y: grid.bbox.y1,
-      width: grid.bbox.x2 - grid.bbox.x1,
-      height: grid.bbox.y2 - grid.bbox.y1
-    };
-    if (shouldDemoteTable(irTable)) {
-      const demoted = demoteTableToText(irTable);
-      if (demoted) {
-        const text = numGridRows === 1 ? "\n" + demoted + "\n" : demoted;
-        blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox: tableBbox, style: dominantStyle(tableItems) });
-      }
-      continue;
-    }
-    blocks.push({ type: "table", table: irTable, pageNumber: pageNum, bbox: tableBbox });
-  }
-  let remaining = items.filter((i) => !usedItems.has(i));
-  if (remaining.length > 0) {
-    remaining.sort((a, b) => b.y - a.y || a.x - b.x);
-    const clusterItems = remaining.map((i) => ({
-      text: i.text,
-      x: i.x,
-      y: i.y,
-      w: i.w,
-      h: i.h,
-      fontSize: i.fontSize,
-      fontName: i.fontName
-    }));
-    const clusterResults = detectClusterTables(clusterItems, pageNum);
-    if (clusterResults.length > 0) {
-      const ciToIdx = /* @__PURE__ */ new Map();
-      for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
-      const usedClusterIndices = /* @__PURE__ */ new Set();
-      for (const cr of clusterResults) {
-        for (const ci of cr.usedItems) {
-          const idx = ciToIdx.get(ci);
-          if (idx !== void 0) usedClusterIndices.add(idx);
-        }
-        blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
-      }
-      remaining = remaining.filter((_, idx) => !usedClusterIndices.has(idx));
-    }
-    if (remaining.length > 0) {
-      const allY = remaining.map((i) => i.y);
-      const pageH = safeMax(allY) - safeMin(allY);
-      const groups = xyCutOrder(remaining, Math.max(15, pageH * 0.03));
-      const textBlocks = [];
-      for (const group of groups) {
-        if (group.length === 0) continue;
-        const groupBlocks = extractPageBlocksFallback(group, pageNum);
-        for (const b of groupBlocks) textBlocks.push(b);
-      }
-      const finalTextBlocks = detectListBlocks(textBlocks);
-      for (const b of finalTextBlocks) blocks.push(b);
-    }
-    blocks.sort((a, b) => {
-      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
-      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
-      return by - ay;
-    });
-    return mergeAdjacentTableBlocks(blocks);
-  }
-  return mergeAdjacentTableBlocks(blocks);
-}
-function mergeAdjacentTableBlocks(blocks) {
-  if (blocks.length <= 1) return blocks;
-  const result = [blocks[0]];
-  for (let i = 1; i < blocks.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = blocks[i];
-    if (prev.type === "table" && curr.type === "table" && prev.table && curr.table && prev.table.cols === curr.table.cols) {
-      const merged = {
-        rows: prev.table.rows + curr.table.rows,
-        cols: prev.table.cols,
-        cells: [...prev.table.cells, ...curr.table.cells],
-        hasHeader: prev.table.hasHeader
-      };
-      result[result.length - 1] = { ...prev, table: merged };
-    } else {
-      result.push(curr);
-    }
-  }
+  walk(node);
   return result;
 }
-function extractPageBlocksFallback(items, pageNum) {
-  if (items.length === 0) return [];
-  const blocks = [];
-  const clusterItems = items.map((i) => ({
-    text: i.text,
-    x: i.x,
-    y: i.y,
-    w: i.w,
-    h: i.h,
-    fontSize: i.fontSize,
-    fontName: i.fontName
-  }));
-  const clusterResults = detectClusterTables(clusterItems, pageNum);
-  if (clusterResults.length > 0) {
-    const ciToIdx = /* @__PURE__ */ new Map();
-    for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
-    const usedIndices = /* @__PURE__ */ new Set();
-    for (const cr of clusterResults) {
-      for (const ci of cr.usedItems) {
-        const idx = ciToIdx.get(ci);
-        if (idx !== void 0) usedIndices.add(idx);
-      }
-      blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
-    }
-    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
-    if (remaining.length > 0) {
-      const yLines = groupByY(remaining);
-      for (const line of yLines) {
-        const text = mergeLineSimple(line);
-        if (!text.trim()) continue;
-        const bbox = computeBBox(line, pageNum);
-        blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
-      }
-    }
-    blocks.sort((a, b) => {
-      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
-      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
-      return by - ay;
-    });
-  } else {
-    const allYLines = groupByY(items);
-    const columns = detectColumns(allYLines);
-    if (columns && columns.length >= 3) {
-      const tableText = extractWithColumns(allYLines, columns);
-      const bbox = computeBBox(items, pageNum);
-      blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(items) });
-    } else {
-      const allY = items.map((i) => i.y);
-      const pageHeight = safeMax(allY) - safeMin(allY);
-      const gapThreshold = Math.max(15, pageHeight * 0.03);
-      const orderedGroups = xyCutOrder(items, gapThreshold);
-      for (const group of orderedGroups) {
-        if (group.length === 0) continue;
-        const yLines = groupByY(group);
-        const groupColumns = detectColumns(yLines);
-        if (groupColumns && groupColumns.length >= 3) {
-          const tableText = extractWithColumns(yLines, groupColumns);
-          const bbox = computeBBox(group, pageNum);
-          blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(group) });
-        } else {
-          for (const line of yLines) {
-            const text = mergeLineSimple(line);
-            if (!text.trim()) continue;
-            const bbox = computeBBox(line, pageNum);
-            blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
-          }
-        }
-      }
+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 detectSpecialKoreanTables(blocks);
+  return result;
 }
-function computeBBox(items, pageNum) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const i of items) {
-    if (i.x < minX) minX = i.x;
-    if (i.y < minY) minY = i.y;
-    if (i.x + i.w > maxX) maxX = i.x + i.w;
-    const effectiveH = i.h > 0 ? i.h : i.fontSize;
-    if (i.y + effectiveH > maxY) maxY = i.y + effectiveH;
+function isInsideTable(el) {
+  let parent = el.parentNode;
+  while (parent) {
+    if (parent.nodeType === 1 && localName(parent) === "tbl") return true;
+    parent = parent.parentNode;
   }
-  return { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  return false;
 }
-function dominantStyle(items) {
-  if (items.length === 0) return void 0;
-  const freq = /* @__PURE__ */ new Map();
-  let maxCount = 0, dominantSize = 0;
-  for (const i of items) {
-    if (i.fontSize <= 0) continue;
-    const count = (freq.get(i.fontSize) || 0) + 1;
-    freq.set(i.fontSize, count);
-    if (count > maxCount) {
-      maxCount = count;
-      dominantSize = i.fontSize;
-    }
-  }
-  if (dominantSize === 0) return void 0;
-  const fontName = items.find((i) => i.fontSize === dominantSize)?.fontName || void 0;
-  return { fontSize: dominantSize, fontName };
-}
-function normalizeItems(rawItems) {
-  const items = [];
-  const spacePositions = [];
-  for (const i of rawItems) {
-    if (typeof i.str !== "string") continue;
-    const x = Math.round(i.transform[4]);
-    const y = Math.round(i.transform[5]);
-    if (!i.str.trim()) {
-      spacePositions.push({ x, y });
-      continue;
-    }
-    const scaleY = Math.abs(i.transform[3]);
-    const scaleX = Math.abs(i.transform[0]);
-    const fontSize = Math.round(Math.max(scaleY, scaleX));
-    const w = Math.round(i.width);
-    const h = Math.round(i.height);
-    const isHidden = fontSize === 0 || i.width === 0 && i.str.trim().length > 0;
-    let text = i.str.trim();
-    if (/^[\d\s\-().·,☎]+$/.test(text) && /\d/.test(text) && / /.test(text)) {
-      text = text.replace(/ /g, "");
-    }
-    const split = splitEvenSpacedItem(text, x, w, fontSize);
-    if (split) {
-      for (const s of split) {
-        items.push({ text: s.text, x: s.x, y, w: s.w, h, fontSize, fontName: i.fontName || "", isHidden });
-      }
-    } else {
-      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden });
-    }
-  }
-  const sorted = items.sort((a, b) => b.y - a.y || a.x - b.x);
-  const deduped = [];
-  for (let i = 0; i < sorted.length; i++) {
-    let isDup = false;
-    for (let j = deduped.length - 1; j >= 0; j--) {
-      const prev = deduped[j];
-      if (prev.y - sorted[i].y > 3) break;
-      if (Math.abs(prev.y - sorted[i].y) <= 3 && prev.text === sorted[i].text && Math.abs(prev.x - sorted[i].x) <= 3) {
-        isDup = true;
-        break;
-      }
-    }
-    if (!isDup) deduped.push(sorted[i]);
-  }
-  if (spacePositions.length > 0) {
-    for (const item of deduped) {
-      for (const sp of spacePositions) {
-        if (Math.abs(sp.y - item.y) <= 3) {
-          const dist = item.x - sp.x;
-          if (dist >= 0 && dist <= 20) {
-            item.hasSpaceBefore = true;
-            break;
-          }
-        }
-      }
-    }
-  }
-  return deduped;
-}
-function splitEvenSpacedItem(text, itemX, itemW, fontSize) {
-  if (!/^[가-힣\d](?: [가-힣\d]){2,}$/.test(text)) return null;
-  const chars = text.split(" ");
-  if (chars.length < 3) return null;
-  const charW = itemW / chars.length;
-  if (charW > fontSize * 2) return null;
-  return chars.map((ch, idx) => ({
-    text: ch,
-    x: Math.round(itemX + idx * charW),
-    w: Math.round(charW * 0.8)
-    // 실제 글자 폭은 간격보다 좁음
-  }));
-}
-function groupByY(items) {
-  if (items.length === 0) return [];
-  const lines = [];
-  let curY = items[0].y;
-  let curLine = [items[0]];
-  for (let i = 1; i < items.length; i++) {
-    if (Math.abs(items[i].y - curY) > 3) {
-      lines.push(curLine);
-      curLine = [];
-      curY = items[i].y;
-    }
-    curLine.push(items[i]);
-  }
-  if (curLine.length > 0) lines.push(curLine);
-  return lines;
-}
-function isProseSpread(items) {
-  if (items.length < 4) return false;
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  const gaps = [];
-  for (let i = 1; i < sorted.length; i++) {
-    gaps.push(sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w));
-  }
-  const maxGap = safeMax(gaps);
-  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
-  return maxGap < 40 && avgLen < 5;
-}
-function detectColumns(yLines) {
-  const allItems = yLines.flat();
-  if (allItems.length === 0) return null;
-  const pageWidth = safeMax(allItems.map((i) => i.x + i.w)) - safeMin(allItems.map((i) => i.x));
-  if (pageWidth < 100) return null;
-  let bigoLineIdx = -1;
-  for (let i = 0; i < yLines.length; i++) {
-    if (yLines[i].length <= 2 && yLines[i].some((item) => item.text === "\uBE44\uACE0")) {
-      bigoLineIdx = i;
-      break;
-    }
-  }
-  const tableYLines = bigoLineIdx >= 0 ? yLines.slice(0, bigoLineIdx) : yLines;
-  const CLUSTER_TOL = 22;
-  const xClusters = [];
-  for (const line of tableYLines) {
-    if (isProseSpread(line)) continue;
-    for (const item of line) {
-      let found = false;
-      for (const c of xClusters) {
-        if (Math.abs(item.x - c.center) <= CLUSTER_TOL) {
-          c.center = Math.round((c.center * c.count + item.x) / (c.count + 1));
-          c.minX = Math.min(c.minX, item.x);
-          c.count++;
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        xClusters.push({ center: item.x, count: 1, minX: item.x });
+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");
       }
     }
-  }
-  const peaks = xClusters.filter((c) => c.count >= 3).sort((a, b) => a.minX - b.minX);
-  if (peaks.length < 3) return null;
-  const MERGE_TOL = 40;
-  const merged = [peaks[0]];
-  for (let i = 1; i < peaks.length; i++) {
-    const prev = merged[merged.length - 1];
-    if (peaks[i].minX - prev.minX < MERGE_TOL) {
-      if (peaks[i].count > prev.count) {
-        prev.center = peaks[i].center;
+  };
+  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]);
       }
-      prev.count += peaks[i].count;
-      prev.minX = Math.min(prev.minX, peaks[i].minX);
-    } else {
-      merged.push({ ...peaks[i] });
     }
   }
-  const rawColumns = merged.filter((c) => c.count >= 3).map((c) => c.minX);
-  if (rawColumns.length < 3) return null;
-  const MIN_DETECT_COL_WIDTH = 30;
-  const columns = [rawColumns[0]];
-  for (let i = 1; i < rawColumns.length; i++) {
-    if (rawColumns[i] - columns[columns.length - 1] < MIN_DETECT_COL_WIDTH) continue;
-    columns.push(rawColumns[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);
+    }
   }
-  return columns.length >= 3 ? columns : null;
 }
-function findColumn(x, columns) {
-  for (let i = columns.length - 1; i >= 0; i--) {
-    if (x >= columns[i] - 10) return i;
+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]);
+    }
   }
-  return 0;
 }
-function extractWithColumns(yLines, columns) {
+function clearChildren(el) {
+  while (el.firstChild) el.removeChild(el.firstChild);
+}
+function collectTextNodes(pEl) {
+  const tElements = findAllElements(pEl, "t");
   const result = [];
-  const colMin = columns[0];
-  const colMax = columns[columns.length - 1];
-  let bigoIdx = -1;
-  for (let i = 0; i < yLines.length; i++) {
-    if (yLines[i].length <= 2 && yLines[i].some((item) => item.text === "\uBE44\uACE0")) {
-      bigoIdx = i;
-      break;
-    }
+  let offset = 0;
+  for (const t of tElements) {
+    const text = t.textContent || "";
+    result.push({ element: t, text, offset });
+    offset += text.length;
   }
-  let tableStart = -1;
-  for (let i = 0; i < (bigoIdx >= 0 ? bigoIdx : yLines.length); i++) {
-    const usedCols = new Set(yLines[i].map((item) => findColumn(item.x, columns)));
-    if (usedCols.size >= 3) {
-      tableStart = i;
-      break;
+  return result;
+}
+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));
     }
   }
-  const tableEnd = bigoIdx >= 0 ? bigoIdx : yLines.length;
-  for (let i = 0; i < (tableStart >= 0 ? tableStart : tableEnd); i++) {
-    result.push(mergeLineSimple(yLines[i]));
+}
+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;
   }
-  if (tableStart >= 0) {
-    const tableLines = yLines.slice(tableStart, tableEnd);
-    const gridLines = [];
-    for (const line of tableLines) {
-      const inRange = line.some(
-        (item) => item.x >= colMin - 20 && item.x <= colMax + 200
-      );
-      if (inRange && !isProseSpread(line)) {
-        gridLines.push(line);
-      } else {
-        if (gridLines.length > 0) {
-          result.push(buildGridTable(gridLines.splice(0), columns));
-        }
-        result.push(mergeLineSimple(line));
-      }
-    }
-    if (gridLines.length > 0) {
-      result.push(buildGridTable(gridLines, columns));
-    }
+  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;
   }
-  if (bigoIdx >= 0) {
-    result.push("");
-    for (let i = bigoIdx; i < yLines.length; i++) {
-      result.push(mergeLineSimple(yLines[i]));
-    }
+  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--;
   }
-  return result.join("\n");
+  const newPart = replacedFull.slice(diffStart, diffEndRepl);
+  replaceTextRange(tNodes, diffStart, diffEndOrig, newPart);
 }
-function buildGridTable(lines, columns) {
-  const numCols = columns.length;
-  const yRows = lines.map((items) => {
-    const row = Array(numCols).fill("");
-    for (const item of items) {
-      const col = findColumn(item.x, columns);
-      row[col] = row[col] ? row[col] + " " + item.text : item.text;
-    }
-    return row;
-  });
-  const dataColStart = Math.max(2, Math.floor(numCols / 2));
-  const merged = [];
-  for (const row of yRows) {
-    if (row.every((c) => c === "")) continue;
-    if (merged.length === 0) {
-      merged.push([...row]);
+
+// src/hwpx/generator.ts
+import JSZip3 from "jszip";
+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";
+var NS_OPF = "http://www.idpf.org/2007/opf/";
+var NS_HPF = "http://www.hancom.co.kr/schema/2011/hpf";
+var NS_OCF = "urn:oasis:names:tc:opendocument:xmlns:container";
+var CHAR_NORMAL = 0;
+var CHAR_BOLD = 1;
+var CHAR_ITALIC = 2;
+var CHAR_BOLD_ITALIC = 3;
+var CHAR_CODE = 4;
+var CHAR_H1 = 5;
+var CHAR_H2 = 6;
+var CHAR_H3 = 7;
+var CHAR_H4 = 8;
+var PARA_NORMAL = 0;
+var PARA_H1 = 1;
+var PARA_H2 = 2;
+var PARA_H3 = 3;
+var PARA_H4 = 4;
+var PARA_CODE = 5;
+var PARA_QUOTE = 6;
+var PARA_LIST = 7;
+async function markdownToHwpx(markdown) {
+  const blocks = parseMarkdownToBlocks(markdown);
+  const sectionXml = blocksToSectionXml(blocks);
+  const zip = new JSZip3();
+  zip.file("mimetype", "application/hwp+zip", { compression: "STORE" });
+  zip.file("META-INF/container.xml", generateContainerXml());
+  zip.file("Contents/content.hpf", generateManifest());
+  zip.file("Contents/header.xml", generateHeaderXml());
+  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 prev = merged[merged.length - 1];
-    const filledCols = row.map((c, i) => c ? i : -1).filter((i) => i >= 0);
-    const filledCount = filledCols.length;
-    let isNewRow = false;
-    if (row[0] && row[0].length >= 3) {
-      isNewRow = true;
-    }
-    if (!isNewRow && numCols > 1 && row[1]) {
-      isNewRow = true;
-    }
-    if (!isNewRow) {
-      const hasData = row.slice(dataColStart).some((c) => c !== "");
-      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
-      if (hasData && prevHasData) {
-        isNewRow = true;
+    const fenceMatch = line.match(/^(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const fence = fenceMatch[1];
+      const lang = fenceMatch[2].trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith(fence)) {
+        codeLines.push(lines[i]);
+        i++;
       }
+      if (i < lines.length) i++;
+      blocks.push({ type: "code_block", text: codeLines.join("\n"), lang });
+      continue;
     }
-    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
-      isNewRow = false;
+    if (/^(\*{3,}|-{3,}|_{3,})\s*$/.test(line.trim())) {
+      blocks.push({ type: "hr" });
+      i++;
+      continue;
     }
-    if (isNewRow) {
-      merged.push([...row]);
-    } else {
-      for (let c = 0; c < numCols; c++) {
-        if (row[c]) {
-          prev[c] = prev[c] ? prev[c] + " " + row[c] : row[c];
-        }
-      }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      blocks.push({ type: "heading", text: headingMatch[2].trim(), level: headingMatch[1].length });
+      i++;
+      continue;
     }
-  }
-  if (merged.length < 2) {
-    return merged.map((r) => r.filter((c) => c).join(" ")).join("\n");
-  }
-  let headerEnd = 0;
-  for (let r = 0; r < merged.length; r++) {
-    const hasDataValues = merged[r].slice(dataColStart).some((c) => c && /\d/.test(c));
-    if (hasDataValues) break;
-    headerEnd = r + 1;
-  }
-  if (headerEnd > 1) {
-    const headerRow = Array(numCols).fill("");
-    for (let r = 0; r < headerEnd; r++) {
-      for (let c = 0; c < numCols; c++) {
-        if (merged[r][c]) {
-          headerRow[c] = headerRow[c] ? headerRow[c] + " " + merged[r][c] : merged[r][c];
+    if (line.trimStart().startsWith("|")) {
+      const tableRows = [];
+      while (i < lines.length && lines[i].trimStart().startsWith("|")) {
+        const row = lines[i];
+        if (/^[\s|:\-]+$/.test(row)) {
+          i++;
+          continue;
         }
+        const cells = row.split("|").slice(1, -1).map((c) => c.trim());
+        if (cells.length > 0) tableRows.push(cells);
+        i++;
       }
-    }
-    merged.splice(0, headerEnd, headerRow);
-  }
-  for (const row of merged) {
-    for (let c = 0; c < row.length; c++) {
-      if (row[c]) row[c] = collapseEvenSpacing(row[c]);
-    }
-  }
-  const totalCells = merged.length * numCols;
-  const filledCells = merged.reduce((s, row) => s + row.filter((c) => c).length, 0);
-  if (filledCells < totalCells * 0.35 || merged.length < 2 || merged.length <= 3 && numCols >= 7) {
-    return merged.map((r) => r.filter((c) => c).join("	")).join("\n");
-  }
-  const md = [];
-  md.push("| " + merged[0].join(" | ") + " |");
-  md.push("| " + merged[0].map(() => "---").join(" | ") + " |");
-  for (let r = 1; r < merged.length; r++) {
-    md.push("| " + merged[r].join(" | ") + " |");
-  }
-  return md.join("\n");
-}
-function mergeLineSimple(items) {
-  if (items.length <= 1) return items[0]?.text || "";
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  const isEvenSpaced = detectEvenSpacedItems(sorted);
-  let result = sorted[0].text;
-  for (let i = 1; i < sorted.length; i++) {
-    const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
-    const avgFs = (sorted[i].fontSize + sorted[i - 1].fontSize) / 2;
-    const tabThreshold = Math.max(avgFs * 2, 30);
-    if (gap > tabThreshold) {
-      result += "	";
-      result += sorted[i].text;
-      continue;
-    }
-    if (isEvenSpaced[i]) {
-      result += sorted[i].text;
+      if (tableRows.length > 0) blocks.push({ type: "table", rows: tableRows });
       continue;
     }
-    if (sorted[i].hasSpaceBefore && gap >= avgFs * 0.05) {
-      result += " ";
-      result += sorted[i].text;
+    if (line.trimStart().startsWith("> ")) {
+      const quoteLines = [];
+      while (i < lines.length && (lines[i].trimStart().startsWith("> ") || lines[i].trimStart().startsWith(">"))) {
+        quoteLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      for (const ql of quoteLines) {
+        blocks.push({ type: "blockquote", text: ql.trim() || "" });
+      }
       continue;
     }
-    if (/[□■○●▶◆◇ㅇ]$/.test(sorted[i - 1].text) && /^[가-힣]/.test(sorted[i].text) && gap > 1) {
-      result += " ";
-      result += sorted[i].text;
+    const listMatch = line.match(/^(\s*)([-*+]|\d+[.)]) (.+)$/);
+    if (listMatch) {
+      const indent = Math.floor(listMatch[1].length / 2);
+      const ordered = /\d/.test(listMatch[2]);
+      blocks.push({ type: "list_item", text: listMatch[3].trim(), ordered, indent });
+      i++;
       continue;
     }
-    if (gap < avgFs * 0.15) {
-    } else if (gap < avgFs * 0.35 && (/[가-힣]$/.test(result) || /^[가-힣]/.test(sorted[i].text))) {
-    } else if (gap > 3) result += " ";
-    result += sorted[i].text;
+    blocks.push({ type: "paragraph", text: line.trim() });
+    i++;
   }
-  return result;
-}
-function cleanPdfText(text) {
-  return mergeKoreanLines(
-    text.replace(/^\d{1,4}\n/, "").replace(/^[\s]*[-–—]\s*[-–—]?\d+[-–—]?[\s]*[-–—]?[\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "").replace(/\n\d{1,4}\n/g, "\n").replace(/\n\d{1,4}$/, "").replace(/^#{1,6}\s*\d{1,4}\s*$/gm, "")
-  ).replace(/^(?!\| ---).*$/gm, (line) => collapseEvenSpacing(line)).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\n{3,}/g, "\n\n").trim();
-}
-function startsWithMarker(line) {
-  const t = line.trimStart();
-  return /^[가-힣ㄱ-ㅎ][.)]/.test(t) || /^\d+[.)]/.test(t) || /^\([가-힣ㄱ-ㅎ\d]+\)/.test(t) || /^[○●※▶▷◆◇■□★☆\-·]\s/.test(t) || /^제\d+[조항호장절]/.test(t);
-}
-function isStandaloneHeader(line) {
-  return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(line.trim());
+  return blocks;
 }
-function detectListBlocks(blocks) {
-  const result = [];
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (block.type === "paragraph" && block.text) {
-      const text = block.text.trim();
-      if (/^\d+\.\s/.test(text)) {
-        result.push({ ...block, type: "list", listType: "ordered", text: block.text });
-        continue;
+function parseInlineMarkdown(text) {
+  text = text.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1");
+  text = text.replace(/\[([^\]]*)\]\(([^)]*)\)/g, (_, t, u) => t || u);
+  text = text.replace(/~~([^~]+)~~/g, "$1");
+  const spans = [];
+  const regex = /(`[^`]+`|\*{3}[^*]+\*{3}|\*{2}[^*]+\*{2}|\*[^*]+\*|_{2}[^_]+_{2}|_[^_]+_)/g;
+  let lastIdx = 0;
+  for (const match of text.matchAll(regex)) {
+    const idx = match.index;
+    if (idx > lastIdx) {
+      spans.push({ text: text.slice(lastIdx, idx), bold: false, italic: false, code: false });
+    }
+    const raw = match[0];
+    if (raw.startsWith("`")) {
+      spans.push({ text: raw.slice(1, -1), bold: false, italic: false, code: true });
+    } else if (raw.startsWith("***") || raw.startsWith("___")) {
+      spans.push({ text: raw.slice(3, -3), bold: true, italic: true, code: false });
+    } else if (raw.startsWith("**") || raw.startsWith("__")) {
+      spans.push({ text: raw.slice(2, -2), bold: true, italic: false, code: false });
+    } else {
+      spans.push({ text: raw.slice(1, -1), bold: false, italic: true, code: false });
+    }
+    lastIdx = idx + raw.length;
+  }
+  if (lastIdx < text.length) {
+    spans.push({ text: text.slice(lastIdx), bold: false, italic: false, code: false });
+  }
+  if (spans.length === 0) {
+    spans.push({ text, bold: false, italic: false, code: false });
+  }
+  return spans;
+}
+function spanToCharPrId(span) {
+  if (span.code) return CHAR_CODE;
+  if (span.bold && span.italic) return CHAR_BOLD_ITALIC;
+  if (span.bold) return CHAR_BOLD;
+  if (span.italic) return CHAR_ITALIC;
+  return CHAR_NORMAL;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateRuns(text, defaultCharPr = CHAR_NORMAL) {
+  const spans = parseInlineMarkdown(text);
+  return spans.map((span) => {
+    const charId = span.code || span.bold || span.italic ? spanToCharPrId(span) : defaultCharPr;
+    return `<hp:run charPrIDRef="${charId}"><hp:t>${escapeXml(span.text)}</hp:t></hp:run>`;
+  }).join("");
+}
+function generateParagraph(text, paraPrId = PARA_NORMAL, charPrId = CHAR_NORMAL) {
+  if (paraPrId === PARA_CODE) {
+    return `<hp:p paraPrIDRef="${paraPrId}" styleIDRef="0"><hp:run charPrIDRef="${CHAR_CODE}"><hp:t>${escapeXml(text)}</hp:t></hp:run></hp:p>`;
+  }
+  const runs = generateRuns(text, charPrId);
+  return `<hp:p paraPrIDRef="${paraPrId}" styleIDRef="0">${runs}</hp:p>`;
+}
+function headingParaPrId(level) {
+  if (level === 1) return PARA_H1;
+  if (level === 2) return PARA_H2;
+  if (level === 3) return PARA_H3;
+  return PARA_H4;
+}
+function headingCharPrId(level) {
+  if (level === 1) return CHAR_H1;
+  if (level === 2) return CHAR_H2;
+  if (level === 3) return CHAR_H3;
+  return CHAR_H4;
+}
+function generateContainerXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<ocf:container xmlns:ocf="${NS_OCF}" xmlns:hpf="${NS_HPF}">
+  <ocf:rootfiles>
+    <ocf:rootfile full-path="Contents/content.hpf" media-type="application/hwpml-package+xml"/>
+  </ocf:rootfiles>
+</ocf:container>`;
+}
+function generateManifest() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<opf:package xmlns:opf="${NS_OPF}" xmlns:hpf="${NS_HPF}" xmlns:hh="${NS_HEAD}">
+  <opf:manifest>
+    <opf:item id="header" href="Contents/header.xml" media-type="application/xml"/>
+    <opf:item id="section0" href="Contents/section0.xml" media-type="application/xml"/>
+  </opf:manifest>
+  <opf:spine>
+    <opf:itemref idref="header" linear="no"/>
+    <opf:itemref idref="section0" linear="yes"/>
+  </opf:spine>
+</opf:package>`;
+}
+function charPr(id, height, bold, italic, fontId = 0) {
+  const boldAttr = bold ? ` bold="1"` : "";
+  const italicAttr = italic ? ` italic="1"` : "";
+  return `      <hh:charPr id="${id}" height="${height}" textColor="#000000" shadeColor="none" useFontSpace="0" useKerning="0" symMark="NONE" borderFillIDRef="0"${boldAttr}${italicAttr}>
+        <hh:fontRef hangul="${fontId}" latin="${fontId}" hanja="${fontId}" japanese="${fontId}" other="${fontId}" symbol="${fontId}" user="${fontId}"/>
+        <hh:ratio hangul="100" latin="100" hanja="100" japanese="100" other="100" symbol="100" user="100"/>
+        <hh:spacing hangul="0" latin="0" hanja="0" japanese="0" other="0" symbol="0" user="0"/>
+        <hh:relSz hangul="100" latin="100" hanja="100" japanese="100" other="100" symbol="100" user="100"/>
+        <hh:offset hangul="0" latin="0" hanja="0" japanese="0" other="0" symbol="0" user="0"/>
+      </hh:charPr>`;
+}
+function paraPr(id, opts = {}) {
+  const { align = "JUSTIFY", spaceBefore = 0, spaceAfter = 0, lineSpacing = 160, indent = 0 } = opts;
+  return `      <hh:paraPr id="${id}" tabPrIDRef="0" condense="0" fontLineHeight="0" snapToGrid="1" suppressLineNumbers="0" checked="0" textDir="AUTO">
+        <hh:align horizontal="${align}" vertical="BASELINE"/>
+        <hh:heading type="NONE" idRef="0" level="0"/>
+        <hh:breakSetting breakLatinWord="KEEP_WORD" breakNonLatinWord="BREAK_WORD" widowOrphan="0" keepWithNext="0" keepLines="0" pageBreakBefore="0" lineWrap="BREAK"/>
+        <hh:autoSpacing eAsianEng="0" eAsianNum="0"/>
+        <hh:margin indent="${indent}" left="0" right="0" prev="${spaceBefore}" next="${spaceAfter}"/>
+        <hh:lineSpacing type="PERCENT" value="${lineSpacing}"/>
+        <hh:border borderFillIDRef="0" offsetLeft="0" offsetRight="0" offsetTop="0" offsetBottom="0" connect="0" ignoreMargin="0"/>
+      </hh:paraPr>`;
+}
+function generateHeaderXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<hh:head xmlns:hh="${NS_HEAD}" xmlns:hp="${NS_PARA}" version="1.4" secCnt="1">
+  <hh:beginNum page="1" footnote="1" endnote="1" pic="1" tbl="1" equation="1"/>
+  <hh:refList>
+    <hh:fontfaces itemCnt="7">
+      <hh:fontface lang="HANGUL" fontCnt="2">
+        <hh:font id="0" face="\uD568\uCD08\uB86C\uBC14\uD0D5" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="4" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+        <hh:font id="1" face="\uD568\uCD08\uB86C\uB3CB\uC6C0" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="4" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="LATIN" fontCnt="2">
+        <hh:font id="0" face="Times New Roman" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_OLDSTYLE" weight="5" proportion="4" contrast="2" strokeVariation="0" armStyle="0" letterform="0" midline="0" xHeight="4"/>
+        </hh:font>
+        <hh:font id="1" face="Consolas" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_MODERN" weight="5" proportion="0" contrast="0" strokeVariation="0" armStyle="0" letterform="0" midline="0" xHeight="0"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="HANJA" fontCnt="1">
+        <hh:font id="0" face="\uD568\uCD08\uB86C\uBC14\uD0D5" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="4" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="JAPANESE" fontCnt="1">
+        <hh:font id="0" face="\uAD74\uB9BC" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="OTHER" fontCnt="1">
+        <hh:font id="0" face="\uAD74\uB9BC" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="SYMBOL" fontCnt="1">
+        <hh:font id="0" face="Symbol" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+      <hh:fontface lang="USER" fontCnt="1">
+        <hh:font id="0" face="\uAD74\uB9BC" type="TTF" isEmbedded="0">
+          <hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/>
+        </hh:font>
+      </hh:fontface>
+    </hh:fontfaces>
+    <hh:borderFills itemCnt="1">
+      <hh:borderFill id="0" threeD="0" shadow="0" centerLine="0" breakCellSeparateLine="0">
+        <hh:slash type="NONE" Crooked="0" isCounter="0"/>
+        <hh:backSlash type="NONE" Crooked="0" isCounter="0"/>
+        <hh:leftBorder type="NONE" width="0.1mm" color="#000000"/>
+        <hh:rightBorder type="NONE" width="0.1mm" color="#000000"/>
+        <hh:topBorder type="NONE" width="0.1mm" color="#000000"/>
+        <hh:bottomBorder type="NONE" width="0.1mm" color="#000000"/>
+        <hh:diagonal type="NONE" width="0.1mm" color="#000000"/>
+        <hh:fillInfo/>
+      </hh:borderFill>
+    </hh:borderFills>
+    <hh:charProperties itemCnt="9">
+${charPr(0, 1e3, false, false)}
+${charPr(1, 1e3, true, false)}
+${charPr(2, 1e3, false, true)}
+${charPr(3, 1e3, true, true)}
+${charPr(4, 900, false, false, 1)}
+${charPr(5, 1800, true, false, 1)}
+${charPr(6, 1400, true, false, 1)}
+${charPr(7, 1200, true, false, 1)}
+${charPr(8, 1100, true, false, 1)}
+    </hh:charProperties>
+    <hh:tabProperties itemCnt="0"/>
+    <hh:numberings itemCnt="0"/>
+    <hh:bullets itemCnt="0"/>
+    <hh:paraProperties itemCnt="8">
+${paraPr(0)}
+${paraPr(1, { align: "LEFT", spaceBefore: 800, spaceAfter: 200, lineSpacing: 180 })}
+${paraPr(2, { align: "LEFT", spaceBefore: 600, spaceAfter: 150, lineSpacing: 170 })}
+${paraPr(3, { align: "LEFT", spaceBefore: 400, spaceAfter: 100, lineSpacing: 160 })}
+${paraPr(4, { align: "LEFT", spaceBefore: 300, spaceAfter: 100, lineSpacing: 160 })}
+${paraPr(5, { align: "LEFT", lineSpacing: 130, indent: 400 })}
+${paraPr(6, { align: "LEFT", lineSpacing: 150, indent: 600 })}
+${paraPr(7, { align: "LEFT", lineSpacing: 160, indent: 600 })}
+    </hh:paraProperties>
+    <hh:styles itemCnt="1">
+      <hh:style id="0" type="PARA" name="\uBC14\uD0D5\uAE00" engName="Normal" paraPrIDRef="0" charPrIDRef="0" nextStyleIDRef="0" langIDRef="1042" lockForm="0"/>
+    </hh:styles>
+  </hh:refList>
+  <hh:compatibleDocument targetProgram="HWP2018"/>
+</hh:head>`;
+}
+function generateSecPr() {
+  return `<hp:secPr textDirection="HORIZONTAL" spaceColumns="1134" tabStop="8000" outlineShapeIDRef="0" memoShapeIDRef="0" textVerticalWidthHead="0" masterPageCnt="0"><hp:grid lineGrid="0" charGrid="0" wonggojiFormat="0"/><hp:startNum pageStartsOn="BOTH" page="0" pic="0" tbl="0" equation="0"/><hp:visibility hideFirstHeader="0" hideFirstFooter="0" hideFirstMasterPage="0" border="SHOW_ALL" fill="SHOW_ALL" hideFirstPageNum="0" hideFirstEmptyLine="0" showLineNumber="0"/><hp:pagePr landscape="WIDELY" width="59528" height="84188" gutterType="LEFT_ONLY"><hp:margin header="2835" footer="2835" gutter="0" left="5670" right="4252" top="8504" bottom="4252"/></hp:pagePr><hp:footNotePr><hp:autoNumFormat type="DIGIT" userChar="" prefixChar="" suffixChar=")" supscript="0"/><hp:noteLine length="-1" type="SOLID" width="0.12 mm" color="#000000"/><hp:noteSpacing betweenNotes="283" belowLine="567" aboveLine="850"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="EACH_COLUMN" beneathText="0"/></hp:footNotePr><hp:endNotePr><hp:autoNumFormat type="DIGIT" userChar="" prefixChar="" suffixChar=")" supscript="0"/><hp:noteLine length="14692344" type="SOLID" width="0.12 mm" color="#000000"/><hp:noteSpacing betweenNotes="0" belowLine="567" aboveLine="850"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="END_OF_DOCUMENT" beneathText="0"/></hp:endNotePr></hp:secPr>`;
+}
+function generateTable(rows) {
+  const trElements = rows.map((row) => {
+    const tdElements = row.map((cell) => {
+      const runs = generateRuns(cell);
+      return `<hp:tc><hp:cellSpan colSpan="1" rowSpan="1"/><hp:p paraPrIDRef="0" styleIDRef="0">${runs}</hp:p></hp:tc>`;
+    }).join("");
+    return `<hp:tr>${tdElements}</hp:tr>`;
+  }).join("");
+  return `<hp:tbl>${trElements}</hp:tbl>`;
+}
+function blocksToSectionXml(blocks) {
+  const paraXmls = [];
+  let isFirst = true;
+  for (const block of blocks) {
+    let xml = "";
+    switch (block.type) {
+      case "heading": {
+        const pId = headingParaPrId(block.level || 1);
+        const cId = headingCharPrId(block.level || 1);
+        xml = generateParagraph(block.text || "", pId, cId);
+        break;
       }
-      if (/^[○●·※▶▷◆◇\-]\s/.test(text)) {
-        result.push({ ...block, type: "list", listType: "unordered", text: block.text });
-        continue;
+      case "paragraph":
+        xml = generateParagraph(block.text || "");
+        break;
+      case "code_block": {
+        const codeLines = (block.text || "").split("\n");
+        xml = codeLines.map((line) => generateParagraph(line || " ", PARA_CODE)).join("\n  ");
+        break;
       }
-    }
-    result.push(block);
-  }
-  return result;
-}
-var KOREAN_TABLE_HEADER_RE = /^\(?(구분|항목|종류|분류|유형|대상|내용|기간|금액|비율|방법|절차|요건|조건|근거|목적|범위|기준)\)?[:\s]/;
-var KV_FALSE_POSITIVE_RE = /\d{1,2}:\d{2}|:\/\/|\d+:\d+/;
-function detectSpecialKoreanTables(blocks) {
-  const result = [];
-  let kvLines = [];
-  const flushKvTable = () => {
-    if (kvLines.length < 2) {
-      for (const kv of kvLines) result.push(kv.block);
-      kvLines = [];
-      return;
-    }
-    const cells = kvLines.map((kv) => {
-      if (kv.value) {
-        return [
-          { text: kv.key, colSpan: 1, rowSpan: 1 },
-          { text: kv.value, colSpan: 1, rowSpan: 1 }
-        ];
+      case "blockquote":
+        xml = generateParagraph(block.text || "", PARA_QUOTE);
+        break;
+      case "list_item": {
+        const marker = block.ordered ? `${(block.indent || 0) + 1}. ` : "\xB7 ";
+        const indentPrefix = "  ".repeat(block.indent || 0);
+        xml = generateParagraph(indentPrefix + marker + (block.text || ""), PARA_LIST);
+        break;
       }
-      return [
-        { text: kv.key, colSpan: 2, rowSpan: 1 },
-        { text: "", colSpan: 1, rowSpan: 1 }
-      ];
-    });
-    const irTable = {
-      rows: cells.length,
-      cols: 2,
-      cells,
-      hasHeader: true
-    };
-    const firstBlock = kvLines[0].block;
-    result.push({
-      type: "table",
-      table: irTable,
-      pageNumber: firstBlock.pageNumber,
-      bbox: firstBlock.bbox
-    });
-    kvLines = [];
-  };
-  for (const block of blocks) {
-    if (block.type !== "paragraph" || !block.text) {
-      flushKvTable();
-      result.push(block);
-      continue;
-    }
-    const text = block.text.trim();
-    if (KOREAN_TABLE_HEADER_RE.test(text)) {
-      const colonIdx = text.indexOf(":");
-      if (colonIdx >= 0) {
-        kvLines.push({
-          key: text.slice(0, colonIdx).trim(),
-          value: text.slice(colonIdx + 1).trim(),
-          block
-        });
-      } else {
-        const spaceIdx = text.search(/\s/);
-        if (spaceIdx > 0) {
-          kvLines.push({
-            key: text.slice(0, spaceIdx).trim(),
-            value: text.slice(spaceIdx + 1).trim(),
-            block
-          });
-        } else {
-          kvLines.push({ key: text, value: "", block });
+      case "hr":
+        xml = `<hp:p paraPrIDRef="0" styleIDRef="0"><hp:run charPrIDRef="0"><hp:t>\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500</hp:t></hp:run></hp:p>`;
+        break;
+      case "table":
+        if (block.rows) {
+          if (isFirst) {
+            const secRun = `<hp:run charPrIDRef="0">${generateSecPr()}<hp:t></hp:t></hp:run>`;
+            paraXmls.push(`<hp:p paraPrIDRef="0" styleIDRef="0">${secRun}</hp:p>`);
+            isFirst = false;
+          }
+          xml = generateTable(block.rows);
         }
-      }
-      continue;
+        break;
     }
-    if (kvLines.length > 0 && text.includes(":")) {
-      if (!KV_FALSE_POSITIVE_RE.test(text) && !text.includes("(") && !text.includes(")")) {
-        const colonIdx = text.indexOf(":");
-        const key = text.slice(0, colonIdx).trim();
-        if (/^[가-힣]+$/.test(key) && key.length >= 2 && key.length <= 8) {
-          kvLines.push({
-            key,
-            value: text.slice(colonIdx + 1).trim(),
-            block
-          });
-          continue;
-        }
-      }
+    if (!xml) continue;
+    if (isFirst && block.type !== "table") {
+      xml = xml.replace(
+        /<hp:run charPrIDRef="(\d+)">/,
+        `<hp:run charPrIDRef="$1">${generateSecPr()}`
+      );
+      isFirst = false;
     }
-    flushKvTable();
-    result.push(block);
+    paraXmls.push(xml);
   }
-  flushKvTable();
-  return result;
-}
-function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
-  const ZONE_RATIO = 0.1;
-  const MIN_REPEAT = 3;
-  const headerTexts = /* @__PURE__ */ new Map();
-  const footerTexts = /* @__PURE__ */ new Map();
-  for (let bi = 0; bi < blocks.length; bi++) {
-    const b = blocks[bi];
-    if (!b.bbox || !b.pageNumber || !b.text?.trim()) continue;
-    const ph = pageHeights.get(b.bbox.page) || pageHeights.get(b.pageNumber);
-    if (!ph) continue;
-    const blockTop = ph - (b.bbox.y + b.bbox.height);
-    const blockBottom = ph - b.bbox.y;
-    if (blockBottom <= ph * ZONE_RATIO) {
-      const arr = footerTexts.get(b.pageNumber) || [];
-      arr.push(b.text.trim());
-      footerTexts.set(b.pageNumber, arr);
-    } else if (blockTop >= ph * (1 - ZONE_RATIO)) {
-      const arr = headerTexts.get(b.pageNumber) || [];
-      arr.push(b.text.trim());
-      headerTexts.set(b.pageNumber, arr);
-    }
-  }
-  const repeatedPatterns = /* @__PURE__ */ new Set();
-  for (const textsMap of [headerTexts, footerTexts]) {
-    const patternCount = /* @__PURE__ */ new Map();
-    for (const [, texts] of textsMap) {
-      for (const t of texts) {
-        const normalized = t.replace(/\d+/g, "#");
-        patternCount.set(normalized, (patternCount.get(normalized) || 0) + 1);
-      }
-    }
-    for (const [pattern, count] of patternCount) {
-      if (count >= MIN_REPEAT) repeatedPatterns.add(pattern);
-    }
-  }
-  if (repeatedPatterns.size === 0) return [];
-  const removeIndices = [];
-  for (let bi = 0; bi < blocks.length; bi++) {
-    const b = blocks[bi];
-    if (!b.bbox || !b.pageNumber || !b.text?.trim()) continue;
-    const ph = pageHeights.get(b.bbox.page) || pageHeights.get(b.pageNumber);
-    if (!ph) continue;
-    const blockTop = ph - (b.bbox.y + b.bbox.height);
-    const blockBottom = ph - b.bbox.y;
-    const inZone = blockBottom <= ph * ZONE_RATIO || blockTop >= ph * (1 - ZONE_RATIO);
-    if (!inZone) continue;
-    const normalized = b.text.trim().replace(/\d+/g, "#");
-    if (repeatedPatterns.has(normalized)) {
-      removeIndices.push(bi);
-    }
-  }
-  if (removeIndices.length > 0) {
-    warnings.push({ message: `${removeIndices.length}\uAC1C \uBA38\uB9AC\uAE00/\uBC14\uB2E5\uAE00 \uC694\uC18C \uC81C\uAC70\uB428`, code: "HIDDEN_TEXT_FILTERED" });
-  }
-  return removeIndices;
-}
-function mergeKoreanLines(text) {
-  if (!text) return "";
-  const lines = text.split("\n");
-  if (lines.length <= 1) return text;
-  const result = [lines[0]];
-  for (let i = 1; i < lines.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = lines[i];
-    const currTrimmed = curr.trim();
-    if (/^#{1,6}\s/.test(prev) || /^#{1,6}\s/.test(curr) || /^\|/.test(currTrimmed) || /^---/.test(currTrimmed)) {
-      result.push(curr);
-      continue;
-    }
-    if (/,$/.test(prev.trim()) && currTrimmed.length > 0) {
-      result[result.length - 1] = prev + "\n" + curr;
-      continue;
-    }
-    if (/^\(※/.test(currTrimmed)) {
-      result[result.length - 1] = prev + " " + currTrimmed;
-      continue;
-    }
-    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev) && !startsWithMarker(prev)) {
-      result[result.length - 1] = prev + " " + curr;
-    } else {
-      result.push(curr);
-    }
+  if (paraXmls.length === 0) {
+    paraXmls.push(`<hp:p paraPrIDRef="0" styleIDRef="0"><hp:run charPrIDRef="0">${generateSecPr()}<hp:t></hp:t></hp:run></hp:p>`);
   }
-  return result.join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<hs:sec xmlns:hs="${NS_SECTION}" xmlns:hp="${NS_PARA}">
+  ${paraXmls.join("\n  ")}
+</hs:sec>`;
 }
 
 // src/index.ts
 import { readFile } from "fs/promises";
 
 // src/xlsx/parser.ts
-import JSZip2 from "jszip";
-import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
+import JSZip4 from "jszip";
+import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 var MAX_SHEETS = 100;
 var MAX_DECOMPRESS_SIZE3 = 100 * 1024 * 1024;
 var MAX_ROWS2 = 1e4;
@@ -5231,7 +3583,7 @@ function getTextContent(el) {
   return el.textContent?.trim() ?? "";
 }
 function parseXml(text) {
-  return new DOMParser2().parseFromString(stripDtd(text), "text/xml");
+  return new DOMParser3().parseFromString(stripDtd(text), "text/xml");
 }
 function parseSharedStrings(xml) {
   const doc = parseXml(xml);
@@ -5384,7 +3736,7 @@ function sheetToBlocks(sheetName, grid, merges, maxRow, maxCol, sheetIndex) {
 }
 async function parseXlsxDocument(buffer, options) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE3);
-  const zip = await JSZip2.loadAsync(buffer);
+  const zip = await JSZip4.loadAsync(buffer);
   const warnings = [];
   const workbookFile = zip.file("xl/workbook.xml");
   if (!workbookFile) {
@@ -5474,24 +3826,24 @@ async function parseXlsxDocument(buffer, options) {
 }
 
 // src/docx/parser.ts
-import JSZip3 from "jszip";
-import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
+import JSZip5 from "jszip";
+import { DOMParser as DOMParser4 } from "@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;
@@ -5499,7 +3851,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);
@@ -5509,16 +3861,16 @@ 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;
 }
 function parseXml2(text) {
-  return new DOMParser3().parseFromString(stripDtd(text), "text/xml");
+  return new DOMParser4().parseFromString(stripDtd(text), "text/xml");
 }
 function parseStyles(xml) {
   const doc = parseXml2(xml);
@@ -5812,7 +4164,7 @@ async function extractImages(zip, rels, doc) {
 }
 async function parseDocxDocument(buffer, options) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE4);
-  const zip = await JSZip3.loadAsync(buffer);
+  const zip = await JSZip5.loadAsync(buffer);
   const warnings = [];
   const docFile = zip.file("word/document.xml");
   if (!docFile) {
@@ -5860,11 +4212,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);
     }
@@ -5902,135 +4254,6 @@ async function parseDocxDocument(buffer, options) {
   };
 }
 
-// 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 JSZip4 from "jszip";
-
 // src/index.ts
 async function parse(input, options) {
   let buffer;
@@ -6083,6 +4306,18 @@ async function parseHwp(buffer, options) {
   }
 }
 async function parsePdf(buffer, options) {
+  let parsePdfDocument;
+  try {
+    const mod = await import("./parser-PXD73E4H.js");
+    parsePdfDocument = mod.parsePdfDocument;
+  } catch {
+    return {
+      success: false,
+      fileType: "pdf",
+      error: "PDF \uD30C\uC2F1\uC5D0 pdfjs-dist\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. \uC124\uCE58: npm install pdfjs-dist",
+      code: "MISSING_DEPENDENCY"
+    };
+  }
   try {
     const { markdown, blocks, metadata, outline, warnings, isImageBased } = await parsePdfDocument(buffer, options);
     return { success: true, fileType: "pdf", markdown, blocks, metadata, outline, warnings, isImageBased };
@@ -6286,16 +4521,13 @@ function diffTableCells(a, b) {
 }
 
 export {
-  VERSION,
-  toArrayBuffer,
-  KordocError,
-  sanitizeError,
-  blocksToMarkdown,
   extractHwpxMetadataOnly,
   extractHwp5MetadataOnly,
-  extractPdfMetadataOnly,
-  compare,
   extractFormFields,
+  fillFormFields,
+  fillHwpx,
+  markdownToHwpx,
+  compare,
   parse
 };
-//# sourceMappingURL=chunk-AIG7SDWU.js.map
+//# sourceMappingURL=chunk-RQWICKON.js.map