kordoc 2.2.4 → 2.2.6

package/dist/{chunk-SY2RFVLW.js → chunk-RF6UJXR3.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-FCQEF2ZM.js";
 import {
   parsePageRange
 } from "./chunk-MOL7MDBG.js";
 
-// src/utils.ts
-var VERSION = true ? "2.2.4" : "0.0.0-dev";
-function toArrayBuffer(buf) {
-  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
-    return buf.buffer;
-  }
-  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,2382 +2513,122 @@ 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
-    )
-  };
-}
-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 });
-      }
-    }
-  }
-  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;
-      }
-    }
-    merged.push({ x: sumX / count, y: sumY / count, radius: maxRadius });
-  }
-  return merged;
-}
-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 });
-  }
-  return mergeAdjacentGrids(grids);
-}
-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;
-    }
-    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;
-    }
-    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;
-      }
-    }
-    merged.push(curr);
-  }
-  return merged;
-}
-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 });
-    }
-  }
-  return clusters.map((c) => c.sum / c.count);
-}
-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);
-      }
-    }
-  }
-  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()];
-}
-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;
-          }
-        }
-        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 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);
-    }
-  }
-  return result;
-}
-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;
-      } 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;
-      }
-    }
-    if (isShortKorean) {
-      if (runStart < 0) runStart = i;
-    } else {
-      if (runStart >= 0 && i - runStart >= 3) {
-        markEvenRun(items, result, runStart, i);
-      }
-      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);
-    }
-  }
-  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);
-      }
-    }
-  }
-  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);
-          }
-        }
-      }
-    }
-  }
-  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;
-          }
-        }
-      }
-      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;
-        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;
-      }
-    }
-  }
-  return matched.size;
-}
-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 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));
-  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;
-    }
-  };
-}
-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);
-    }
-  }
-  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) });
-          }
-        }
-      }
-    }
-  }
-  return detectSpecialKoreanTables(blocks);
-}
-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;
-  }
-  return { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-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 });
-      }
-    }
-  }
-  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;
-      }
-      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]);
-  }
-  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;
-  }
-  return 0;
-}
-function extractWithColumns(yLines, columns) {
-  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 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;
-    }
-  }
-  const tableEnd = bigoIdx >= 0 ? bigoIdx : yLines.length;
-  for (let i = 0; i < (tableStart >= 0 ? tableStart : tableEnd); i++) {
-    result.push(mergeLineSimple(yLines[i]));
-  }
-  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));
-    }
-  }
-  if (bigoIdx >= 0) {
-    result.push("");
-    for (let i = bigoIdx; i < yLines.length; i++) {
-      result.push(mergeLineSimple(yLines[i]));
-    }
-  }
-  return result.join("\n");
-}
-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]);
-      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;
-      }
-    }
-    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
-      isNewRow = false;
-    }
-    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];
-        }
-      }
-    }
-  }
-  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];
-        }
-      }
-    }
-    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;
-      continue;
-    }
-    if (sorted[i].hasSpaceBefore && gap >= avgFs * 0.05) {
-      result += " ";
-      result += sorted[i].text;
-      continue;
-    }
-    if (/[□■○●▶◆◇ㅇ]$/.test(sorted[i - 1].text) && /^[가-힣]/.test(sorted[i].text) && gap > 1) {
-      result += " ";
-      result += sorted[i].text;
-      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;
-  }
-  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());
-}
-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;
-      }
-      if (/^[○●·※▶▷◆◇\-]\s/.test(text)) {
-        result.push({ ...block, type: "list", listType: "unordered", text: block.text });
-        continue;
-      }
-    }
-    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 }
-        ];
-      }
-      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 });
-        }
-      }
-      continue;
-    }
-    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;
-        }
-      }
-    }
-    flushKvTable();
-    result.push(block);
-  }
-  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);
-    }
-  }
-  return result.join("\n");
-}
-
-// 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;
-  }
-  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 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)) {
-          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;
+  return fields;
 }
 function extractInlineFields(text) {
   const fields = [];
@@ -6982,6 +4306,18 @@ async function parseHwp(buffer, options) {
   }
 }
 async function parsePdf(buffer, options) {
+  let parsePdfDocument;
+  try {
+    const mod = await import("./parser-AMP7MAOH.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 };
@@ -7185,14 +4521,8 @@ function diffTableCells(a, b) {
 }
 
 export {
-  VERSION,
-  toArrayBuffer,
-  KordocError,
-  sanitizeError,
-  blocksToMarkdown,
   extractHwpxMetadataOnly,
   extractHwp5MetadataOnly,
-  extractPdfMetadataOnly,
   extractFormFields,
   fillFormFields,
   fillHwpx,
@@ -7200,4 +4530,4 @@ export {
   compare,
   parse
 };
-//# sourceMappingURL=chunk-SY2RFVLW.js.map
+//# sourceMappingURL=chunk-RF6UJXR3.js.map