kordoc 3.8.0 → 3.8.2

package/dist/{parser-DCK42RMA.js → parser-NR2TYGO3.js}

@@ -6,41 +6,44 @@ import {
   blocksToMarkdown,
   safeMax,
   safeMin
-} from "./chunk-QV25HMU7.js";
+} from "./chunk-553VTUVP.js";
 import {
   parsePageRange
 } from "./chunk-GE43BE46.js";
 
-// src/pdf/line-detector.ts
+// src/pdf/line-extract.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 ctm = [1, 0, 0, 1, 0, 0];
+  const ctmStack = [];
+  const applyCtm = (x, y) => [ctm[0] * x + ctm[2] * y + ctm[4], ctm[1] * x + ctm[3] * y + ctm[5]];
+  const ctmScale = () => (Math.hypot(ctm[0], ctm[1]) + Math.hypot(ctm[2], ctm[3])) / 2;
   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 });
+  function pushSeg(x1, y1, x2, y2) {
+    const [tx1, ty1] = applyCtm(x1, y1);
+    const [tx2, ty2] = applyCtm(x2, y2);
+    currentPath.push({ x1: tx1, y1: ty1, x2: tx2, y2: ty2 });
+  }
+  function pushRectangle(rx, ry, rw, rh) {
+    const effH = Math.abs(rh) * Math.hypot(ctm[2], ctm[3]);
+    const effW = Math.abs(rw) * Math.hypot(ctm[0], ctm[1]);
+    if (effH < ORIENTATION_TOL * 2) {
+      pushSeg(rx, ry + rh / 2, rx + rw, ry + rh / 2);
+    } else if (effW < ORIENTATION_TOL * 2) {
+      pushSeg(rx + rw / 2, ry, rx + rw / 2, 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 }
-      );
+      pushSeg(rx, ry, rx + rw, ry);
+      pushSeg(rx + rw, ry, rx + rw, ry + rh);
+      pushSeg(rx + rw, ry + rh, rx, ry + rh);
+      pushSeg(rx, ry + rh, rx, ry);
     }
   }
   function flushPath(isStroke) {
@@ -48,8 +51,9 @@ function extractLines(fnArray, argsArray) {
       currentPath = [];
       return;
     }
+    const effWidth = lineWidth * ctmScale();
     for (const seg of currentPath) {
-      classifyAndAdd(seg, lineWidth, horizontals, verticals);
+      classifyAndAdd(seg, effWidth, horizontals, verticals);
     }
     currentPath = [];
   }
@@ -60,6 +64,24 @@ function extractLines(fnArray, argsArray) {
       case OPS.setLineWidth:
         lineWidth = args[0] || 1;
         break;
+      case OPS.save:
+        ctmStack.push(ctm.slice());
+        break;
+      case OPS.restore:
+        ctm = ctmStack.pop() ?? [1, 0, 0, 1, 0, 0];
+        break;
+      case OPS.transform: {
+        const t = args;
+        ctm = [
+          ctm[0] * t[0] + ctm[2] * t[1],
+          ctm[1] * t[0] + ctm[3] * t[1],
+          ctm[0] * t[2] + ctm[2] * t[3],
+          ctm[1] * t[2] + ctm[3] * t[3],
+          ctm[0] * t[4] + ctm[2] * t[5] + ctm[4],
+          ctm[1] * t[4] + ctm[3] * t[5] + ctm[5]
+        ];
+        break;
+      }
       case OPS.constructPath: {
         const arg0 = args[0];
         if (Array.isArray(arg0)) {
@@ -74,16 +96,16 @@ function extractLines(fnArray, argsArray) {
               pathStartY = curY;
             } else if (subOp === OPS.lineTo) {
               const x2 = coords[ci++], y2 = coords[ci++];
-              currentPath.push({ x1: curX, y1: curY, x2, y2 });
+              pushSeg(curX, 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);
+              pushRectangle(rx, ry, rw, rh);
             } else if (subOp === OPS.closePath) {
               if (curX !== pathStartX || curY !== pathStartY) {
-                currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+                pushSeg(curX, curY, pathStartX, pathStartY);
               }
               curX = pathStartX;
               curY = pathStartY;
@@ -109,7 +131,7 @@ function extractLines(fnArray, argsArray) {
                 pathStartY = curY;
               } else if (drawOp === 1 /* lineTo */) {
                 const x2 = pathData[di++], y2 = pathData[di++];
-                currentPath.push({ x1: curX, y1: curY, x2, y2 });
+                pushSeg(curX, curY, x2, y2);
                 curX = x2;
                 curY = y2;
               } else if (drawOp === 2 /* curveTo */) {
@@ -118,7 +140,7 @@ function extractLines(fnArray, argsArray) {
                 di += 4;
               } else if (drawOp === 4 /* closePath */) {
                 if (curX !== pathStartX || curY !== pathStartY) {
-                  currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+                  pushSeg(curX, curY, pathStartX, pathStartY);
                 }
                 curX = pathStartX;
                 curY = pathStartY;
@@ -156,55 +178,6 @@ function extractLines(fnArray, argsArray) {
   }
   return { horizontals, verticals };
 }
-function multiplyTransform(m, t) {
-  return [
-    m[0] * t[0] + m[2] * t[1],
-    m[1] * t[0] + m[3] * t[1],
-    m[0] * t[2] + m[2] * t[3],
-    m[1] * t[2] + m[3] * t[3],
-    m[0] * t[4] + m[2] * t[5] + m[4],
-    m[1] * t[4] + m[3] * t[5] + m[5]
-  ];
-}
-function extractImageRegions(fnArray, argsArray) {
-  const regions = [];
-  let ctm = [1, 0, 0, 1, 0, 0];
-  const stack = [];
-  for (let i = 0; i < fnArray.length; i++) {
-    const op = fnArray[i];
-    switch (op) {
-      case OPS.save:
-        stack.push(ctm);
-        break;
-      case OPS.restore:
-        ctm = stack.pop() || [1, 0, 0, 1, 0, 0];
-        break;
-      case OPS.transform: {
-        const t = argsArray[i];
-        if (Array.isArray(t) && t.length >= 6) ctm = multiplyTransform(ctm, t);
-        break;
-      }
-      case OPS.paintImageXObject:
-      case OPS.paintInlineImageXObject:
-      case OPS.paintImageMaskXObject:
-      case OPS.paintImageXObjectRepeat: {
-        const corners = [[0, 0], [1, 0], [0, 1], [1, 1]];
-        let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
-        for (const [u, v] of corners) {
-          const x = ctm[0] * u + ctm[2] * v + ctm[4];
-          const y = ctm[1] * u + ctm[3] * v + ctm[5];
-          if (x < x1) x1 = x;
-          if (x > x2) x2 = x;
-          if (y < y1) y1 = y;
-          if (y > y2) y2 = y;
-        }
-        if (x2 - x1 > 0 && y2 - y1 > 0) regions.push({ x1, y1, x2, y2 });
-        break;
-      }
-    }
-  }
-  return regions;
-}
 function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
   const dx = Math.abs(seg.x2 - seg.x1);
   const dy = Math.abs(seg.y2 - seg.y1);
@@ -282,6 +255,67 @@ function filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight) {
     )
   };
 }
+
+// src/pdf/image-regions.ts
+import { OPS as OPS2 } from "pdfjs-dist/legacy/build/pdf.mjs";
+function multiplyTransform(m, t) {
+  return [
+    m[0] * t[0] + m[2] * t[1],
+    m[1] * t[0] + m[3] * t[1],
+    m[0] * t[2] + m[2] * t[3],
+    m[1] * t[2] + m[3] * t[3],
+    m[0] * t[4] + m[2] * t[5] + m[4],
+    m[1] * t[4] + m[3] * t[5] + m[5]
+  ];
+}
+function extractImageRegions(fnArray, argsArray) {
+  const regions = [];
+  let ctm = [1, 0, 0, 1, 0, 0];
+  const stack = [];
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    switch (op) {
+      case OPS2.save:
+        stack.push(ctm);
+        break;
+      case OPS2.restore:
+        ctm = stack.pop() || [1, 0, 0, 1, 0, 0];
+        break;
+      case OPS2.transform: {
+        const t = argsArray[i];
+        if (Array.isArray(t) && t.length >= 6) ctm = multiplyTransform(ctm, t);
+        break;
+      }
+      case OPS2.paintImageXObject:
+      case OPS2.paintInlineImageXObject:
+      case OPS2.paintImageMaskXObject:
+      case OPS2.paintImageXObjectRepeat: {
+        const corners = [[0, 0], [1, 0], [0, 1], [1, 1]];
+        let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+        for (const [u, v] of corners) {
+          const x = ctm[0] * u + ctm[2] * v + ctm[4];
+          const y = ctm[1] * u + ctm[3] * v + ctm[5];
+          if (x < x1) x1 = x;
+          if (x > x2) x2 = x;
+          if (y < y1) y1 = y;
+          if (y > y2) y2 = y;
+        }
+        if (x2 - x1 > 0 && y2 - y1 > 0) regions.push({ x1, y1, x2, y2 });
+        break;
+      }
+    }
+  }
+  return regions;
+}
+
+// src/pdf/line-types.ts
+var VERTEX_MERGE_FACTOR = 4;
+
+// src/pdf/table-grid.ts
+var CONNECT_TOL = 5;
+var MIN_COL_WIDTH = 15;
+var MIN_ROW_HEIGHT = 6;
+var MIN_COORD_MERGE_TOL = 8;
 function buildVertices(horizontals, verticals) {
   const vertices = [];
   const tol = CONNECT_TOL;
@@ -493,6 +527,8 @@ function linesIntersect(a, b) {
   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;
 }
+
+// src/pdf/cell-extract.ts
 function extractCells(grid, horizontals, verticals) {
   const { rowYs, colXs } = grid;
   const numRows = rowYs.length - 1;
@@ -590,6 +626,9 @@ function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
   }
   return false;
 }
+
+// src/pdf/cell-text.ts
+var CELL_PADDING = 2;
 var SPACE_GAP_RATIO = 0.17;
 function spaceGapThreshold(fontSize) {
   return Math.max(fontSize * SPACE_GAP_RATIO, 1);
@@ -718,6 +757,28 @@ function markEvenRun(items, result, start, end) {
     }
   }
 }
+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/undersegmented.ts
 var MAX_UNDERSEGMENTED_ROWS = 2;
 var MIN_UNDERSEGMENTED_COLUMNS = 3;
 var MIN_UNDERSEGMENTED_TEXT_LINES = 8;
@@ -831,977 +892,822 @@ function normalizeUndersegmentedTable(originalCells, colXs, items) {
   if (countNonEmptyCols(rebuilt, numCols) < countNonEmptyCols(originalCells, numCols)) return null;
   return rebuilt;
 }
-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 = mergeOverlappingRows(groupByBaseline(merged));
-  if (rows.length < MIN_ROWS) return [];
-  const results = [];
-  const headerResult = detectHeaderRow(rows);
-  if (headerResult) {
-    const { columns, headerIdx } = headerResult;
-    const headerRow = rows[headerIdx];
-    const headerItems = [...headerRow.items].sort((a, b) => a.x - b.x);
-    const headerAndBelow = rows.slice(headerIdx);
-    const mergedRows = mergeMultiLineRows(headerAndBelow, columns);
-    const tableRegions = findTableRegionsByHeader(mergedRows, columns, headerItems);
-    for (const region of tableRegions) {
-      const table = buildClusterTable(region.rows, columns, pageNum);
-      if (table) {
-        expandUsedItems(table.usedItems, originMap);
-        results.push(table);
-      }
+// src/pdf/quality.ts
+function computePageQuality(page, text) {
+  let total = 0;
+  let hangul = 0;
+  let control = 0;
+  let replacement = 0;
+  let pua = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 32 || code === 9 || code === 10 || code === 13) continue;
+    total++;
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) {
+      control++;
+      continue;
     }
-  }
-  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);
-          }
-        }
-      }
+    if (code === 65533) {
+      replacement++;
+      continue;
+    }
+    if (code >= 44032 && code <= 55203) {
+      hangul++;
+      continue;
+    }
+    if (code >= 57344 && code <= 63743 || code >= 56192 && code <= 56319) {
+      pua++;
+      continue;
     }
   }
-  return results;
+  const denom = total || 1;
+  const puaRatio = pua / denom;
+  const controlCharRatio = control / denom;
+  const replacementCharRatio = replacement / denom;
+  let needsOcr = false;
+  let ocrReason;
+  if (total < LOW_TEXT_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "low_text";
+  } else if (puaRatio >= HIGH_PUA_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_pua";
+  } else if (controlCharRatio >= HIGH_CONTROL_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_control";
+  } else if (replacementCharRatio >= HIGH_REPLACEMENT_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_replacement";
+  }
+  return {
+    page,
+    textChars: total,
+    hangulRatio: hangul / denom,
+    controlCharRatio,
+    replacementCharRatio,
+    puaRatio,
+    needsOcr,
+    ocrReason
+  };
 }
-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)) {
-          if (sorted[runEnd].hasSpaceBefore) break;
-          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);
+var LOW_TEXT_THRESHOLD = 20;
+var HIGH_PUA_THRESHOLD = 0.2;
+var HIGH_CONTROL_THRESHOLD = 0.05;
+var HIGH_REPLACEMENT_THRESHOLD = 0.05;
+var DOC_NEEDS_OCR_PAGE_RATIO = 0.3;
+function stripControlChars(text) {
+  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\x80-\x9F]/g, "");
 }
-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;
+function summarizeDocumentQuality(pages) {
+  if (pages.length === 0) {
+    return {
+      totalPages: 0,
+      totalTextChars: 0,
+      avgHangulRatio: 0,
+      avgControlCharRatio: 0,
+      avgReplacementCharRatio: 0,
+      avgPuaRatio: 0,
+      lowTextPageCount: 0,
+      highPuaPageCount: 0,
+      needsOcr: false,
+      ocrCandidatePages: []
+    };
   }
-  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 };
+  let textChars = 0;
+  let hangul = 0;
+  let control = 0;
+  let replacement = 0;
+  let pua = 0;
+  let lowText = 0;
+  let highPua = 0;
+  const ocrCandidatePages = [];
+  for (const p of pages) {
+    textChars += p.textChars;
+    hangul += p.hangulRatio;
+    control += p.controlCharRatio;
+    replacement += p.replacementCharRatio;
+    pua += p.puaRatio;
+    if (p.textChars < LOW_TEXT_THRESHOLD) lowText++;
+    if (p.puaRatio >= HIGH_PUA_THRESHOLD) highPua++;
+    if (p.needsOcr) ocrCandidatePages.push(p.page);
   }
-  return null;
+  const n = pages.length;
+  return {
+    totalPages: n,
+    totalTextChars: textChars,
+    avgHangulRatio: hangul / n,
+    avgControlCharRatio: control / n,
+    avgReplacementCharRatio: replacement / n,
+    avgPuaRatio: pua / n,
+    lowTextPageCount: lowText,
+    highPuaPageCount: highPua,
+    needsOcr: ocrCandidatePages.length / n >= DOC_NEEDS_OCR_PAGE_RATIO,
+    ocrCandidatePages
+  };
 }
-function mergeOverlappingRows(rows) {
-  if (rows.length <= 1) return rows;
-  const result = [rows[0]];
-  for (let i = 1; i < rows.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = rows[i];
-    const a = rowBand(prev);
-    const b = rowBand(curr);
-    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-    const prevIsFrag = isFragmentRow(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
-    const currIsFrag = isFragmentRow(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
-    if (prevIsFrag || currIsFrag) {
-      const baseY = prevIsFrag ? curr.y : prev.y;
-      result[result.length - 1] = { y: baseY, items: [...prev.items, ...curr.items] };
-    } else {
-      result.push(curr);
+
+// src/pdf/text-line.ts
+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 result;
-}
-function isFragmentRow(row) {
-  return row.items.length <= 3 && row.items.every((i) => i.text.length <= 8);
+  return { visible, hiddenCount };
 }
-function rowBand(row) {
-  let bottom = Infinity, top = -Infinity;
-  for (const i of row.items) {
-    const h = i.h > 0 ? i.h : i.fontSize;
-    if (i.y < bottom) bottom = i.y;
-    if (i.y + h > top) top = i.y + h;
+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 { bottom, top, height: top - bottom };
+  return text.replace(
+    /(?<![가-힣])[가-힣](?: [가-힣\d]){2,}(?![가-힣])/g,
+    (match) => match.replace(/ /g, "")
+  );
 }
-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);
-    }
+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 result;
+  return { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-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;
+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 (curItems.length > 0) rows.push({ y: curY, items: curItems });
-  return rows;
+  if (dominantSize === 0) return void 0;
+  const fontName = items.find((i) => i.fontSize === dominantSize)?.fontName || void 0;
+  return { fontSize: dominantSize, fontName };
 }
-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;
+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 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;
+    const scaleX = Math.hypot(i.transform[0], i.transform[1]);
+    const scaleY = Math.hypot(i.transform[2], i.transform[3]);
+    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, "");
     }
-  }
-  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);
+    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 {
-      if (currentRegion.length >= MIN_ROWS) {
-        regions.push({ rows: [...currentRegion] });
-      }
-      currentRegion = [];
+      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden });
     }
   }
-  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);
+  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]);
   }
-  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;
+  if (spacePositions.length > 0) {
+    for (const sp of spacePositions) {
+      let nearest = null;
+      for (const item of deduped) {
+        if (Math.abs(sp.y - item.y) > 3) continue;
+        const dist = item.x - sp.x;
+        if (dist >= -1 && dist <= 20 && (!nearest || item.x < nearest.x)) {
+          nearest = item;
+        }
       }
+      if (nearest) nearest.hasSpaceBefore = true;
     }
   }
-  return matched.size;
+  return deduped;
 }
-function assignRowItems(items, columns, numCols) {
+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 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]) });
+  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]);
   }
-  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;
-      }
+  if (curLine.length > 0) lines.push(curLine);
+  return lines;
+}
+function mergeSuperscriptLines(lines) {
+  if (lines.length <= 1) return lines;
+  const band = (line) => {
+    let bottom = Infinity, top = -Infinity;
+    for (const i of line) {
+      const h = i.h > 0 ? i.h : i.fontSize;
+      if (i.y < bottom) bottom = i.y;
+      if (i.y + h > top) top = i.y + h;
+    }
+    return { bottom, top, height: top - bottom };
+  };
+  const isFrag = (line) => line.length <= 3 && line.every((i) => i.text.trim().length <= 8);
+  const result = [lines[0]];
+  for (let i = 1; i < lines.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = lines[i];
+    const a = band(prev);
+    const b = band(curr);
+    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
+    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    if (prevIsFrag || currIsFrag) {
+      result[result.length - 1] = [...prev, ...curr];
+    } else {
+      result.push(curr);
     }
-    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]);
+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;
     }
-    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);
+    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 > spaceGapThreshold(avgFs)) result += " ";
+    result += sorted[i].text;
   }
-  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;
+  return result;
+}
+
+// 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 = mergeOverlappingRows(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);
+      }
+    }
   }
-  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;
+  if (results.length === 0) {
+    const suspiciousRows = rows.filter((row) => hasSuspiciousGaps(row));
+    if (suspiciousRows.length >= MIN_ROWS) {
+      const columns = extractColumnClusters(suspiciousRows);
+      if (columns.length >= MIN_COLS) {
+        const tableRegions = findTableRegions(rows, columns);
+        for (const region of tableRegions) {
+          const mergedRows = mergeMultiLineRows(region.rows, columns);
+          const table = buildClusterTable(mergedRows, columns, pageNum);
+          if (table) {
+            expandUsedItems(table.usedItems, originMap);
+            results.push(table);
+          }
         }
-        for (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;
+  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)) {
+          if (sorted[runEnd].hasSpaceBefore) break;
+          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;
+          }
         }
-        for (let c = 0; c < numCols; c++) next[c].text = "";
       }
+      merged.push(sorted[i]);
+      i++;
     }
   }
-  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
-  };
+  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);
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  if (allItems.length === 0) return null;
+  let allMinX = Infinity, allMaxX = -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;
+    if (i.x < allMinX) allMinX = i.x;
+    const r = i.x + i.w;
+    if (r > allMaxX) allMaxX = r;
   }
-  return {
-    table: irTable,
-    bbox: { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY },
-    usedItems
-  };
-}
-
-// src/pdf/quality.ts
-function computePageQuality(page, text) {
-  let total = 0;
-  let hangul = 0;
-  let control = 0;
-  let replacement = 0;
-  let pua = 0;
-  for (let i = 0; i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code === 32 || code === 9 || code === 10 || code === 13) continue;
-    total++;
-    if (code < 32 || code === 127 || code >= 128 && code <= 159) {
-      control++;
-      continue;
-    }
-    if (code === 65533) {
-      replacement++;
-      continue;
+  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 (code >= 44032 && code <= 55203) {
-      hangul++;
-      continue;
-    }
-    if (code >= 57344 && code <= 63743 || code >= 56192 && code <= 56319) {
-      pua++;
-      continue;
+    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 };
   }
-  const denom = total || 1;
-  const puaRatio = pua / denom;
-  const controlCharRatio = control / denom;
-  const replacementCharRatio = replacement / denom;
-  let needsOcr = false;
-  let ocrReason;
-  if (total < LOW_TEXT_THRESHOLD) {
-    needsOcr = true;
-    ocrReason = "low_text";
-  } else if (puaRatio >= HIGH_PUA_THRESHOLD) {
-    needsOcr = true;
-    ocrReason = "high_pua";
-  } else if (controlCharRatio >= HIGH_CONTROL_THRESHOLD) {
-    needsOcr = true;
-    ocrReason = "high_control";
-  } else if (replacementCharRatio >= HIGH_REPLACEMENT_THRESHOLD) {
-    needsOcr = true;
-    ocrReason = "high_replacement";
+  return null;
+}
+function mergeOverlappingRows(rows) {
+  if (rows.length <= 1) return rows;
+  const result = [rows[0]];
+  for (let i = 1; i < rows.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = rows[i];
+    const a = rowBand(prev);
+    const b = rowBand(curr);
+    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFragmentRow(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
+    const currIsFrag = isFragmentRow(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    if (prevIsFrag || currIsFrag) {
+      const baseY = prevIsFrag ? curr.y : prev.y;
+      result[result.length - 1] = { y: baseY, items: [...prev.items, ...curr.items] };
+    } else {
+      result.push(curr);
+    }
   }
-  return {
-    page,
-    textChars: total,
-    hangulRatio: hangul / denom,
-    controlCharRatio,
-    replacementCharRatio,
-    puaRatio,
-    needsOcr,
-    ocrReason
-  };
+  return result;
 }
-var LOW_TEXT_THRESHOLD = 20;
-var HIGH_PUA_THRESHOLD = 0.2;
-var HIGH_CONTROL_THRESHOLD = 0.05;
-var HIGH_REPLACEMENT_THRESHOLD = 0.05;
-var DOC_NEEDS_OCR_PAGE_RATIO = 0.3;
-function stripControlChars(text) {
-  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\x80-\x9F]/g, "");
+function isFragmentRow(row) {
+  return row.items.length <= 3 && row.items.every((i) => i.text.length <= 8);
 }
-function summarizeDocumentQuality(pages) {
-  if (pages.length === 0) {
-    return {
-      totalPages: 0,
-      totalTextChars: 0,
-      avgHangulRatio: 0,
-      avgControlCharRatio: 0,
-      avgReplacementCharRatio: 0,
-      avgPuaRatio: 0,
-      lowTextPageCount: 0,
-      highPuaPageCount: 0,
-      needsOcr: false,
-      ocrCandidatePages: []
-    };
+function rowBand(row) {
+  let bottom = Infinity, top = -Infinity;
+  for (const i of row.items) {
+    const h = i.h > 0 ? i.h : i.fontSize;
+    if (i.y < bottom) bottom = i.y;
+    if (i.y + h > top) top = i.y + h;
   }
-  let textChars = 0;
-  let hangul = 0;
-  let control = 0;
-  let replacement = 0;
-  let pua = 0;
-  let lowText = 0;
-  let highPua = 0;
-  const ocrCandidatePages = [];
-  for (const p of pages) {
-    textChars += p.textChars;
-    hangul += p.hangulRatio;
-    control += p.controlCharRatio;
-    replacement += p.replacementCharRatio;
-    pua += p.puaRatio;
-    if (p.textChars < LOW_TEXT_THRESHOLD) lowText++;
-    if (p.puaRatio >= HIGH_PUA_THRESHOLD) highPua++;
-    if (p.needsOcr) ocrCandidatePages.push(p.page);
+  return { bottom, top, height: top - bottom };
+}
+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);
+    }
   }
-  const n = pages.length;
-  return {
-    totalPages: n,
-    totalTextChars: textChars,
-    avgHangulRatio: hangul / n,
-    avgControlCharRatio: control / n,
-    avgReplacementCharRatio: replacement / n,
-    avgPuaRatio: pua / n,
-    lowTextPageCount: lowText,
-    highPuaPageCount: highPua,
-    needsOcr: ocrCandidatePages.length / n >= DOC_NEEDS_OCR_PAGE_RATIO,
-    ocrCandidatePages
-  };
+  return result;
 }
-
-// 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;
+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;
 }
-if (typeof g.Path2D === "undefined") {
-  g.Path2D = class Path2D {
-  };
+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;
 }
-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);
+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);
 }
-async function parsePdfDocument(buffer, options) {
-  const formulaBuffer = options?.formulaOcr ? buffer.slice(0) : null;
-  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 = [];
-    const pageQuality = [];
-    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();
-    const pagesWithLargeImage = /* @__PURE__ */ new Set();
-    const skippedImagePages = /* @__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 pageArea = viewport.width * viewport.height;
-        if (pageArea > 0) {
-          const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray);
-          let uncovered = 0;
-          for (const r of imageRegions) {
-            const area = (r.x2 - r.x1) * (r.y2 - r.y1);
-            if (area < pageArea * 0.05) continue;
-            pagesWithLargeImage.add(i);
-            const hasText = visible.some((it) => {
-              const cx = it.x + it.w / 2;
-              const cy = it.y + (it.h || it.fontSize) / 2;
-              return cx >= r.x1 && cx <= r.x2 && cy >= r.y1 && cy <= r.y2;
-            });
-            if (!hasText) uncovered++;
-          }
-          if (uncovered > 0) skippedImagePages.set(i, uncovered);
-        }
-        const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
-        for (const b of pageBlocks) blocks.push(b);
-        let pageText = "";
-        for (const b of pageBlocks) {
-          const t = b.text || "";
-          totalChars += t.replace(/\s/g, "").length;
-          totalTextBytes += t.length * 2;
-          pageText += pageText ? "\n" + t : t;
-        }
-        pageQuality.push(computePageQuality(i, pageText));
-        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);
-    let isImageBased = false;
-    if (totalChars / Math.max(parsedPageCount, 1) < 10) {
-      if (options?.ocr) {
-        try {
-          const { ocrPages } = await import("./provider-4ZJKV3DC.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, pageQuality, qualitySummary: summarizeDocumentQuality(pageQuality) };
-          }
-        } catch {
-        }
+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();
       }
-      isImageBased = true;
-      warnings.push({
-        message: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, \uD14D\uC2A4\uD2B8 ${totalChars}\uC790) \u2014 \uD14D\uC2A4\uD2B8 \uB808\uC774\uC5B4\uAC00 \uC5C6\uC5B4 OCR\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
-        code: "NEEDS_OCR"
-      });
-    }
-    if (!isImageBased) {
-      const OCR_REASON_MESSAGES = {
-        low_text: "\uD14D\uC2A4\uD2B8\uAC00 \uAC70\uC758 \uC5C6\uB294 \uD398\uC774\uC9C0 (\uC2A4\uCE94/\uC774\uBBF8\uC9C0 \uCD94\uC815)",
-        high_pua: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (PUA \uBE44\uC728 \uB192\uC74C) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
-        high_control: "\uC81C\uC5B4\uBB38\uC790 \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
-        high_replacement: "\uB300\uCCB4\uBB38\uC790(U+FFFD) \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00"
-      };
-      for (const pq of pageQuality) {
-        if (!pq.needsOcr || !pq.ocrReason) continue;
-        if (pq.ocrReason === "low_text" && !pagesWithLargeImage.has(pq.page)) continue;
-        warnings.push({ page: pq.page, message: `${OCR_REASON_MESSAGES[pq.ocrReason]} \u2014 OCR \uAC80\uD1A0 \uD544\uC694`, code: "NEEDS_OCR" });
+      if (currentRegion.length >= MIN_ROWS) {
+        regions.push({ rows: [...currentRegion] });
       }
+      currentRegion = [];
+      missStreak = 0;
     }
-    if (!isImageBased) {
-      for (const [page, count] of [...skippedImagePages.entries()].sort((a, b) => a[0] - b[0])) {
-        warnings.push({ page, message: `${count}\uAC1C \uC774\uBBF8\uC9C0 \uC601\uC5ED\uC5D0 \uCD94\uCD9C \uAC00\uB2A5\uD55C \uD14D\uC2A4\uD2B8 \uC5C6\uC74C (\uADF8\uB9BC/\uCC28\uD2B8/\uB3C4\uC7A5 \uB0B4\uC6A9 \uB204\uB77D \uAC00\uB2A5)`, code: "SKIPPED_IMAGE" });
+  }
+  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);
       }
-    }
-    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);
+    } else {
+      if (currentRegion.length >= MIN_ROWS) {
+        regions.push({ rows: [...currentRegion] });
       }
+      currentRegion = [];
     }
-    mergeCrossPageTables(blocks);
-    if (options?.formulaOcr && formulaBuffer) {
-      try {
-        await applyFormulaOcr(formulaBuffer, blocks, pageFilter, effectivePageCount, warnings, options.onProgress);
-      } catch (e) {
-        warnings.push({
-          message: `\uC218\uC2DD OCR \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`,
-          code: "PARTIAL_PARSE"
-        });
+  }
+  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;
       }
     }
-    const medianFontSize = computeMedianFontSizeFromFreq(fontSizeFreq);
-    if (medianFontSize > 0) {
-      detectHeadings(blocks, medianFontSize);
-    }
-    detectMarkerHeadings(blocks);
-    detectTableCaptions(blocks);
-    detectKoreanListBlocks(blocks);
-    const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
-    sanitizeBlockControlChars(blocks);
-    let markdown = cleanPdfText(blocksToMarkdown(blocks));
-    return {
-      markdown,
-      blocks,
-      metadata,
-      outline: outline.length > 0 ? outline : void 0,
-      warnings: warnings.length > 0 ? warnings : void 0,
-      isImageBased: isImageBased || void 0,
-      pageQuality,
-      qualitySummary: summarizeDocumentQuality(pageQuality)
-    };
-  } finally {
-    await doc.destroy().catch(() => {
-    });
   }
+  return matched.size;
 }
-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);
+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;
+      }
     }
-    if (typeof info.CreationDate === "string") metadata.createdAt = parsePdfDate(info.CreationDate);
-    if (typeof info.ModDate === "string") metadata.modifiedAt = parsePdfDate(info.ModDate);
-  } catch {
   }
+  return matched.size;
 }
-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 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) });
   }
-}
-function filterHiddenText(items, pageWidth, pageHeight) {
-  let hiddenCount = 0;
-  const visible = [];
-  for (const item of items) {
-    if (item.isHidden) {
-      hiddenCount++;
-      continue;
+  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;
     }
-    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;
+    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]) });
     }
-    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;
+  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);
   }
-  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);
+  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 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 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 }))
   );
-}
-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(" "));
+  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);
     }
   }
-  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;
+  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;
+      }
     }
-    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;
+  }
+  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/xy-cut.ts
 var MAX_XYCUT_DEPTH = 50;
 var XYCUT_MIN_GAP = 5;
 var CROSS_LAYOUT_BETA = 2;
@@ -1959,1033 +1865,947 @@ function findVerticalCut(items) {
   }
   return { position, gap: largestGap };
 }
-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));
-  markStrikethroughItems(items, horizontals);
-  wrapStrikethroughRuns(items);
-  const grids = buildTableGrids(horizontals, verticals);
-  if (grids.length > 0) {
-    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
+
+// src/pdf/columns.ts
+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));
   }
-  return extractPageBlocksFallback(items, pageNum);
+  const maxGap = safeMax(gaps);
+  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
+  return maxGap < 40 && avgLen < 5;
 }
-var STRIKE_MAX_THICKNESS = 2;
-var STRIKE_MAX_THICKNESS_RATIO = 0.25;
-var STRIKE_CENTER_TOLERANCE = 0.25;
-var STRIKE_MIN_OVERLAP_RATIO = 0.8;
-var STRIKE_MAX_LINE_TO_TEXT_RATIO = 1.5;
-function markStrikethroughItems(items, horizontals) {
-  if (items.length === 0 || horizontals.length === 0) return;
-  for (const line of horizontals) {
-    if (line.lineWidth > STRIKE_MAX_THICKNESS) continue;
-    const matches = [];
-    for (const item of items) {
-      const h = item.h > 0 ? item.h : item.fontSize;
-      if (h <= 0 || item.w <= 0) continue;
-      if (line.lineWidth > h * STRIKE_MAX_THICKNESS_RATIO) continue;
-      const centerY = item.y + h * 0.4;
-      if (Math.abs(line.y1 - centerY) > h * STRIKE_CENTER_TOLERANCE) continue;
-      const overlap = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
-      if (overlap / item.w < STRIKE_MIN_OVERLAP_RATIO) continue;
-      matches.push(item);
+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;
     }
-    if (matches.length === 0) continue;
-    let totalW = 0;
-    for (const m of matches) totalW += m.w;
-    if (totalW <= 0 || (line.x2 - line.x1) / totalW > STRIKE_MAX_LINE_TO_TEXT_RATIO) continue;
-    for (const m of matches) m.strike = true;
-  }
-}
-function wrapStrikethroughRuns(items) {
-  const struck = items.filter((i) => i.strike);
-  if (struck.length === 0) return;
-  const lines = /* @__PURE__ */ new Map();
-  for (const item of struck) {
-    const key = Math.round(item.y / 3);
-    const arr = lines.get(key) || [];
-    arr.push(item);
-    lines.set(key, arr);
-  }
-  for (const arr of lines.values()) {
-    arr.sort((a, b) => a.x - b.x);
-    arr[0].text = "~~" + arr[0].text;
-    arr[arr.length - 1].text = arr[arr.length - 1].text + "~~";
   }
-}
-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;
-    if (numGridCols === 1 && numGridRows >= 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,
-      hasSpaceBefore: i.hasSpaceBefore
-    }));
-    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
-      };
-    }
-    let finalGrid = irGrid;
-    let finalRows = numRows;
-    if (numRows <= 2 && numCols >= 3) {
-      const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
-      if (rebuilt) {
-        finalGrid = rebuilt.map((row) => row.map((rawText) => {
-          const cleaned = rawText.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
-          return {
-            text: cleaned.split("\n").map((line) => collapseEvenSpacing(line)).join("\n"),
-            colSpan: 1,
-            rowSpan: 1
-          };
-        }));
-        finalRows = finalGrid.length;
+  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 irTable = {
-      rows: finalRows,
-      cols: numCols,
-      cells: finalGrid,
-      hasHeader: finalRows > 1
-    };
-    const hasContent = finalGrid.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) });
+  }
+  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;
       }
-      continue;
+      prev.count += peaks[i].count;
+      prev.minX = Math.min(prev.minX, peaks[i].minX);
+    } else {
+      merged.push({ ...peaks[i] });
     }
-    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,
-      hasSpaceBefore: i.hasSpaceBefore
-    }));
-    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);
+  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));
         }
-        blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
+        result.push(mergeLineSimple(line));
       }
-      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);
+    if (gridLines.length > 0) {
+      result.push(buildGridTable(gridLines, columns));
     }
-    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);
+  if (bigoIdx >= 0) {
+    result.push("");
+    for (let i = bigoIdx; i < yLines.length; i++) {
+      result.push(mergeLineSimple(yLines[i]));
+    }
+  }
+  return result.join("\n");
 }
-var NEIGHBOR_TABLE_EPSILON = 0.2;
-function mergeCrossPageTables(blocks) {
-  for (let i = blocks.length - 2; i >= 0; i--) {
-    const prev = blocks[i];
-    const curr = blocks[i + 1];
-    if (prev.type !== "table" || curr.type !== "table" || !prev.table || !curr.table) continue;
-    if (!prev.pageNumber || !curr.pageNumber || curr.pageNumber !== prev.pageNumber + 1) continue;
-    if (prev.table.cols !== curr.table.cols) continue;
-    if (!prev.bbox || !curr.bbox) continue;
-    const width = Math.max(prev.bbox.width, curr.bbox.width, 1);
-    const leftDiff = Math.abs(prev.bbox.x - curr.bbox.x);
-    const rightDiff = Math.abs(prev.bbox.x + prev.bbox.width - (curr.bbox.x + curr.bbox.width));
-    if (leftDiff > width * NEIGHBOR_TABLE_EPSILON || rightDiff > width * NEIGHBOR_TABLE_EPSILON) continue;
-    let currCells = curr.table.cells;
-    if (currCells.length > 1 && prev.table.cells.length > 0 && rowTextsEqual(prev.table.cells[0], currCells[0])) {
-      currCells = currCells.slice(1);
+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;
     }
-    if (currCells.length === 0) {
-      blocks.splice(i + 1, 1);
+    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 merged = {
-      rows: prev.table.rows + currCells.length,
-      cols: prev.table.cols,
-      cells: [...prev.table.cells, ...currCells],
-      hasHeader: prev.table.hasHeader,
-      caption: prev.table.caption
-    };
-    blocks[i] = { ...prev, table: merged };
-    blocks.splice(i + 1, 1);
-  }
-}
-function rowTextsEqual(a, b) {
-  if (a.length !== b.length) return false;
-  const norm = (t) => t.replace(/\s+/g, "");
-  for (let i = 0; i < a.length; i++) {
-    if (norm(a[i].text) !== norm(b[i].text)) return false;
-  }
-  return a.some((c) => c.text.trim() !== "");
-}
-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);
+    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;
     }
-  }
-  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,
-    hasSpaceBefore: i.hasSpaceBefore
-  }));
-  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 });
+    if (!isNewRow && numCols > 1 && row[1]) {
+      isNewRow = true;
     }
-    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
-    if (remaining.length > 0) {
-      const yLines = mergeSuperscriptLines(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) });
+    if (!isNewRow) {
+      const hasData = row.slice(dataColStart).some((c) => c !== "");
+      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
+      if (hasData && prevHasData) {
+        isNewRow = true;
       }
     }
-    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 = mergeSuperscriptLines(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) });
+    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
+      isNewRow = false;
+    }
+    if (isNewRow) {
+      merged.push([...row]);
     } 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 = mergeSuperscriptLines(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) });
-          }
+      for (let c = 0; c < numCols; c++) {
+        if (row[c]) {
+          prev[c] = prev[c] ? prev[c] + " " + row[c] : row[c];
         }
       }
     }
   }
-  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;
+  if (merged.length < 2) {
+    return merged.map((r) => r.filter((c) => c).join(" ")).join("\n");
   }
-  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;
-    }
+  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 (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 });
+  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];
+        }
       }
-    } else {
-      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden });
     }
+    merged.splice(0, headerEnd, headerRow);
   }
-  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;
-      }
+  for (const row of merged) {
+    for (let c = 0; c < row.length; c++) {
+      if (row[c]) row[c] = collapseEvenSpacing(row[c]);
     }
-    if (!isDup) deduped.push(sorted[i]);
   }
-  if (spacePositions.length > 0) {
-    for (const sp of spacePositions) {
-      let nearest = null;
-      for (const item of deduped) {
-        if (Math.abs(sp.y - item.y) > 3) continue;
-        const dist = item.x - sp.x;
-        if (dist >= -1 && dist <= 20 && (!nearest || item.x < nearest.x)) {
-          nearest = item;
-        }
-      }
-      if (nearest) nearest.hasSpaceBefore = true;
-    }
+  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");
   }
-  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]);
+  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(" | ") + " |");
   }
-  if (curLine.length > 0) lines.push(curLine);
-  return lines;
+  return md.join("\n");
 }
-function mergeSuperscriptLines(lines) {
-  if (lines.length <= 1) return lines;
-  const band = (line) => {
-    let bottom = Infinity, top = -Infinity;
-    for (const i of line) {
-      const h = i.h > 0 ? i.h : i.fontSize;
-      if (i.y < bottom) bottom = i.y;
-      if (i.y + h > top) top = i.y + h;
-    }
-    return { bottom, top, height: top - bottom };
-  };
-  const isFrag = (line) => line.length <= 3 && line.every((i) => i.text.trim().length <= 8);
-  const result = [lines[0]];
-  for (let i = 1; i < lines.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = lines[i];
-    const a = band(prev);
-    const b = band(curr);
-    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
-    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
-    if (prevIsFrag || currIsFrag) {
-      result[result.length - 1] = [...prev, ...curr];
-    } else {
-      result.push(curr);
+
+// src/pdf/block-detect.ts
+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);
     }
   }
-  return result;
 }
-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));
+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;
   }
-  const maxGap = safeMax(gaps);
-  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
-  return maxGap < 40 && avgLen < 5;
+  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 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;
+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(" "));
     }
   }
-  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 });
-      }
+  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;
     }
-  }
-  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;
+    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;
       }
-      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]);
+}
+var TABLE_CAPTION_RE = /^[<\[(【〈]?\s*(표|그림|도표|Table|Figure|Fig\.?)\s*[\d①-⑮][\d.\-]*\s*[\])】〉>]?[.:]?\s*/i;
+var CAPTION_MAX_LENGTH = 100;
+var CAPTION_MAX_GAP = 30;
+function detectTableCaptions(blocks) {
+  const isCaptionCandidate = (b, table) => {
+    if (!b || b.type !== "paragraph" || !b.text) return false;
+    if (b.pageNumber !== table.pageNumber) return false;
+    const text = b.text.trim();
+    if (!text || text.length > CAPTION_MAX_LENGTH || text.includes("\n")) return false;
+    if (!TABLE_CAPTION_RE.test(text)) return false;
+    if (b.bbox && table.bbox) {
+      const capTop = b.bbox.y + b.bbox.height;
+      const capBottom = b.bbox.y;
+      const tblTop = table.bbox.y + table.bbox.height;
+      const tblBottom = table.bbox.y;
+      const gap = capBottom >= tblTop ? capBottom - tblTop : tblBottom - capTop;
+      if (gap > CAPTION_MAX_GAP) return false;
+      const overlap = Math.min(b.bbox.x + b.bbox.width, table.bbox.x + table.bbox.width) - Math.max(b.bbox.x, table.bbox.x);
+      if (overlap < Math.min(b.bbox.width, table.bbox.width) * 0.3) return false;
+    }
+    return true;
+  };
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type !== "table" || !block.table || block.table.caption) continue;
+    if (isCaptionCandidate(blocks[i - 1], block)) {
+      block.table.caption = blocks[i - 1].text.trim();
+      blocks.splice(i - 1, 1);
+      i--;
+    } else if (isCaptionCandidate(blocks[i + 1], block)) {
+      block.table.caption = blocks[i + 1].text.trim();
+      blocks.splice(i + 1, 1);
+    }
   }
-  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;
+var KOREAN_LIST_SEQ = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
+function parseListLabel(text) {
+  let m = text.match(/^(\d{1,2})\.(?!\d)\s+/);
+  if (m) return { family: "arabicDot", ord: parseInt(m[1], 10) };
+  m = text.match(/^([가-하])\.\s+/);
+  if (m) {
+    const idx = KOREAN_LIST_SEQ.indexOf(m[1]);
+    if (idx >= 0) return { family: "korDot", ord: idx + 1 };
   }
-  return 0;
+  m = text.match(/^(\d{1,2})\)\s*/);
+  if (m) return { family: "arabicParen", ord: parseInt(m[1], 10) };
+  m = text.match(/^([가-하])\)\s*/);
+  if (m) {
+    const idx = KOREAN_LIST_SEQ.indexOf(m[1]);
+    if (idx >= 0) return { family: "korParen", ord: idx + 1 };
+  }
+  m = text.match(/^([①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮])\s*/);
+  if (m) return { family: "circled", ord: m[1].charCodeAt(0) - 9312 + 1 };
+  return null;
 }
-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;
-    }
+var ATTACHMENT_RE = /^붙\s*임\s*(\d+[.:]?)?\s/;
+function detectKoreanListBlocks(blocks) {
+  const labeled = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b.type !== "paragraph" && b.type !== "list" || !b.text) continue;
+    const label = parseListLabel(b.text.trim());
+    if (label) labeled.push({ idx: i, label });
   }
-  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 validated = /* @__PURE__ */ new Set();
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const l of labeled) {
+    const arr = byFamily.get(l.label.family) || [];
+    arr.push(l);
+    byFamily.set(l.label.family, arr);
+  }
+  for (const arr of byFamily.values()) {
+    let chain = [];
+    for (const item of arr) {
+      const prev = chain[chain.length - 1];
+      if (prev && item.label.ord === prev.label.ord + 1 && item.idx - prev.idx <= 20) {
+        chain.push(item);
+      } else {
+        if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
+        chain = [item];
+      }
     }
+    if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
   }
-  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));
-      }
+  let familyStack = [];
+  let lastTopLevelList = null;
+  const toRemove = /* @__PURE__ */ new Set();
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b.type === "table" || b.type === "heading" || b.type === "separator") {
+      familyStack = [];
+      lastTopLevelList = null;
+      continue;
     }
-    if (gridLines.length > 0) {
-      result.push(buildGridTable(gridLines, columns));
+    if (b.type !== "paragraph" && b.type !== "list" || !b.text) continue;
+    const text = b.text.trim();
+    if (b.type === "paragraph" && ATTACHMENT_RE.test(text)) {
+      blocks[i] = { ...b, type: "list", listType: "unordered" };
+      continue;
+    }
+    if (!validated.has(i)) continue;
+    const label = parseListLabel(text);
+    let depth = familyStack.indexOf(label.family);
+    if (depth < 0) {
+      familyStack.push(label.family);
+      depth = familyStack.length - 1;
+    } else {
+      familyStack = familyStack.slice(0, depth + 1);
+    }
+    const listType = label.family === "arabicDot" ? "ordered" : "unordered";
+    const listBlock = { ...b, type: "list", listType };
+    if (depth === 0) {
+      blocks[i] = listBlock;
+      lastTopLevelList = listBlock;
+    } else if (lastTopLevelList) {
+      if (!lastTopLevelList.children) lastTopLevelList.children = [];
+      lastTopLevelList.children.push(listBlock);
+      toRemove.add(i);
+    } else {
+      blocks[i] = listBlock;
+      lastTopLevelList = listBlock;
     }
   }
-  if (bigoIdx >= 0) {
-    result.push("");
-    for (let i = bigoIdx; i < yLines.length; i++) {
-      result.push(mergeLineSimple(yLines[i]));
+  if (toRemove.size > 0) {
+    const sorted = [...toRemove].sort((a, b) => b - a);
+    for (const idx of sorted) blocks.splice(idx, 1);
+  }
+}
+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.join("\n");
+  return result;
 }
-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;
+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;
     }
-    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]);
+    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 prev = merged[merged.length - 1];
-    const filledCols = row.map((c, i) => c ? i : -1).filter((i) => i >= 0);
-    const filledCount = filledCols.length;
-    let isNewRow = false;
-    if (row[0] && row[0].length >= 3) {
-      isNewRow = true;
-    }
-    if (!isNewRow && numCols > 1 && row[1]) {
-      isNewRow = true;
-    }
-    if (!isNewRow) {
-      const hasData = row.slice(dataColStart).some((c) => c !== "");
-      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
-      if (hasData && prevHasData) {
-        isNewRow = true;
+    const 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 (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 (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);
   }
-  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;
+  flushKvTable();
+  return result;
+}
+function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
+  const ZONE_RATIO = 0.12;
+  const MIN_REPEAT = 3;
+  const topEntries = [];
+  const bottomEntries = [];
+  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 entry = { blockIdx: bi, page: b.pageNumber, text: b.text.trim() };
+    if (blockBottom <= ph * ZONE_RATIO) bottomEntries.push(entry);
+    else if (blockTop >= ph * (1 - ZONE_RATIO)) topEntries.push(entry);
   }
-  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];
-        }
+  const removeSet = /* @__PURE__ */ new Set();
+  for (const entries of [topEntries, bottomEntries]) {
+    if (entries.length === 0) continue;
+    const patternCount = /* @__PURE__ */ new Map();
+    const patternPages = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const norm = e.text.replace(/\d+/g, "#");
+      patternCount.set(norm, (patternCount.get(norm) || 0) + 1);
+      const pages = patternPages.get(norm) || /* @__PURE__ */ new Set();
+      pages.add(e.page);
+      patternPages.set(norm, pages);
+    }
+    const repeatedPatterns = /* @__PURE__ */ new Set();
+    for (const [p, count] of patternCount) {
+      if (count >= MIN_REPEAT && (patternPages.get(p)?.size ?? 0) >= MIN_REPEAT) {
+        repeatedPatterns.add(p);
       }
     }
-    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]);
+    for (const e of entries) {
+      const norm = e.text.replace(/\d+/g, "#");
+      if (repeatedPatterns.has(norm)) {
+        removeSet.add(e.blockIdx);
+      }
     }
   }
-  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 > spaceGapThreshold(avgFs)) result += " ";
-    result += sorted[i].text;
+  if (removeSet.size > 0) {
+    warnings.push({ message: `${removeSet.size}\uAC1C \uBA38\uB9AC\uAE00/\uBC14\uB2E5\uAE00 \uC694\uC18C \uC81C\uAC70\uB428`, code: "HIDDEN_TEXT_FILTERED" });
   }
-  return result;
+  return [...removeSet].sort((a, b) => a - b);
 }
-function sanitizeBlockControlChars(blocks) {
-  for (const b of blocks) {
-    if (b.text) b.text = stripControlChars(b.text);
-    if (b.table) {
-      for (const row of b.table.cells) {
-        for (const cell of row) {
-          if (cell.text) cell.text = stripControlChars(cell.text);
-        }
-      }
-    }
-    if (b.children) sanitizeBlockControlChars(b.children);
+
+// src/pdf/page-blocks.ts
+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));
+  markStrikethroughItems(items, horizontals);
+  wrapStrikethroughRuns(items);
+  const grids = buildTableGrids(horizontals, verticals);
+  if (grids.length > 0) {
+    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
   }
+  return extractPageBlocksFallback(items, pageNum);
 }
-function cleanPdfText(text) {
-  return mergeKoreanLines(
-    stripControlChars(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) => {
-    if (/^\s*\${1,2}.+\${1,2}\s*$/.test(line)) return line;
-    return collapseEvenSpacing(line);
-  }).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\\~\\~/g, "~~").replace(/~~~~/g, "").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());
-}
-var TABLE_CAPTION_RE = /^[<\[(【〈]?\s*(표|그림|도표|Table|Figure|Fig\.?)\s*[\d①-⑮][\d.\-]*\s*[\])】〉>]?[.:]?\s*/i;
-var CAPTION_MAX_LENGTH = 100;
-var CAPTION_MAX_GAP = 30;
-function detectTableCaptions(blocks) {
-  const isCaptionCandidate = (b, table) => {
-    if (!b || b.type !== "paragraph" || !b.text) return false;
-    if (b.pageNumber !== table.pageNumber) return false;
-    const text = b.text.trim();
-    if (!text || text.length > CAPTION_MAX_LENGTH || text.includes("\n")) return false;
-    if (!TABLE_CAPTION_RE.test(text)) return false;
-    if (b.bbox && table.bbox) {
-      const capTop = b.bbox.y + b.bbox.height;
-      const capBottom = b.bbox.y;
-      const tblTop = table.bbox.y + table.bbox.height;
-      const tblBottom = table.bbox.y;
-      const gap = capBottom >= tblTop ? capBottom - tblTop : tblBottom - capTop;
-      if (gap > CAPTION_MAX_GAP) return false;
-      const overlap = Math.min(b.bbox.x + b.bbox.width, table.bbox.x + table.bbox.width) - Math.max(b.bbox.x, table.bbox.x);
-      if (overlap < Math.min(b.bbox.width, table.bbox.width) * 0.3) return false;
-    }
-    return true;
-  };
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (block.type !== "table" || !block.table || block.table.caption) continue;
-    if (isCaptionCandidate(blocks[i - 1], block)) {
-      block.table.caption = blocks[i - 1].text.trim();
-      blocks.splice(i - 1, 1);
-      i--;
-    } else if (isCaptionCandidate(blocks[i + 1], block)) {
-      block.table.caption = blocks[i + 1].text.trim();
-      blocks.splice(i + 1, 1);
+var STRIKE_MAX_THICKNESS = 2;
+var STRIKE_MAX_THICKNESS_RATIO = 0.25;
+var STRIKE_CENTER_TOLERANCE = 0.25;
+var STRIKE_MIN_OVERLAP_RATIO = 0.8;
+var STRIKE_MAX_LINE_TO_TEXT_RATIO = 1.5;
+function markStrikethroughItems(items, horizontals) {
+  if (items.length === 0 || horizontals.length === 0) return;
+  for (const line of horizontals) {
+    if (line.lineWidth > STRIKE_MAX_THICKNESS) continue;
+    const matches = [];
+    for (const item of items) {
+      const h = item.h > 0 ? item.h : item.fontSize;
+      if (h <= 0 || item.w <= 0) continue;
+      if (line.lineWidth > h * STRIKE_MAX_THICKNESS_RATIO) continue;
+      const centerY = item.y + h * 0.4;
+      if (Math.abs(line.y1 - centerY) > h * STRIKE_CENTER_TOLERANCE) continue;
+      const overlap = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
+      if (overlap / item.w < STRIKE_MIN_OVERLAP_RATIO) continue;
+      matches.push(item);
     }
+    if (matches.length === 0) continue;
+    let totalW = 0;
+    for (const m of matches) totalW += m.w;
+    if (totalW <= 0 || (line.x2 - line.x1) / totalW > STRIKE_MAX_LINE_TO_TEXT_RATIO) continue;
+    for (const m of matches) m.strike = true;
   }
 }
-var KOREAN_LIST_SEQ = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
-function parseListLabel(text) {
-  let m = text.match(/^(\d{1,2})\.(?!\d)\s+/);
-  if (m) return { family: "arabicDot", ord: parseInt(m[1], 10) };
-  m = text.match(/^([가-하])\.\s+/);
-  if (m) {
-    const idx = KOREAN_LIST_SEQ.indexOf(m[1]);
-    if (idx >= 0) return { family: "korDot", ord: idx + 1 };
+function wrapStrikethroughRuns(items) {
+  const struck = items.filter((i) => i.strike);
+  if (struck.length === 0) return;
+  const lines = /* @__PURE__ */ new Map();
+  for (const item of struck) {
+    const key = Math.round(item.y / 3);
+    const arr = lines.get(key) || [];
+    arr.push(item);
+    lines.set(key, arr);
   }
-  m = text.match(/^(\d{1,2})\)\s*/);
-  if (m) return { family: "arabicParen", ord: parseInt(m[1], 10) };
-  m = text.match(/^([가-하])\)\s*/);
-  if (m) {
-    const idx = KOREAN_LIST_SEQ.indexOf(m[1]);
-    if (idx >= 0) return { family: "korParen", ord: idx + 1 };
+  for (const arr of lines.values()) {
+    arr.sort((a, b) => a.x - b.x);
+    arr[0].text = "~~" + arr[0].text;
+    arr[arr.length - 1].text = arr[arr.length - 1].text + "~~";
   }
-  m = text.match(/^([①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮])\s*/);
-  if (m) return { family: "circled", ord: m[1].charCodeAt(0) - 9312 + 1 };
-  return null;
 }
-var ATTACHMENT_RE = /^붙\s*임\s*(\d+[.:]?)?\s/;
-function detectKoreanListBlocks(blocks) {
-  const labeled = [];
-  for (let i = 0; i < blocks.length; i++) {
-    const b = blocks[i];
-    if (b.type !== "paragraph" && b.type !== "list" || !b.text) continue;
-    const label = parseListLabel(b.text.trim());
-    if (label) labeled.push({ idx: i, label });
-  }
-  const validated = /* @__PURE__ */ new Set();
-  const byFamily = /* @__PURE__ */ new Map();
-  for (const l of labeled) {
-    const arr = byFamily.get(l.label.family) || [];
-    arr.push(l);
-    byFamily.set(l.label.family, arr);
-  }
-  for (const arr of byFamily.values()) {
-    let chain = [];
-    for (const item of arr) {
-      const prev = chain[chain.length - 1];
-      if (prev && item.label.ord === prev.label.ord + 1 && item.idx - prev.idx <= 20) {
-        chain.push(item);
-      } else {
-        if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
-        chain = [item];
+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;
+    if (numGridCols === 1 && numGridRows >= 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,
+      hasSpaceBefore: i.hasSpaceBefore
+    }));
+    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
+      };
+    }
+    let finalGrid = irGrid;
+    let finalRows = numRows;
+    if (numRows <= 2 && numCols >= 3) {
+      const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
+      if (rebuilt) {
+        finalGrid = rebuilt.map((row) => row.map((rawText) => {
+          const cleaned = rawText.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
+          return {
+            text: cleaned.split("\n").map((line) => collapseEvenSpacing(line)).join("\n"),
+            colSpan: 1,
+            rowSpan: 1
+          };
+        }));
+        finalRows = finalGrid.length;
       }
     }
-    if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
-  }
-  let familyStack = [];
-  let lastTopLevelList = null;
-  const toRemove = /* @__PURE__ */ new Set();
-  for (let i = 0; i < blocks.length; i++) {
-    const b = blocks[i];
-    if (b.type === "table" || b.type === "heading" || b.type === "separator") {
-      familyStack = [];
-      lastTopLevelList = null;
+    const irTable = {
+      rows: finalRows,
+      cols: numCols,
+      cells: finalGrid,
+      hasHeader: finalRows > 1
+    };
+    const hasContent = finalGrid.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;
     }
-    if (b.type !== "paragraph" && b.type !== "list" || !b.text) continue;
-    const text = b.text.trim();
-    if (b.type === "paragraph" && ATTACHMENT_RE.test(text)) {
-      blocks[i] = { ...b, type: "list", listType: "unordered" };
-      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,
+      hasSpaceBefore: i.hasSpaceBefore
+    }));
+    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 (!validated.has(i)) continue;
-    const label = parseListLabel(text);
-    let depth = familyStack.indexOf(label.family);
-    if (depth < 0) {
-      familyStack.push(label.family);
-      depth = familyStack.length - 1;
-    } else {
-      familyStack = familyStack.slice(0, depth + 1);
+    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);
+}
+var NEIGHBOR_TABLE_EPSILON = 0.2;
+function mergeCrossPageTables(blocks) {
+  for (let i = blocks.length - 2; i >= 0; i--) {
+    const prev = blocks[i];
+    const curr = blocks[i + 1];
+    if (prev.type !== "table" || curr.type !== "table" || !prev.table || !curr.table) continue;
+    if (!prev.pageNumber || !curr.pageNumber || curr.pageNumber !== prev.pageNumber + 1) continue;
+    if (prev.table.cols !== curr.table.cols) continue;
+    if (!prev.bbox || !curr.bbox) continue;
+    const width = Math.max(prev.bbox.width, curr.bbox.width, 1);
+    const leftDiff = Math.abs(prev.bbox.x - curr.bbox.x);
+    const rightDiff = Math.abs(prev.bbox.x + prev.bbox.width - (curr.bbox.x + curr.bbox.width));
+    if (leftDiff > width * NEIGHBOR_TABLE_EPSILON || rightDiff > width * NEIGHBOR_TABLE_EPSILON) continue;
+    let currCells = curr.table.cells;
+    if (currCells.length > 1 && prev.table.cells.length > 0 && rowTextsEqual(prev.table.cells[0], currCells[0])) {
+      currCells = currCells.slice(1);
     }
-    const listType = label.family === "arabicDot" ? "ordered" : "unordered";
-    const listBlock = { ...b, type: "list", listType };
-    if (depth === 0) {
-      blocks[i] = listBlock;
-      lastTopLevelList = listBlock;
-    } else if (lastTopLevelList) {
-      if (!lastTopLevelList.children) lastTopLevelList.children = [];
-      lastTopLevelList.children.push(listBlock);
-      toRemove.add(i);
-    } else {
-      blocks[i] = listBlock;
-      lastTopLevelList = listBlock;
+    if (currCells.length === 0) {
+      blocks.splice(i + 1, 1);
+      continue;
     }
+    const merged = {
+      rows: prev.table.rows + currCells.length,
+      cols: prev.table.cols,
+      cells: [...prev.table.cells, ...currCells],
+      hasHeader: prev.table.hasHeader,
+      caption: prev.table.caption
+    };
+    blocks[i] = { ...prev, table: merged };
+    blocks.splice(i + 1, 1);
   }
-  if (toRemove.size > 0) {
-    const sorted = [...toRemove].sort((a, b) => b - a);
-    for (const idx of sorted) blocks.splice(idx, 1);
+}
+function rowTextsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const norm = (t) => t.replace(/\s+/g, "");
+  for (let i = 0; i < a.length; i++) {
+    if (norm(a[i].text) !== norm(b[i].text)) return false;
   }
+  return a.some((c) => c.text.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;
-      }
+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);
     }
-    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 }
-        ];
+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,
+    hasSpaceBefore: i.hasSpaceBefore
+  }));
+  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);
       }
-      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;
+      blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
     }
-    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 });
-        }
+    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
+    if (remaining.length > 0) {
+      const yLines = mergeSuperscriptLines(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) });
       }
-      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;
+    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 = mergeSuperscriptLines(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 = mergeSuperscriptLines(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) });
+          }
         }
       }
     }
-    flushKvTable();
-    result.push(block);
   }
-  flushKvTable();
-  return result;
+  return detectSpecialKoreanTables(blocks);
 }
-function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
-  const ZONE_RATIO = 0.12;
-  const MIN_REPEAT = 3;
-  const topEntries = [];
-  const bottomEntries = [];
-  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 entry = { blockIdx: bi, page: b.pageNumber, text: b.text.trim() };
-    if (blockBottom <= ph * ZONE_RATIO) bottomEntries.push(entry);
-    else if (blockTop >= ph * (1 - ZONE_RATIO)) topEntries.push(entry);
-  }
-  const removeSet = /* @__PURE__ */ new Set();
-  for (const entries of [topEntries, bottomEntries]) {
-    if (entries.length === 0) continue;
-    const patternCount = /* @__PURE__ */ new Map();
-    const patternPages = /* @__PURE__ */ new Map();
-    for (const e of entries) {
-      const norm = e.text.replace(/\d+/g, "#");
-      patternCount.set(norm, (patternCount.get(norm) || 0) + 1);
-      const pages = patternPages.get(norm) || /* @__PURE__ */ new Set();
-      pages.add(e.page);
-      patternPages.set(norm, pages);
-    }
-    const repeatedPatterns = /* @__PURE__ */ new Set();
-    for (const [p, count] of patternCount) {
-      if (count >= MIN_REPEAT && (patternPages.get(p)?.size ?? 0) >= MIN_REPEAT) {
-        repeatedPatterns.add(p);
-      }
-    }
-    for (const e of entries) {
-      const norm = e.text.replace(/\d+/g, "#");
-      if (repeatedPatterns.has(norm)) {
-        removeSet.add(e.blockIdx);
+
+// src/pdf/text-clean.ts
+function sanitizeBlockControlChars(blocks) {
+  for (const b of blocks) {
+    if (b.text) b.text = stripControlChars(b.text);
+    if (b.table) {
+      for (const row of b.table.cells) {
+        for (const cell of row) {
+          if (cell.text) cell.text = stripControlChars(cell.text);
+        }
       }
     }
+    if (b.children) sanitizeBlockControlChars(b.children);
   }
-  if (removeSet.size > 0) {
-    warnings.push({ message: `${removeSet.size}\uAC1C \uBA38\uB9AC\uAE00/\uBC14\uB2E5\uAE00 \uC694\uC18C \uC81C\uAC70\uB428`, code: "HIDDEN_TEXT_FILTERED" });
-  }
-  return [...removeSet].sort((a, b) => a - b);
+}
+function cleanPdfText(text) {
+  return mergeKoreanLines(
+    stripControlChars(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) => {
+    if (/^\s*\${1,2}.+\${1,2}\s*$/.test(line)) return line;
+    return collapseEvenSpacing(line);
+  }).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\\~\\~/g, "~~").replace(/~~~~/g, "").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 mergeKoreanLines(text) {
   if (!text) return "";
@@ -3016,6 +2836,8 @@ function mergeKoreanLines(text) {
   }
   return result.join("\n");
 }
+
+// src/pdf/formula-ocr.ts
 async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
   const formulaMod = await import("./formula-RXVSQPXI.js");
   const { FormulaPipeline, ensureFormulaModels } = formulaMod;
@@ -3134,6 +2956,251 @@ async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, w
 function formatMb(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
+
+// 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";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+GlobalWorkerOptions.workerSrc = "";
+var MAX_PAGES = 5e3;
+var MAX_TOTAL_TEXT = 100 * 1024 * 1024;
+var PDF_LOAD_TIMEOUT_MS = 3e4;
+var pdfjsAssets = {};
+try {
+  const _require = createRequire(import.meta.url);
+  const pkgDir = dirname(_require.resolve("pdfjs-dist/package.json"));
+  pdfjsAssets.cMapUrl = join(pkgDir, "cmaps") + "/";
+  pdfjsAssets.cMapPacked = true;
+  pdfjsAssets.standardFontDataUrl = join(pkgDir, "standard_fonts") + "/";
+} catch {
+}
+async function loadPdfWithTimeout(buffer) {
+  const loadingTask = getDocument({
+    data: new Uint8Array(buffer),
+    useSystemFonts: true,
+    disableFontFace: true,
+    isEvalSupported: false,
+    ...pdfjsAssets
+  });
+  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 formulaBuffer = options?.formulaOcr ? buffer.slice(0) : null;
+  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 = [];
+    const pageQuality = [];
+    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();
+    const pagesWithLargeImage = /* @__PURE__ */ new Set();
+    const skippedImagePages = /* @__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 pageArea = viewport.width * viewport.height;
+        if (pageArea > 0) {
+          const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray);
+          let uncovered = 0;
+          for (const r of imageRegions) {
+            const area = (r.x2 - r.x1) * (r.y2 - r.y1);
+            if (area < pageArea * 0.05) continue;
+            pagesWithLargeImage.add(i);
+            const hasText = visible.some((it) => {
+              const cx = it.x + it.w / 2;
+              const cy = it.y + (it.h || it.fontSize) / 2;
+              return cx >= r.x1 && cx <= r.x2 && cy >= r.y1 && cy <= r.y2;
+            });
+            if (!hasText) uncovered++;
+          }
+          if (uncovered > 0) skippedImagePages.set(i, uncovered);
+        }
+        const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
+        for (const b of pageBlocks) blocks.push(b);
+        let pageText = "";
+        for (const b of pageBlocks) {
+          const t = b.text || "";
+          totalChars += t.replace(/\s/g, "").length;
+          totalTextBytes += t.length * 2;
+          pageText += pageText ? "\n" + t : t;
+        }
+        pageQuality.push(computePageQuality(i, pageText));
+        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);
+    let isImageBased = false;
+    if (totalChars / Math.max(parsedPageCount, 1) < 10) {
+      if (options?.ocr) {
+        try {
+          const { ocrPages } = await import("./provider-4ZJKV3DC.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, pageQuality, qualitySummary: summarizeDocumentQuality(pageQuality) };
+          }
+        } catch {
+        }
+      }
+      isImageBased = true;
+      warnings.push({
+        message: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, \uD14D\uC2A4\uD2B8 ${totalChars}\uC790) \u2014 \uD14D\uC2A4\uD2B8 \uB808\uC774\uC5B4\uAC00 \uC5C6\uC5B4 OCR\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+        code: "NEEDS_OCR"
+      });
+    }
+    if (!isImageBased) {
+      const OCR_REASON_MESSAGES = {
+        low_text: "\uD14D\uC2A4\uD2B8\uAC00 \uAC70\uC758 \uC5C6\uB294 \uD398\uC774\uC9C0 (\uC2A4\uCE94/\uC774\uBBF8\uC9C0 \uCD94\uC815)",
+        high_pua: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (PUA \uBE44\uC728 \uB192\uC74C) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_control: "\uC81C\uC5B4\uBB38\uC790 \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_replacement: "\uB300\uCCB4\uBB38\uC790(U+FFFD) \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00"
+      };
+      for (const pq of pageQuality) {
+        if (!pq.needsOcr || !pq.ocrReason) continue;
+        if (pq.ocrReason === "low_text" && !pagesWithLargeImage.has(pq.page)) continue;
+        warnings.push({ page: pq.page, message: `${OCR_REASON_MESSAGES[pq.ocrReason]} \u2014 OCR \uAC80\uD1A0 \uD544\uC694`, code: "NEEDS_OCR" });
+      }
+    }
+    if (!isImageBased) {
+      for (const [page, count] of [...skippedImagePages.entries()].sort((a, b) => a[0] - b[0])) {
+        warnings.push({ page, message: `${count}\uAC1C \uC774\uBBF8\uC9C0 \uC601\uC5ED\uC5D0 \uCD94\uCD9C \uAC00\uB2A5\uD55C \uD14D\uC2A4\uD2B8 \uC5C6\uC74C (\uADF8\uB9BC/\uCC28\uD2B8/\uB3C4\uC7A5 \uB0B4\uC6A9 \uB204\uB77D \uAC00\uB2A5)`, code: "SKIPPED_IMAGE" });
+      }
+    }
+    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);
+      }
+    }
+    mergeCrossPageTables(blocks);
+    if (options?.formulaOcr && formulaBuffer) {
+      try {
+        await applyFormulaOcr(formulaBuffer, blocks, pageFilter, effectivePageCount, warnings, options.onProgress);
+      } catch (e) {
+        warnings.push({
+          message: `\uC218\uC2DD OCR \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`,
+          code: "PARTIAL_PARSE"
+        });
+      }
+    }
+    const medianFontSize = computeMedianFontSizeFromFreq(fontSizeFreq);
+    if (medianFontSize > 0) {
+      detectHeadings(blocks, medianFontSize);
+    }
+    detectMarkerHeadings(blocks);
+    detectTableCaptions(blocks);
+    detectKoreanListBlocks(blocks);
+    const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
+    sanitizeBlockControlChars(blocks);
+    let markdown = cleanPdfText(blocksToMarkdown(blocks));
+    return {
+      markdown,
+      blocks,
+      metadata,
+      outline: outline.length > 0 ? outline : void 0,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      isImageBased: isImageBased || void 0,
+      pageQuality,
+      qualitySummary: summarizeDocumentQuality(pageQuality)
+    };
+  } 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(() => {
+    });
+  }
+}
 export {
   cleanPdfText,
   detectKoreanListBlocks,
@@ -3143,4 +3210,4 @@ export {
   parsePdfDocument,
   removeHeaderFooterBlocks
 };
-//# sourceMappingURL=parser-DCK42RMA.js.map
+//# sourceMappingURL=parser-NR2TYGO3.js.map