kordoc 4.0.8 → 4.2.0

package/dist/{parser-KMMUS73Q.js → chunk-4JPPLIIV.js}

@@ -2,18 +2,64 @@ import {
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3,
-  KordocError,
-  blocksToMarkdown,
-  encodePng,
   safeMax,
   safeMin
-} from "./chunk-OQPILS7B.js";
-import {
-  parsePageRange
-} from "./chunk-GE43BE46.js";
+} from "./chunk-JP5YH3Z4.js";
 
-// src/pdf/line-extract.ts
+// src/pdf/image-regions.ts
 import { OPS } 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 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;
+}
+
+// src/pdf/line-extract.ts
+import { OPS as OPS2 } from "pdfjs-dist/legacy/build/pdf.mjs";
 var ORIENTATION_TOL = 2;
 var MIN_LINE_LENGTH = 15;
 var MAX_LINE_WIDTH = 5;
@@ -62,16 +108,16 @@ function extractLines(fnArray, argsArray) {
     const op = fnArray[i];
     const args = argsArray[i];
     switch (op) {
-      case OPS.setLineWidth:
+      case OPS2.setLineWidth:
         lineWidth = args[0] || 1;
         break;
-      case OPS.save:
+      case OPS2.save:
         ctmStack.push(ctm.slice());
         break;
-      case OPS.restore:
+      case OPS2.restore:
         ctm = ctmStack.pop() ?? [1, 0, 0, 1, 0, 0];
         break;
-      case OPS.transform: {
+      case OPS2.transform: {
         const t = args;
         ctm = [
           ctm[0] * t[0] + ctm[2] * t[1],
@@ -83,36 +129,36 @@ function extractLines(fnArray, argsArray) {
         ];
         break;
       }
-      case OPS.constructPath: {
+      case OPS2.constructPath: {
         const arg0 = args[0];
         if (Array.isArray(arg0)) {
           const subOps = arg0;
           const coords = args[1];
           let ci = 0;
           for (const subOp of subOps) {
-            if (subOp === OPS.moveTo) {
+            if (subOp === OPS2.moveTo) {
               curX = coords[ci++];
               curY = coords[ci++];
               pathStartX = curX;
               pathStartY = curY;
-            } else if (subOp === OPS.lineTo) {
+            } else if (subOp === OPS2.lineTo) {
               const x2 = coords[ci++], y2 = coords[ci++];
               pushSeg(curX, curY, x2, y2);
               curX = x2;
               curY = y2;
-            } else if (subOp === OPS.rectangle) {
+            } else if (subOp === OPS2.rectangle) {
               const rx = coords[ci++], ry = coords[ci++];
               const rw = coords[ci++], rh = coords[ci++];
               pushRectangle(rx, ry, rw, rh);
-            } else if (subOp === OPS.closePath) {
+            } else if (subOp === OPS2.closePath) {
               if (curX !== pathStartX || curY !== pathStartY) {
                 pushSeg(curX, curY, pathStartX, pathStartY);
               }
               curX = pathStartX;
               curY = pathStartY;
-            } else if (subOp === OPS.curveTo) {
+            } else if (subOp === OPS2.curveTo) {
               ci += 6;
-            } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
+            } else if (subOp === OPS2.curveTo2 || subOp === OPS2.curveTo3) {
               ci += 4;
             }
           }
@@ -150,33 +196,33 @@ function extractLines(fnArray, argsArray) {
               }
             }
           }
-          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
+          if (afterOp === OPS2.stroke || afterOp === OPS2.closeStroke) {
             flushPath(true);
-          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill) {
+          } else if (afterOp === OPS2.fill || afterOp === OPS2.eoFill) {
             flushPath(true, true);
-          } else if (afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
+          } else if (afterOp === OPS2.fillStroke || afterOp === OPS2.eoFillStroke || afterOp === OPS2.closeFillStroke || afterOp === OPS2.closeEOFillStroke) {
             flushPath(true);
-          } else if (afterOp === OPS.endPath) {
+          } else if (afterOp === OPS2.endPath) {
             flushPath(false);
           }
         }
         break;
       }
-      case OPS.stroke:
-      case OPS.closeStroke:
+      case OPS2.stroke:
+      case OPS2.closeStroke:
         flushPath(true);
         break;
-      case OPS.fill:
-      case OPS.eoFill:
+      case OPS2.fill:
+      case OPS2.eoFill:
         flushPath(true, true);
         break;
-      case OPS.fillStroke:
-      case OPS.eoFillStroke:
-      case OPS.closeFillStroke:
-      case OPS.closeEOFillStroke:
+      case OPS2.fillStroke:
+      case OPS2.eoFillStroke:
+      case OPS2.closeFillStroke:
+      case OPS2.closeEOFillStroke:
         flushPath(true);
         break;
-      case OPS.endPath:
+      case OPS2.endPath:
         flushPath(false);
         break;
     }
@@ -312,9 +358,9 @@ function closeOpenTableEdges(horizontals, verticals) {
   const groups = [];
   for (const hl of chainCollinearRules(horizontals)) {
     let placed = false;
-    for (const g2 of groups) {
-      if (Math.abs(g2[0].x1 - hl.x1) <= EDGE_ALIGN_TOL && Math.abs(g2[0].x2 - hl.x2) <= EDGE_ALIGN_TOL) {
-        g2.push(hl);
+    for (const g of groups) {
+      if (Math.abs(g[0].x1 - hl.x1) <= EDGE_ALIGN_TOL && Math.abs(g[0].x2 - hl.x2) <= EDGE_ALIGN_TOL) {
+        g.push(hl);
         placed = true;
         break;
       }
@@ -322,8 +368,8 @@ function closeOpenTableEdges(horizontals, verticals) {
     if (!placed) groups.push([hl]);
   }
   const splitGroups = [];
-  for (const g2 of groups) {
-    const sorted = [...g2].sort((a, b) => a.y1 - b.y1);
+  for (const g of groups) {
+    const sorted = [...g].sort((a, b) => a.y1 - b.y1);
     const gaps = [];
     for (let i = 1; i < sorted.length; i++) gaps.push(sorted[i].y1 - sorted[i - 1].y1);
     const median = gaps.length ? [...gaps].sort((a, b) => a - b)[gaps.length >> 1] : 0;
@@ -344,21 +390,21 @@ function closeOpenTableEdges(horizontals, verticals) {
     if (cur.length) splitGroups.push(cur);
   }
   const synthesized = [];
-  for (const g2 of splitGroups) {
-    if (g2.length < EDGE_MIN_RULES) continue;
+  for (const g of splitGroups) {
+    if (g.length < EDGE_MIN_RULES) continue;
     let yMin = Infinity, yMax = -Infinity, x1 = 0, x2 = 0;
-    for (const hl of g2) {
+    for (const hl of g) {
       if (hl.y1 < yMin) yMin = hl.y1;
       if (hl.y1 > yMax) yMax = hl.y1;
       x1 += hl.x1;
       x2 += hl.x2;
     }
-    x1 /= g2.length;
-    x2 /= g2.length;
+    x1 /= g.length;
+    x2 /= g.length;
     if (yMax - yMin < EDGE_MIN_SPAN) continue;
     const crossCount = (v) => {
       let n = 0;
-      for (const hl of g2) {
+      for (const hl of g) {
         if (v.x1 >= hl.x1 - EDGE_CONNECT_TOL && v.x1 <= hl.x2 + EDGE_CONNECT_TOL && hl.y1 >= v.y1 - EDGE_CONNECT_TOL && hl.y1 <= v.y2 + EDGE_CONNECT_TOL) n++;
       }
       return n;
@@ -495,58 +541,6 @@ function bridgeSplitColumnVerticals(horizontals, verticals) {
   return synthesized.length ? [...verticals, ...synthesized] : verticals;
 }
 
-// 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;
 
@@ -578,6 +572,18 @@ function buildVertices(horizontals, verticals) {
 }
 function mergeVertices(vertices) {
   if (vertices.length <= 1) return vertices;
+  let maxRadiusAll = 1;
+  for (const v of vertices) {
+    if (v.radius > maxRadiusAll) maxRadiusAll = v.radius;
+  }
+  const cell = Math.max(VERTEX_MERGE_FACTOR * maxRadiusAll, 1);
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vertices.length; i++) {
+    const key = Math.floor(vertices[i].x / cell) + "," + Math.floor(vertices[i].y / cell);
+    const arr = buckets.get(key);
+    if (arr) arr.push(i);
+    else buckets.set(key, [i]);
+  }
   const merged = [];
   const used = new Array(vertices.length).fill(false);
   for (let i = 0; i < vertices.length; i++) {
@@ -585,7 +591,20 @@ function mergeVertices(vertices) {
     let sumX = vertices[i].x, sumY = vertices[i].y;
     let maxRadius = vertices[i].radius;
     let count = 1;
-    for (let j = i + 1; j < vertices.length; j++) {
+    const cx = Math.floor(vertices[i].x / cell);
+    const cy = Math.floor(vertices[i].y / cell);
+    const candidates = [];
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const arr = buckets.get(cx + dx + "," + (cy + dy));
+        if (!arr) continue;
+        for (const j of arr) {
+          if (j > i && !used[j]) candidates.push(j);
+        }
+      }
+    }
+    candidates.sort((a, b) => a - b);
+    for (const j of candidates) {
       if (used[j]) continue;
       const mergeTol = VERTEX_MERGE_FACTOR * Math.max(maxRadius, vertices[j].radius);
       if (Math.abs(vertices[i].x - vertices[j].x) <= mergeTol && Math.abs(vertices[i].y - vertices[j].y) <= mergeTol) {
@@ -611,8 +630,8 @@ function buildTableGrids(horizontals, verticals) {
     ...verticals.map((l, i) => ({ ...l, type: "v", id: i + horizontals.length }))
   ];
   const groups = [];
-  for (const g2 of groupConnectedLines(allLines)) {
-    const bands = splitStackedGroup(g2);
+  for (const g of groupConnectedLines(allLines)) {
+    const bands = splitStackedGroup(g);
     for (const b of bands) groups.push({ lines: b, fromSplit: bands.length > 1 });
   }
   const grids = [];
@@ -812,6 +831,7 @@ function splitStackedGroup(group) {
   }
   return bands.filter((b) => b.length > 0);
 }
+var GROUP_BUCKET_CELL = 100;
 function groupConnectedLines(lines) {
   const parent = lines.map((_, i) => i);
   function find(x) {
@@ -825,10 +845,34 @@ function groupConnectedLines(lines) {
     const ra = find(a), rb = find(b);
     if (ra !== rb) parent[ra] = rb;
   }
+  const cellMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
-    for (let j = i + 1; j < lines.length; j++) {
-      if (linesIntersect(lines[i], lines[j])) {
-        union(i, j);
+    const l = lines[i];
+    const cx1 = Math.floor((Math.min(l.x1, l.x2) - CONNECT_TOL) / GROUP_BUCKET_CELL);
+    const cx2 = Math.floor((Math.max(l.x1, l.x2) + CONNECT_TOL) / GROUP_BUCKET_CELL);
+    const cy1 = Math.floor((Math.min(l.y1, l.y2) - CONNECT_TOL) / GROUP_BUCKET_CELL);
+    const cy2 = Math.floor((Math.max(l.y1, l.y2) + CONNECT_TOL) / GROUP_BUCKET_CELL);
+    for (let cx = cx1; cx <= cx2; cx++) {
+      for (let cy = cy1; cy <= cy2; cy++) {
+        const key = cx + "," + cy;
+        const arr = cellMap.get(key);
+        if (arr) arr.push(i);
+        else cellMap.set(key, [i]);
+      }
+    }
+  }
+  const tested = /* @__PURE__ */ new Set();
+  for (const arr of cellMap.values()) {
+    for (let a = 0; a < arr.length; a++) {
+      for (let b = a + 1; b < arr.length; b++) {
+        const i = Math.min(arr[a], arr[b]);
+        const j = Math.max(arr[a], arr[b]);
+        const key = i * lines.length + j;
+        if (tested.has(key)) continue;
+        tested.add(key);
+        if (linesIntersect(lines[i], lines[j])) {
+          union(i, j);
+        }
       }
     }
   }
@@ -1008,7 +1052,8 @@ function cellTextToString(items) {
     }
   }
   lines.push(curLine);
-  const textLines = lines.map((line) => {
+  const merged = mergeSuperscriptRows(lines);
+  const textLines = merged.map((line) => {
     const s = line.sort((a, b) => a.x - b.x);
     if (s.length === 1) return s[0].text;
     const evenSpaced = detectEvenSpacedItems(s);
@@ -1032,6 +1077,40 @@ function cellTextToString(items) {
   });
   return mergeCellTextLines(textLines);
 }
+function mergeSuperscriptRows(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) => {
+    if (line.length > 8) return false;
+    let total = 0;
+    for (const i of line) total += i.text.trim().length;
+    return total > 0 && total <= 10;
+  };
+  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);
+    }
+  }
+  return result;
+}
 function detectEvenSpacedItems(items) {
   const result = new Array(items.length).fill(false);
   if (items.length < 3) return result;
@@ -1071,12 +1150,12 @@ function markEvenRun(items, result, start, end) {
   for (let i = start + 1; i < end; i++) {
     gaps.push(items[i].x - (items[i - 1].x + items[i - 1].w));
   }
-  const posGaps = gaps.filter((g2) => g2 > 0);
+  const posGaps = gaps.filter((g) => g > 0);
   if (posGaps.length < 2) return;
   let minGap = Infinity, maxGap = -Infinity;
-  for (const g2 of posGaps) {
-    if (g2 < minGap) minGap = g2;
-    if (g2 > maxGap) maxGap = g2;
+  for (const g of posGaps) {
+    if (g < minGap) minGap = g;
+    if (g > maxGap) maxGap = g;
   }
   const avgFs = items[start].fontSize;
   if (minGap >= avgFs * 0.1 && maxGap <= avgFs * 3 && maxGap / Math.max(minGap, 0.1) <= 3) {
@@ -1221,301 +1300,6 @@ function normalizeUndersegmentedTable(originalCells, colXs, items) {
   return rebuilt;
 }
 
-// src/pdf/image-extract.ts
-import { OPS as OPS3, ImageKind } from "pdfjs-dist/legacy/build/pdf.mjs";
-var IMAGE_RESOLVE_TIMEOUT_MS = 5e3;
-function resolveImgData(page, objId) {
-  const store = objId.startsWith("g_") ? page.commonObjs : page.objs;
-  return new Promise((resolve) => {
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        resolve(null);
-      }
-    }, IMAGE_RESOLVE_TIMEOUT_MS);
-    try {
-      store.get(objId, (data) => {
-        if (!done) {
-          done = true;
-          clearTimeout(timer);
-          resolve(data ?? null);
-        }
-      });
-    } catch {
-      if (!done) {
-        done = true;
-        clearTimeout(timer);
-        resolve(null);
-      }
-    }
-  });
-}
-var MIN_DIM = 8;
-var MAX_PIXELS = 36e6;
-var MAX_IMAGES_PER_DOC = 200;
-var MAX_TOTAL_IMAGE_BYTES = 128 * 1024 * 1024;
-function createPdfImageState() {
-  return { imageIndex: 0, totalBytes: 0, seen: /* @__PURE__ */ new Map(), capWarned: false };
-}
-function fnv1a(data) {
-  let h = 2166136261;
-  for (let i = 0; i < data.length; i++) {
-    h ^= data[i];
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-function toRgba(img) {
-  const { width: w, height: h, kind, data } = img;
-  if (!data || !w || !h) return null;
-  const rgba = new Uint8Array(w * h * 4);
-  if (kind === ImageKind.RGBA_32BPP) {
-    if (data.length < w * h * 4) return null;
-    rgba.set(data.subarray(0, w * h * 4));
-    return rgba;
-  }
-  if (kind === ImageKind.RGB_24BPP) {
-    if (data.length < w * h * 3) return null;
-    for (let i = 0, s = 0, d = 0; i < w * h; i++, s += 3, d += 4) {
-      rgba[d] = data[s];
-      rgba[d + 1] = data[s + 1];
-      rgba[d + 2] = data[s + 2];
-      rgba[d + 3] = 255;
-    }
-    return rgba;
-  }
-  if (kind === ImageKind.GRAYSCALE_1BPP) {
-    const stride = w + 7 >> 3;
-    if (data.length < stride * h) return null;
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        const bit = data[y * stride + (x >> 3)] >> 7 - (x & 7) & 1;
-        const v = bit ? 255 : 0;
-        const d = (y * w + x) * 4;
-        rgba[d] = v;
-        rgba[d + 1] = v;
-        rgba[d + 2] = v;
-        rgba[d + 3] = 255;
-      }
-    }
-    return rgba;
-  }
-  return null;
-}
-async function extractPageImages(page, fnArray, argsArray, pageNumber, state, warnings) {
-  const blocks = [];
-  const images = [];
-  const pageSeenIds = /* @__PURE__ */ new Set();
-  for (let i = 0; i < fnArray.length; i++) {
-    const op = fnArray[i];
-    let imgData = null;
-    let dedupeId = null;
-    if (op === OPS3.paintImageXObject || op === OPS3.paintImageXObjectRepeat) {
-      const objId = argsArray[i]?.[0];
-      if (typeof objId !== "string" || pageSeenIds.has(objId)) continue;
-      pageSeenIds.add(objId);
-      dedupeId = objId;
-      imgData = await resolveImgData(page, objId);
-    } else if (op === OPS3.paintInlineImageXObject) {
-      imgData = argsArray[i]?.[0];
-    } else {
-      continue;
-    }
-    if (!imgData?.data || !imgData.width || !imgData.height) continue;
-    const { width: w, height: h } = imgData;
-    if (w < MIN_DIM || h < MIN_DIM) continue;
-    if (w * h > MAX_PIXELS) {
-      warnings.push({ page: pageNumber, message: `\uC774\uBBF8\uC9C0 \uD06C\uAE30 \uCD08\uACFC\uB85C \uCD94\uCD9C \uC0DD\uB7B5 (${w}\xD7${h})`, code: "SKIPPED_IMAGE" });
-      continue;
-    }
-    const hash = `${w}x${h}k${imgData.kind ?? "?"}h${fnv1a(imgData.data)}${dedupeId ? "" : "inline"}`;
-    if (state.seen.has(hash)) continue;
-    if (state.imageIndex >= MAX_IMAGES_PER_DOC || state.totalBytes >= MAX_TOTAL_IMAGE_BYTES) {
-      if (!state.capWarned) {
-        state.capWarned = true;
-        warnings.push({ page: pageNumber, message: `\uC774\uBBF8\uC9C0 \uCD94\uCD9C \uC0C1\uD55C \uB3C4\uB2EC (${MAX_IMAGES_PER_DOC}\uAC1C/128MB) \u2014 \uC774\uD6C4 \uC774\uBBF8\uC9C0 \uC0DD\uB7B5`, code: "SKIPPED_IMAGE" });
-      }
-      continue;
-    }
-    const rgba = toRgba(imgData);
-    if (!rgba) continue;
-    const png = encodePng(w, h, rgba);
-    state.imageIndex++;
-    state.totalBytes += png.length;
-    const filename = `image_${String(state.imageIndex).padStart(3, "0")}.png`;
-    state.seen.set(hash, filename);
-    images.push({ filename, data: png, mimeType: "image/png" });
-    blocks.push({ type: "image", text: filename, pageNumber });
-  }
-  return { blocks, images };
-}
-function injectPageImageBlocks(blocks, pageImages) {
-  if (pageImages.size === 0) return;
-  const lastIndexForPage = /* @__PURE__ */ new Map();
-  for (let i = 0; i < blocks.length; i++) {
-    const p = blocks[i].pageNumber;
-    if (p !== void 0) lastIndexForPage.set(p, i);
-  }
-  const pageAtIndex = /* @__PURE__ */ new Map();
-  for (const [p, last] of lastIndexForPage) pageAtIndex.set(last, p);
-  const result = [];
-  const injected = /* @__PURE__ */ new Set();
-  for (let i = 0; i < blocks.length; i++) {
-    result.push(blocks[i]);
-    const p = pageAtIndex.get(i);
-    if (p !== void 0 && pageImages.has(p)) {
-      result.push(...pageImages.get(p));
-      injected.add(p);
-    }
-  }
-  for (const p of [...pageImages.keys()].sort((a, b) => a - b)) {
-    if (injected.has(p)) continue;
-    let at = result.length;
-    for (let i = 0; i < result.length; i++) {
-      const bp = result[i].pageNumber;
-      if (bp !== void 0 && bp > p) {
-        at = i;
-        break;
-      }
-    }
-    result.splice(at, 0, ...pageImages.get(p));
-  }
-  blocks.length = 0;
-  blocks.push(...result);
-}
-
-// src/pdf/quality.ts
-var RARE_JONG = /* @__PURE__ */ new Set([3, 5, 6, 9, 10, 11, 12, 13, 14, 15, 18, 24, 25, 26]);
-var MOJIBAKE_MIN_HANGUL = 30;
-var MOJIBAKE_MAX_NOBATCHIM = 0.15;
-var MOJIBAKE_MIN_RAREBATCHIM = 0.25;
-function computePageQuality(page, text) {
-  let total = 0;
-  let hangul = 0;
-  let hangulNoBatchim = 0;
-  let hangulRareBatchim = 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;
-    }
-    if (code >= 44032 && code <= 55203) {
-      hangul++;
-      const jong = (code - 44032) % 28;
-      if (jong === 0) hangulNoBatchim++;
-      else if (RARE_JONG.has(jong)) hangulRareBatchim++;
-      continue;
-    }
-    if (code >= 57344 && code <= 63743 || code >= 56192 && code <= 56319) {
-      pua++;
-      continue;
-    }
-  }
-  const denom = total || 1;
-  const puaRatio = pua / denom;
-  const controlCharRatio = control / denom;
-  const replacementCharRatio = replacement / denom;
-  const hangulNoBatchimRatio = hangul > 0 ? hangulNoBatchim / hangul : 0;
-  const hangulRareBatchimRatio = hangul > 0 ? hangulRareBatchim / hangul : 0;
-  const garbledHangul = hangul >= MOJIBAKE_MIN_HANGUL && hangulNoBatchimRatio < MOJIBAKE_MAX_NOBATCHIM && hangulRareBatchimRatio >= MOJIBAKE_MIN_RAREBATCHIM;
-  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";
-  } else if (garbledHangul) {
-    needsOcr = true;
-    ocrReason = "garbled_hangul";
-  }
-  return {
-    page,
-    textChars: total,
-    hangulRatio: hangul / denom,
-    controlCharRatio,
-    replacementCharRatio,
-    puaRatio,
-    hangulNoBatchimRatio,
-    hangulRareBatchimRatio,
-    needsOcr,
-    ocrReason
-  };
-}
-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 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: []
-    };
-  }
-  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);
-  }
-  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
-  };
-}
-
 // src/pdf/text-line.ts
 function filterHiddenText(items, pageWidth, pageHeight) {
   let hiddenCount = 0;
@@ -1610,7 +1394,8 @@ function normalizeItems(rawItems) {
     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) {
+      const xTol = Math.min(3, Math.max(0.5, sorted[i].w * 0.5));
+      if (Math.abs(prev.y - sorted[i].y) <= 3 && prev.text === sorted[i].text && Math.abs(prev.x - sorted[i].x) <= xTol) {
         isDup = true;
         break;
       }
@@ -1672,7 +1457,12 @@ function mergeSuperscriptLines(lines) {
     }
     return { bottom, top, height: top - bottom };
   };
-  const isFrag = (line) => line.length <= 3 && line.every((i) => i.text.trim().length <= 8);
+  const isFrag = (line) => {
+    if (line.length > 8) return false;
+    let total = 0;
+    for (const i of line) total += i.text.trim().length;
+    return total > 0 && total <= 10;
+  };
   const result = [lines[0]];
   for (let i = 1; i < lines.length; i++) {
     const prev = result[result.length - 1];
@@ -1724,1339 +1514,1356 @@ function mergeLineSimple(items) {
   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);
-      }
-    }
-  }
-  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);
-          }
-        }
-      }
-    }
+// 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 results.filter((r) => !isTwoColumnProse(r));
+  return sorted[sorted.length - 1][0];
 }
-function isTwoColumnProse(r) {
-  const t = r.table;
-  if (t.rows < 8) return false;
-  const dense = [];
-  for (let c = 0; c < t.cols; c++) {
-    const filled = t.cells.filter((row) => row[c]?.text.trim()).length;
-    if (filled / t.rows >= 0.3) dense.push(c);
-  }
-  if (dense.length !== 2) return false;
-  for (const c of dense) {
-    const lens = t.cells.map((row) => row[c]?.text.replace(/\s+/g, "").length ?? 0).filter((n) => n > 0);
-    const avg = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
-    if (avg < 12) return false;
-  }
-  return findTwoColumnProseCutX([...r.usedItems]) !== null;
-}
-function findTwoColumnProseCutX(items) {
-  const lines = groupByBaseline(items);
-  if (lines.length < 8) return null;
-  let minX = Infinity;
-  let maxX = -Infinity;
-  for (const i of items) {
-    if (i.x < minX) minX = i.x;
-    if (i.x + i.w > maxX) maxX = i.x + i.w;
-  }
-  if (!Number.isFinite(maxX - minX)) return null;
-  if (maxX - minX < 100) return null;
-  const lo = minX + (maxX - minX) * 0.3;
-  const hi = minX + (maxX - minX) * 0.7;
-  const step = Math.max(2, (hi - lo) / 400);
-  let cutX = 0;
-  let bestCover = Infinity;
-  for (let x = lo; x <= hi; x += step) {
-    let cover = 0;
-    for (const line of lines) {
-      if (line.items.some((i) => i.x < x && i.x + i.w > x)) cover++;
-    }
-    if (cover < bestCover) {
-      bestCover = cover;
-      cutX = x;
-    }
-  }
-  if (bestCover / lines.length > 0.15) return null;
-  const left = [];
-  const right = [];
-  let twoSide = 0;
-  for (const line of lines) {
-    let hasL = false;
-    let hasR = false;
-    for (const i of line.items) {
-      if (i.x + i.w <= cutX) {
-        left.push(i);
-        hasL = true;
-      } else if (i.x >= cutX) {
-        right.push(i);
-        hasR = true;
-      }
-    }
-    if (hasL && hasR) twoSide++;
-  }
-  if (twoSide / lines.length < 0.55) return null;
-  if (left.length < 5 || right.length < 5) return null;
-  const allText = items.map((i) => i.text).join("").replace(/\s+/g, "");
-  const digits = (allText.match(/[\d,.%△—-]/g) || []).length;
-  if (allText.length === 0 || digits / allText.length > 0.15) return null;
-  const stats = [left, right].map((side) => {
-    let sMinX = Infinity;
-    let sMaxR = -Infinity;
-    let fsSum = 0;
-    const rowEnds = /* @__PURE__ */ new Map();
-    const rowLens = /* @__PURE__ */ new Map();
-    const rowFirst = /* @__PURE__ */ new Map();
-    for (const i of side) {
-      if (i.x < sMinX) sMinX = i.x;
-      const rgt = i.x + i.w;
-      if (rgt > sMaxR) sMaxR = rgt;
-      fsSum += i.fontSize;
-      const key = Math.round(i.y / 4);
-      rowEnds.set(key, Math.max(rowEnds.get(key) ?? -Infinity, rgt));
-      rowLens.set(key, (rowLens.get(key) ?? 0) + i.text.replace(/\s+/g, "").length);
-      const f = rowFirst.get(key);
-      if (!f || i.x < f.x) rowFirst.set(key, i);
-    }
-    const ends = [...rowEnds.values()].sort((a, b) => a - b);
-    const p85 = ends[Math.floor(ends.length * 0.85)] ?? sMaxR;
-    const fs = fsSum / side.length;
-    const justified = ends.filter((e) => Math.abs(e - p85) <= fs).length / ends.length;
-    const lens = [...rowLens.values()];
-    const avgLen = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
-    const markers = [...rowFirst.values()].filter((i) => /^[•▪◦‣∙·\-–—□■◇◆▶※*]/.test(i.text)).length;
-    return { width: sMaxR - sMinX, justified, avgLen, markerRatio: markers / (rowFirst.size || 1) };
-  });
-  if (stats.some((s) => s.avgLen < 12)) return null;
-  if (stats.some((s) => s.markerRatio > 0.1)) return null;
-  const widthSym = Math.min(stats[0].width, stats[1].width) / Math.max(stats[0].width, stats[1].width);
-  if (widthSym < 0.6) return null;
-  if (Math.min(stats[0].justified, stats[1].justified) < 0.55) return null;
-  return cutX;
-}
-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);
-}
-function detectHeaderRow(rows) {
-  const allItems = rows.flatMap((r) => r.items);
-  if (allItems.length === 0) return null;
-  let allMinX = Infinity, allMaxX = -Infinity;
-  for (const i of allItems) {
-    if (i.x < allMinX) allMinX = i.x;
-    const r = i.x + i.w;
-    if (r > allMaxX) allMaxX = r;
-  }
-  const pageSpan = allMaxX - allMinX;
-  if (pageSpan <= 0) return null;
-  for (let ri = 0; ri < rows.length; ri++) {
-    const row = rows[ri];
-    if (row.items.length < MIN_COLS || row.items.length > 6) continue;
-    if (row.items.some((i) => i.text.length > 8)) continue;
-    if (!row.items.some((i) => /[가-힣]/.test(i.text))) continue;
-    if (row.items.some((i) => /^[□■○●·※▶▷◆◇\-]/.test(i.text))) continue;
-    const sorted = [...row.items].sort((a, b) => a.x - b.x);
-    const xSpan = sorted[sorted.length - 1].x + sorted[sorted.length - 1].w - sorted[0].x;
-    if (xSpan / pageSpan < 0.4) continue;
-    const avgFs = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
-    let hasLargeGap = false;
-    for (let i = 1; i < sorted.length; i++) {
-      const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
-      if (gap >= avgFs * 2.5) {
-        hasLargeGap = true;
-        break;
-      }
-    }
-    if (!hasLargeGap) continue;
-    const columns = sorted.map((item) => ({ x: item.x, count: 0 }));
-    let matchCount = 0;
-    for (let j = ri + 1; j < rows.length && matchCount < MIN_ROWS + 2; j++) {
-      const matched = countMatchedColumnsRange(rows[j], columns, sorted);
-      if (matched >= MIN_COLS) matchCount++;
-    }
-    if (matchCount < MIN_ROWS) continue;
-    return { columns, headerIdx: ri };
-  }
-  return null;
-}
-function 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 result;
-}
-function isFragmentRow(row) {
-  return row.items.length <= 3 && row.items.every((i) => i.text.length <= 8);
-}
-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;
-  }
-  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);
-    }
-  }
-  return result;
-}
-function groupByBaseline(items) {
-  if (items.length === 0) return [];
-  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
-  const rows = [];
-  let curItems = [sorted[0]];
-  let curY = sorted[0].y;
-  for (let i = 1; i < sorted.length; i++) {
-    if (Math.abs(sorted[i].y - curY) <= Y_TOL) {
-      curItems.push(sorted[i]);
-    } else {
-      rows.push({ y: curY, items: curItems });
-      curItems = [sorted[i]];
-      curY = sorted[i].y;
+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);
     }
   }
-  if (curItems.length > 0) rows.push({ y: curY, items: curItems });
-  return rows;
 }
-function hasSuspiciousGaps(row) {
-  if (row.items.length < 2) return false;
-  const sorted = [...row.items].sort((a, b) => a.x - b.x);
-  if (sorted.length === 2 && sorted[1].text.length > 20) return false;
-  const avgFontSize = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
-  const minGap = Math.max(avgFontSize * MIN_GAP_FACTOR, MIN_GAP_ABSOLUTE);
-  for (let i = 1; i < sorted.length; i++) {
-    const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
-    if (gap >= minGap) return true;
+function shouldDemoteTable(table) {
+  const allCells = table.cells.flatMap((row) => row.map((c) => c.text.trim())).filter(Boolean);
+  const allText = allCells.join(" ");
+  if (table.rows >= 2 && table.cols >= 2 && table.cells[0].every((c) => {
+    const t = c.text.trim();
+    return t.length > 0 && t.length <= 12 && !/[□■◆○●▶ㅇ<>]/.test(t);
+  }) && table.cells.slice(1).some((row) => row.some((c) => c.text.trim() !== ""))) return false;
+  if (table.rows <= 3 && table.cols <= 3 && allText.length <= 200) {
+    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 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 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 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);
+  return lines.join("\n");
 }
-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] });
+function detectMarkerHeadings(blocks) {
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type !== "paragraph" || !block.text) continue;
+    const text = block.text.trim();
+    if (text.length < 50 && /^[□■◆◇▶]\s*[가-힣]/.test(text)) {
+      block.type = "heading";
+      block.level = 4;
+      continue;
+    }
+    if (/^[가-힣]{2,6}$/.test(text) && block.style?.fontSize) {
+      const prev = blocks[i - 1];
+      const next = blocks[i + 1];
+      const prevIsStructural = !prev || prev.type === "table" || prev.type === "heading" || prev.type === "separator";
+      const nextIsStructural = !next || next.type === "table" || next.type === "heading" || next.type === "paragraph" && next.text && /^[□■◆○●]/.test(next.text.trim());
+      if (prevIsStructural || nextIsStructural) {
+        block.type = "heading";
+        block.level = 3;
       }
-      currentRegion = [];
-      missStreak = 0;
     }
   }
-  while (currentRegion.length > 0) {
-    const last = currentRegion[currentRegion.length - 1];
-    if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
-    currentRegion.pop();
+}
+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);
+    }
   }
-  if (currentRegion.length >= MIN_ROWS) {
-    regions.push({ rows: currentRegion });
+}
+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 regions;
+  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 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);
+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];
       }
+    }
+    if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
+  }
+  let familyStack = [];
+  let lastTopLevelList = null;
+  let prevListIdx = -2;
+  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 (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 {
-      if (currentRegion.length >= MIN_ROWS) {
-        regions.push({ rows: [...currentRegion] });
-      }
-      currentRegion = [];
+      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 && i === prevListIdx + 1) {
+      if (!lastTopLevelList.children) lastTopLevelList.children = [];
+      lastTopLevelList.children.push(listBlock);
+      toRemove.add(i);
+    } else {
+      blocks[i] = listBlock;
+      lastTopLevelList = listBlock;
     }
+    prevListIdx = i;
   }
-  if (currentRegion.length >= MIN_ROWS) {
-    regions.push({ rows: currentRegion });
+  if (toRemove.size > 0) {
+    const sorted = [...toRemove].sort((a, b) => b - a);
+    for (const idx of sorted) blocks.splice(idx, 1);
   }
-  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;
+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;
       }
-    }
-  }
-  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 (/^[○●·※▶▷◆◇\-]\s/.test(text)) {
+        result.push({ ...block, type: "list", listType: "unordered", text: block.text });
+        continue;
       }
     }
+    result.push(block);
   }
-  return matched.size;
+  return result;
 }
-function assignRowItems(items, columns, numCols) {
-  if (items.length === 0) return [];
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  const colCenters = columns.map((c) => c.x);
-  const gaps = [];
-  for (let i = 1; i < sorted.length; i++) {
-    gaps.push({ idx: i, size: sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w) });
-  }
-  const gapSizes = gaps.map((g2) => g2.size).sort((a, b) => a - b);
-  const medianGap = gapSizes.length > 0 ? gapSizes[Math.floor(gapSizes.length / 2)] : 0;
-  const gapThreshold = sorted.length <= numCols + 1 ? 12 : Math.max(medianGap * 2.5, 12);
-  const significantGaps = gaps.filter((g2) => g2.size >= gapThreshold).sort((a, b) => b.size - a.size).slice(0, numCols - 1).sort((a, b) => a.idx - b.idx);
-  const groups = [];
-  let start = 0;
-  for (const gap of significantGaps) {
-    groups.push(sorted.slice(start, gap.idx));
-    start = gap.idx;
-  }
-  groups.push(sorted.slice(start));
+var KOREAN_TABLE_HEADER_RE = /^\(?(구분|항목|종류|분류|유형|대상|내용|기간|금액|비율|방법|절차|요건|조건|근거|목적|범위|기준)\)?[:\s]/;
+var KV_FALSE_POSITIVE_RE = /\d{1,2}:\d{2}|:\/\/|\d+:\d+/;
+function detectSpecialKoreanTables(blocks) {
   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;
+  let kvLines = [];
+  const flushKvTable = () => {
+    if (kvLines.length < 2) {
+      for (const kv of kvLines) result.push(kv.block);
+      kvLines = [];
+      return;
     }
-    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 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;
     }
-  }
-  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;
+    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;
     }
-    result.push({ col: bestCol, items: groups[gi] });
+    if (kvLines.length > 0 && text.includes(":")) {
+      if (!KV_FALSE_POSITIVE_RE.test(text) && !text.includes("(") && !text.includes(")")) {
+        const colonIdx = text.indexOf(":");
+        const key = text.slice(0, colonIdx).trim();
+        if (/^[가-힣]+$/.test(key) && key.length >= 2 && key.length <= 8) {
+          kvLines.push({
+            key,
+            value: text.slice(colonIdx + 1).trim(),
+            block
+          });
+          continue;
+        }
+      }
+    }
+    flushKvTable();
+    result.push(block);
   }
+  flushKvTable();
   return result;
 }
-function buildClusterTable(rows, columns, pageNum) {
-  const numCols = columns.length;
-  const numRows = rows.length;
-  if (numRows < MIN_ROWS || numCols < MIN_COLS) return null;
-  const cells = Array.from(
-    { length: numRows },
-    () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
-  );
-  const usedItems = /* @__PURE__ */ new Set();
-  for (let r = 0; r < numRows; r++) {
-    const row = rows[r];
-    if (row.items.length === 1 && numCols > 1) {
-      cells[r][0] = { text: row.items[0].text, colSpan: numCols, rowSpan: 1 };
-      usedItems.add(row.items[0]);
-      continue;
+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) topEntries.push(entry);
+    else if (blockTop >= ph * (1 - ZONE_RATIO)) bottomEntries.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 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);
+    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)) continue;
+      const cand = blocks[e.blockIdx];
+      const cb = cand.bbox;
+      let sharesLine = false;
+      for (let bi = 0; bi < blocks.length; bi++) {
+        if (bi === e.blockIdx) continue;
+        const o = blocks[bi];
+        if (!o.bbox || o.bbox.page !== cb.page) continue;
+        const oNorm = o.text?.trim().replace(/\d+/g, "#");
+        if (oNorm && repeatedPatterns.has(oNorm)) continue;
+        const overlap = Math.min(cb.y + cb.height, o.bbox.y + o.bbox.height) - Math.max(cb.y, o.bbox.y);
+        if (overlap >= cb.height * 0.5) {
+          sharesLine = true;
+          break;
+        }
+      }
+      if (!sharesLine) removeSet.add(e.blockIdx);
     }
   }
-  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;
+  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" });
   }
-  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;
+  return [...removeSet].sort((a, b) => a - b);
+}
+
+// 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 = 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;
+  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++) 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) {
+  return results.filter((r) => !isTwoColumnProse(r));
+}
+function isTwoColumnProse(r) {
+  const t = r.table;
+  if (t.rows < 8) return false;
+  const dense = [];
+  for (let c = 0; c < t.cols; c++) {
+    const filled = t.cells.filter((row) => row[c]?.text.trim()).length;
+    if (filled / t.rows >= 0.3) dense.push(c);
+  }
+  if (dense.length !== 2) return false;
+  for (const c of dense) {
+    const lens = t.cells.map((row) => row[c]?.text.replace(/\s+/g, "").length ?? 0).filter((n) => n > 0);
+    const avg = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
+    if (avg < 12) return false;
+  }
+  return findTwoColumnProseCutX([...r.usedItems]) !== null;
+}
+function findTwoColumnProseCutX(items) {
+  const lines = groupByBaseline(items);
+  if (lines.length < 8) return null;
+  let minX = Infinity;
+  let maxX = -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 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;
-var CROSS_OVERLAP_RATIO = 0.1;
-var CROSS_MIN_OVERLAPS = 2;
-var CROSS_MAX_MASK_RATIO = 0.2;
-var NARROW_ELEMENT_WIDTH_RATIO = 0.1;
-function xyCutOrder(items, gapThreshold, depth = 0) {
-  if (items.length === 0) return [];
-  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return [items];
-  if (depth === 0 && items.length >= 3) {
-    const cross = identifyCrossLayoutItems(items);
-    if (cross.size > 0 && cross.size <= items.length * CROSS_MAX_MASK_RATIO) {
-      const rest = items.filter((i) => !cross.has(i));
-      if (rest.length > 0) {
-        const groups = xyCutOrder(rest, gapThreshold, 1);
-        return mergeCrossLayoutGroups(groups, [...cross]);
+  if (!Number.isFinite(maxX - minX)) return null;
+  if (maxX - minX < 100) return null;
+  const lo = minX + (maxX - minX) * 0.3;
+  const hi = minX + (maxX - minX) * 0.7;
+  const step = Math.max(2, (hi - lo) / 400);
+  let cutX = 0;
+  let bestCover = Infinity;
+  for (let x = lo; x <= hi; x += step) {
+    let cover = 0;
+    for (const line of lines) {
+      if (line.items.some((i) => i.x < x && i.x + i.w > x)) cover++;
+    }
+    if (cover < bestCover) {
+      bestCover = cover;
+      cutX = x;
+    }
+  }
+  if (bestCover / lines.length > 0.15) return null;
+  const left = [];
+  const right = [];
+  let twoSide = 0;
+  for (const line of lines) {
+    let hasL = false;
+    let hasR = false;
+    for (const i of line.items) {
+      if (i.x + i.w <= cutX) {
+        left.push(i);
+        hasL = true;
+      } else if (i.x >= cutX) {
+        right.push(i);
+        hasR = true;
       }
     }
+    if (hasL && hasR) twoSide++;
   }
-  const minGap = Math.max(XYCUT_MIN_GAP, gapThreshold);
-  const hCut = findHorizontalCut(items);
-  const vCut = findVerticalCutWithOutlierFilter(items, minGap);
-  const hValid = hCut.gap >= minGap;
-  const vValid = vCut.gap >= minGap;
-  let useHorizontal;
-  if (hValid && vValid) useHorizontal = vCut.gap <= hCut.gap * 1.5;
-  else if (hValid) useHorizontal = true;
-  else if (vValid) useHorizontal = false;
-  else return [items];
-  if (useHorizontal) {
-    const upper = items.filter((i) => i.y > hCut.position);
-    const lower = items.filter((i) => i.y <= hCut.position);
-    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
-      return [...xyCutOrder(upper, gapThreshold, depth + 1), ...xyCutOrder(lower, gapThreshold, depth + 1)];
+  if (twoSide / lines.length < 0.55) return null;
+  if (left.length < 5 || right.length < 5) return null;
+  const allText = items.map((i) => i.text).join("").replace(/\s+/g, "");
+  const digits = (allText.match(/[\d,.%△—-]/g) || []).length;
+  if (allText.length === 0 || digits / allText.length > 0.15) return null;
+  const stats = [left, right].map((side) => {
+    let sMinX = Infinity;
+    let sMaxR = -Infinity;
+    let fsSum = 0;
+    const rowEnds = /* @__PURE__ */ new Map();
+    const rowLens = /* @__PURE__ */ new Map();
+    const rowFirst = /* @__PURE__ */ new Map();
+    for (const i of side) {
+      if (i.x < sMinX) sMinX = i.x;
+      const rgt = i.x + i.w;
+      if (rgt > sMaxR) sMaxR = rgt;
+      fsSum += i.fontSize;
+      const key = Math.round(i.y / 4);
+      rowEnds.set(key, Math.max(rowEnds.get(key) ?? -Infinity, rgt));
+      rowLens.set(key, (rowLens.get(key) ?? 0) + i.text.replace(/\s+/g, "").length);
+      const f = rowFirst.get(key);
+      if (!f || i.x < f.x) rowFirst.set(key, i);
     }
-  } else {
-    const left = items.filter((i) => i.x + i.w / 2 < vCut.position);
-    const right = items.filter((i) => i.x + i.w / 2 >= vCut.position);
-    if (left.length > 0 && right.length > 0 && left.length < items.length) {
-      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
+    const ends = [...rowEnds.values()].sort((a, b) => a - b);
+    const p85 = ends[Math.floor(ends.length * 0.85)] ?? sMaxR;
+    const fs = fsSum / side.length;
+    const justified = ends.filter((e) => Math.abs(e - p85) <= fs).length / ends.length;
+    const lens = [...rowLens.values()];
+    const avgLen = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
+    const markers = [...rowFirst.values()].filter((i) => /^[•▪◦‣∙·\-–—□■◇◆▶※*]/.test(i.text)).length;
+    return { width: sMaxR - sMinX, justified, avgLen, markerRatio: markers / (rowFirst.size || 1) };
+  });
+  if (stats.some((s) => s.avgLen < 12)) return null;
+  if (stats.some((s) => s.markerRatio > 0.1)) return null;
+  const widthSym = Math.min(stats[0].width, stats[1].width) / Math.max(stats[0].width, stats[1].width);
+  if (widthSym < 0.6) return null;
+  if (Math.min(stats[0].justified, stats[1].justified) < 0.55) return null;
+  return cutX;
+}
+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 g = i + 1; g < runEnd; g++) {
+            gaps.push(sorted[g].x - (sorted[g - 1].x + sorted[g - 1].w));
+          }
+          let minG = Infinity, maxG = -Infinity;
+          for (const g of gaps) {
+            if (g < minG) minG = g;
+            if (g > maxG) maxG = g;
+          }
+          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 [items];
+  return { merged, originMap };
 }
-function identifyCrossLayoutItems(items) {
-  const cross = /* @__PURE__ */ new Set();
-  if (items.length < 3) return cross;
-  let maxWidth = 0;
-  for (const i of items) {
-    if (i.w > maxWidth) maxWidth = i.w;
+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);
   }
-  const threshold = CROSS_LAYOUT_BETA * maxWidth;
-  for (const item of items) {
-    if (item.w < threshold) continue;
-    let overlaps = 0;
-    for (const other of items) {
-      if (other === item) continue;
-      const left = Math.max(item.x, other.x);
-      const right = Math.min(item.x + item.w, other.x + other.w);
-      const overlapW = right - left;
-      if (overlapW <= 0) continue;
-      const smaller = Math.min(item.w, other.w);
-      if (smaller > 0 && overlapW / smaller >= CROSS_OVERLAP_RATIO) {
-        overlaps++;
-        if (overlaps >= CROSS_MIN_OVERLAPS) break;
+  for (const a of toAdd) usedItems.add(a);
+}
+function detectHeaderRow(rows) {
+  const allItems = rows.flatMap((r) => r.items);
+  if (allItems.length === 0) return null;
+  let allMinX = Infinity, allMaxX = -Infinity;
+  for (const i of allItems) {
+    if (i.x < allMinX) allMinX = i.x;
+    const r = i.x + i.w;
+    if (r > allMaxX) allMaxX = r;
+  }
+  const pageSpan = allMaxX - allMinX;
+  if (pageSpan <= 0) return null;
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
+    if (row.items.length < MIN_COLS || row.items.length > 6) continue;
+    if (row.items.some((i) => i.text.length > 8)) continue;
+    if (!row.items.some((i) => /[가-힣]/.test(i.text))) continue;
+    if (row.items.some((i) => /^[□■○●·※▶▷◆◇\-]/.test(i.text))) continue;
+    const sorted = [...row.items].sort((a, b) => a.x - b.x);
+    const xSpan = sorted[sorted.length - 1].x + sorted[sorted.length - 1].w - sorted[0].x;
+    if (xSpan / pageSpan < 0.4) continue;
+    const avgFs = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
+    let hasLargeGap = false;
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
+      if (gap >= avgFs * 2.5) {
+        hasLargeGap = true;
+        break;
       }
     }
-    if (overlaps >= CROSS_MIN_OVERLAPS) cross.add(item);
+    if (!hasLargeGap) continue;
+    const columns = sorted.map((item) => ({ x: item.x, count: 0 }));
+    let matchCount = 0;
+    for (let j = ri + 1; j < rows.length && matchCount < MIN_ROWS + 2; j++) {
+      const matched = countMatchedColumnsRange(rows[j], columns, sorted);
+      if (matched >= MIN_COLS) matchCount++;
+    }
+    if (matchCount < MIN_ROWS) continue;
+    return { columns, headerIdx: ri };
   }
-  return cross;
+  return null;
 }
-function mergeCrossLayoutGroups(groups, cross) {
-  if (cross.length === 0) return groups;
-  const sortedCross = [...cross].sort((a, b) => b.y + b.h - (a.y + a.h) || a.x - b.x);
-  const groupTop = (g2) => {
-    let top = -Infinity;
-    for (const i of g2) {
-      const t = i.y + i.h;
-      if (t > top) top = t;
-    }
-    return top;
-  };
-  const result = [];
-  let gi = 0, ci = 0;
-  while (gi < groups.length || ci < sortedCross.length) {
-    if (ci >= sortedCross.length) {
-      result.push(groups[gi++]);
-      continue;
-    }
-    if (gi >= groups.length) {
-      result.push([sortedCross[ci++]]);
-      continue;
+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);
     }
-    const crossTop = sortedCross[ci].y + sortedCross[ci].h;
-    if (crossTop >= groupTop(groups[gi])) result.push([sortedCross[ci++]]);
-    else result.push(groups[gi++]);
   }
   return result;
 }
-function findHorizontalCut(items) {
-  if (items.length < 2) return { position: 0, gap: 0 };
-  const sorted = [...items].sort((a, b) => b.y - a.y);
-  let largestGap = 0;
-  let position = 0;
-  for (let i = 1; i < sorted.length; i++) {
-    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
-    const currTop = sorted[i].y;
-    const gap = prevBottom - currTop;
-    if (gap > largestGap) {
-      largestGap = gap;
-      position = (prevBottom + currTop) / 2;
-    }
+function isFragmentRow(row) {
+  return row.items.length <= 3 && row.items.every((i) => i.text.length <= 8);
+}
+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;
   }
-  return { position, gap: largestGap };
+  return { bottom, top, height: top - bottom };
 }
-function findVerticalCutWithOutlierFilter(items, minGap) {
-  const edgeCut = findVerticalCut(items);
-  if (edgeCut.gap >= minGap) return edgeCut;
-  if (items.length >= 3) {
-    let minX = Infinity, maxX = -Infinity;
-    for (const i of items) {
-      if (i.x < minX) minX = i.x;
-      const r = i.x + i.w;
-      if (r > maxX) maxX = r;
-    }
-    const narrowThreshold = (maxX - minX) * NARROW_ELEMENT_WIDTH_RATIO;
-    const filtered = items.filter((i) => i.w >= narrowThreshold);
-    if (filtered.length >= 2 && filtered.length < items.length && filtered.length >= items.length * 0.7) {
-      const filteredCut = findVerticalCut(filtered);
-      if (filteredCut.gap > edgeCut.gap && filteredCut.gap >= minGap) {
-        return filteredCut;
-      }
+function mergeMultiLineRows(rows, columns) {
+  if (rows.length <= 1) return rows;
+  const result = [rows[0]];
+  const allFontSizes = rows.flatMap((r) => r.items).map((i) => i.fontSize);
+  const avgFontSize = allFontSizes.length > 0 ? allFontSizes.reduce((s, v) => s + v, 0) / allFontSizes.length : 12;
+  for (let i = 1; i < rows.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = rows[i];
+    const yGap = Math.abs(prev.y - curr.y);
+    const matchedCols = countMatchedColumns(curr, columns);
+    if (yGap < avgFontSize * 1.8 && curr.items.length <= 2 && (matchedCols < MIN_COLS || curr.items.length === 1)) {
+      result[result.length - 1] = {
+        y: prev.y,
+        items: [...prev.items, ...curr.items]
+      };
+    } else {
+      result.push(curr);
     }
   }
-  return edgeCut;
+  return result;
 }
-function findVerticalCut(items) {
-  if (items.length < 2) return { position: 0, gap: 0 };
-  const sorted = [...items].sort((a, b) => a.x - b.x || a.x + a.w - (b.x + b.w));
-  let largestGap = 0;
-  let position = 0;
-  let prevRight = null;
-  for (const it of sorted) {
-    const left = it.x;
-    const right = it.x + it.w;
-    if (prevRight !== null && left > prevRight) {
-      const gap = left - prevRight;
-      if (gap > largestGap) {
-        largestGap = gap;
-        position = (prevRight + left) / 2;
-      }
+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;
     }
-    prevRight = prevRight === null ? right : Math.max(prevRight, right);
   }
-  return { position, gap: largestGap };
+  if (curItems.length > 0) rows.push({ y: curY, items: curItems });
+  return rows;
 }
-
-// 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 = [];
+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++) {
-    gaps.push(sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w));
+    const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
+    if (gap >= minGap) return true;
   }
-  const maxGap = safeMax(gaps);
-  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
-  return maxGap < 40 && avgLen < 5;
+  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 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 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;
-        }
+  const minCount = Math.max(2, Math.floor(rows.length * MIN_COL_FILL_RATIO));
+  return clusters.filter((c) => c.count >= minCount).sort((a, b) => a.x - b.x);
+}
+function findTableRegionsByHeader(allRows, columns, headerItems) {
+  const regions = [];
+  let currentRegion = [];
+  let missStreak = 0;
+  for (const row of allRows) {
+    const matchedCols = countMatchedColumnsRange(row, columns, headerItems);
+    if (matchedCols >= MIN_COLS) {
+      currentRegion.push(row);
+      missStreak = 0;
+    } else if (currentRegion.length > 0 && (row.items.length <= 2 || missStreak === 0)) {
+      currentRegion.push(row);
+      missStreak++;
+    } else {
+      while (currentRegion.length > 0) {
+        const last = currentRegion[currentRegion.length - 1];
+        if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
+        currentRegion.pop();
+      }
+      if (currentRegion.length >= MIN_ROWS) {
+        regions.push({ rows: [...currentRegion] });
+      }
+      currentRegion = [];
+      missStreak = 0;
+    }
+  }
+  while (currentRegion.length > 0) {
+    const last = currentRegion[currentRegion.length - 1];
+    if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
+    currentRegion.pop();
+  }
+  if (currentRegion.length >= MIN_ROWS) {
+    regions.push({ rows: currentRegion });
+  }
+  return regions;
+}
+function findTableRegions(allRows, columns) {
+  const regions = [];
+  let currentRegion = [];
+  for (const row of allRows) {
+    const matchedCols = countMatchedColumns(row, columns);
+    if (matchedCols >= MIN_COLS) {
+      currentRegion.push(row);
+    } else if (row.items.length === 1) {
+      if (currentRegion.length > 0) {
+        currentRegion.push(row);
       }
-      if (!found) {
-        xClusters.push({ center: item.x, count: 1, minX: item.x });
+    } else {
+      if (currentRegion.length >= MIN_ROWS) {
+        regions.push({ rows: [...currentRegion] });
       }
+      currentRegion = [];
     }
   }
-  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 (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;
       }
-      prev.count += peaks[i].count;
-      prev.minX = Math.min(prev.minX, peaks[i].minX);
-    } else {
-      merged.push({ ...peaks[i] });
     }
   }
-  const rawColumns = merged.filter((c) => c.count >= 3).map((c) => c.minX);
-  if (rawColumns.length < 3) return null;
-  const MIN_DETECT_COL_WIDTH = 30;
-  const columns = [rawColumns[0]];
-  for (let i = 1; i < rawColumns.length; i++) {
-    if (rawColumns[i] - columns[columns.length - 1] < MIN_DETECT_COL_WIDTH) continue;
-    columns.push(rawColumns[i]);
-  }
-  return columns.length >= 3 ? columns : null;
+  return matched.size;
 }
-function findColumn(x, columns) {
-  for (let i = columns.length - 1; i >= 0; i--) {
-    if (x >= columns[i] - 10) return i;
+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 });
   }
-  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;
+  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;
+      }
     }
   }
-  let tableStart = -1;
-  for (let i = 0; i < (bigoIdx >= 0 ? bigoIdx : yLines.length); i++) {
-    const usedCols = new Set(yLines[i].map((item) => findColumn(item.x, columns)));
-    if (usedCols.size >= 3) {
-      tableStart = i;
-      break;
-    }
+  return matched.size;
+}
+function assignRowItems(items, columns, numCols) {
+  if (items.length === 0) return [];
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  const colCenters = columns.map((c) => c.x);
+  const gaps = [];
+  for (let i = 1; i < sorted.length; i++) {
+    gaps.push({ idx: i, size: sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w) });
   }
-  const tableEnd = bigoIdx >= 0 ? bigoIdx : yLines.length;
-  for (let i = 0; i < (tableStart >= 0 ? tableStart : tableEnd); i++) {
-    result.push(mergeLineSimple(yLines[i]));
+  const gapSizes = gaps.map((g) => g.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((g) => g.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;
   }
-  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));
-      }
+  groups.push(sorted.slice(start));
+  const result = [];
+  const usedCols = /* @__PURE__ */ new Set();
+  const groupCenters = groups.map((g) => {
+    let minX = Infinity, maxX = -Infinity;
+    for (const i of g) {
+      if (i.x < minX) minX = i.x;
+      const r = i.x + i.w;
+      if (r > maxX) maxX = r;
     }
-    if (gridLines.length > 0) {
-      result.push(buildGridTable(gridLines, columns));
+    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]) });
     }
   }
-  if (bigoIdx >= 0) {
-    result.push("");
-    for (let i = bigoIdx; i < yLines.length; i++) {
-      result.push(mergeLineSimple(yLines[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;
+      }
     }
+    result.push({ col: bestCol, items: groups[gi] });
   }
-  return result.join("\n");
+  return result;
 }
-function buildGridTable(lines, columns) {
+function buildClusterTable(rows, columns, pageNum) {
   const numCols = columns.length;
-  const yRows = lines.map((items) => {
-    const row = Array(numCols).fill("");
-    for (const item of items) {
-      const col = findColumn(item.x, columns);
-      row[col] = row[col] ? row[col] + " " + item.text : item.text;
-    }
-    return row;
-  });
-  const dataColStart = Math.max(2, Math.floor(numCols / 2));
-  const merged = [];
-  for (const row of yRows) {
-    if (row.every((c) => c === "")) continue;
-    if (merged.length === 0) {
-      merged.push([...row]);
+  const numRows = rows.length;
+  if (numRows < MIN_ROWS || numCols < MIN_COLS) return null;
+  const cells = Array.from(
+    { length: numRows },
+    () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
+  );
+  const usedItems = /* @__PURE__ */ new Set();
+  for (let r = 0; r < numRows; r++) {
+    const row = rows[r];
+    if (row.items.length === 1 && numCols > 1) {
+      cells[r][0] = { text: row.items[0].text, colSpan: numCols, rowSpan: 1 };
+      usedItems.add(row.items[0]);
       continue;
     }
-    const prev = merged[merged.length - 1];
-    const filledCols = row.map((c, i) => c ? i : -1).filter((i) => i >= 0);
-    const filledCount = filledCols.length;
-    let isNewRow = false;
-    if (row[0] && row[0].length >= 3) {
-      isNewRow = true;
-    }
-    if (!isNewRow && numCols > 1 && row[1]) {
-      isNewRow = true;
-    }
-    if (!isNewRow) {
-      const hasData = row.slice(dataColStart).some((c) => c !== "");
-      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
-      if (hasData && prevHasData) {
-        isNewRow = true;
-      }
-    }
-    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
-      isNewRow = false;
+    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 (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];
+  }
+  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 (merged.length < 2) {
-    return merged.map((r) => r.filter((c) => c).join(" ")).join("\n");
-  }
-  let headerEnd = 0;
-  for (let r = 0; r < merged.length; r++) {
-    const hasDataValues = merged[r].slice(dataColStart).some((c) => c && /\d/.test(c));
-    if (hasDataValues) break;
-    headerEnd = r + 1;
-  }
-  if (headerEnd > 1) {
-    const headerRow = Array(numCols).fill("");
-    for (let r = 0; r < headerEnd; r++) {
-      for (let c = 0; c < numCols; c++) {
-        if (merged[r][c]) {
-          headerRow[c] = headerRow[c] ? headerRow[c] + " " + merged[r][c] : merged[r][c];
+  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 = "";
       }
     }
-    merged.splice(0, headerEnd, headerRow);
-  }
-  for (const row of merged) {
-    for (let c = 0; c < row.length; c++) {
-      if (row[c]) row[c] = collapseEvenSpacing(row[c]);
-    }
   }
-  const totalCells = merged.length * numCols;
-  const filledCells = merged.reduce((s, row) => s + row.filter((c) => c).length, 0);
-  if (filledCells < totalCells * 0.35 || merged.length < 2 || merged.length <= 3 && numCols >= 7) {
-    return merged.map((r) => r.filter((c) => c).join("	")).join("\n");
-  }
-  const md = [];
-  md.push("| " + merged[0].join(" | ") + " |");
-  md.push("| " + merged[0].map(() => "---").join(" | ") + " |");
-  for (let r = 1; r < merged.length; r++) {
-    md.push("| " + merged[r].join(" | ") + " |");
+  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 md.join("\n");
+  return {
+    table: irTable,
+    bbox: { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY },
+    usedItems
+  };
 }
 
-// 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;
+// src/pdf/xy-cut.ts
+var MAX_XYCUT_DEPTH = 50;
+var XYCUT_MIN_GAP = 5;
+var CROSS_LAYOUT_BETA = 2;
+var CROSS_OVERLAP_RATIO = 0.1;
+var CROSS_MIN_OVERLAPS = 2;
+var CROSS_MAX_MASK_RATIO = 0.2;
+var NARROW_ELEMENT_WIDTH_RATIO = 0.1;
+function xyCutOrder(items, gapThreshold, depth = 0) {
+  if (items.length === 0) return [];
+  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return [items];
+  if (depth === 0 && items.length >= 3) {
+    const cross = identifyCrossLayoutItems(items);
+    if (cross.size > 0 && cross.size <= items.length * CROSS_MAX_MASK_RATIO) {
+      const rest = items.filter((i) => !cross.has(i));
+      if (rest.length > 0) {
+        const groups = xyCutOrder(rest, gapThreshold, 1);
+        return mergeCrossLayoutGroups(groups, [...cross]);
+      }
+    }
   }
-  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);
+  const minGap = Math.max(XYCUT_MIN_GAP, gapThreshold);
+  const hCut = findHorizontalCut(items);
+  const vCut = findVerticalCutWithOutlierFilter(items, minGap);
+  const hValid = hCut.gap >= minGap;
+  const vValid = vCut.gap >= minGap;
+  let useHorizontal;
+  if (hValid && vValid) useHorizontal = vCut.gap <= hCut.gap * 1.5;
+  else if (hValid) useHorizontal = true;
+  else if (vValid) useHorizontal = false;
+  else return [items];
+  if (useHorizontal) {
+    const upper = items.filter((i) => i.y > hCut.position);
+    const lower = items.filter((i) => i.y <= hCut.position);
+    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
+      return [...xyCutOrder(upper, gapThreshold, depth + 1), ...xyCutOrder(lower, gapThreshold, depth + 1)];
+    }
+  } else {
+    const left = items.filter((i) => i.x + i.w / 2 < vCut.position);
+    const right = items.filter((i) => i.x + i.w / 2 >= vCut.position);
+    if (left.length > 0 && right.length > 0 && left.length < items.length) {
+      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
     }
   }
+  return [items];
 }
-function shouldDemoteTable(table) {
-  const allCells = table.cells.flatMap((row) => row.map((c) => c.text.trim())).filter(Boolean);
-  const allText = allCells.join(" ");
-  if (table.rows >= 2 && table.cols >= 2 && table.cells[0].every((c) => {
-    const t = c.text.trim();
-    return t.length > 0 && t.length <= 12 && !/[□■◆○●▶ㅇ<>]/.test(t);
-  }) && table.cells.slice(1).some((row) => row.some((c) => c.text.trim() !== ""))) return false;
-  if (table.rows <= 3 && table.cols <= 3 && allText.length <= 200) {
-    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;
+function identifyCrossLayoutItems(items) {
+  const cross = /* @__PURE__ */ new Set();
+  if (items.length < 3) return cross;
+  let maxWidth = 0;
+  for (const i of items) {
+    if (i.w > maxWidth) maxWidth = i.w;
   }
-  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 threshold = CROSS_LAYOUT_BETA * maxWidth;
+  for (const item of items) {
+    if (item.w < threshold) continue;
+    let overlaps = 0;
+    for (const other of items) {
+      if (other === item) continue;
+      const left = Math.max(item.x, other.x);
+      const right = Math.min(item.x + item.w, other.x + other.w);
+      const overlapW = right - left;
+      if (overlapW <= 0) continue;
+      const smaller = Math.min(item.w, other.w);
+      if (smaller > 0 && overlapW / smaller >= CROSS_OVERLAP_RATIO) {
+        overlaps++;
+        if (overlaps >= CROSS_MIN_OVERLAPS) break;
+      }
     }
+    if (overlaps >= CROSS_MIN_OVERLAPS) cross.add(item);
   }
-  return lines.join("\n");
+  return cross;
 }
-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;
+function mergeCrossLayoutGroups(groups, cross) {
+  if (cross.length === 0) return groups;
+  const sortedCross = [...cross].sort((a, b) => b.y + b.h - (a.y + a.h) || a.x - b.x);
+  const groupTop = (g) => {
+    let top = -Infinity;
+    for (const i of g) {
+      const t = i.y + i.h;
+      if (t > top) top = t;
+    }
+    return top;
+  };
+  const result = [];
+  let gi = 0, ci = 0;
+  while (gi < groups.length || ci < sortedCross.length) {
+    if (ci >= sortedCross.length) {
+      result.push(groups[gi++]);
       continue;
     }
-    if (/^[가-힣]{2,6}$/.test(text) && block.style?.fontSize) {
-      const prev = blocks[i - 1];
-      const next = blocks[i + 1];
-      const prevIsStructural = !prev || prev.type === "table" || prev.type === "heading" || prev.type === "separator";
-      const nextIsStructural = !next || next.type === "table" || next.type === "heading" || next.type === "paragraph" && next.text && /^[□■◆○●]/.test(next.text.trim());
-      if (prevIsStructural || nextIsStructural) {
-        block.type = "heading";
-        block.level = 3;
-      }
+    if (gi >= groups.length) {
+      result.push([sortedCross[ci++]]);
+      continue;
     }
+    const crossTop = sortedCross[ci].y + sortedCross[ci].h;
+    if (crossTop >= groupTop(groups[gi])) result.push([sortedCross[ci++]]);
+    else result.push(groups[gi++]);
   }
+  return result;
 }
-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;
+function findHorizontalCut(items) {
+  if (items.length < 2) return { position: 0, gap: 0 };
+  const sorted = [...items].sort((a, b) => b.y - a.y);
+  let largestGap = 0;
+  let position = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
+    const currTop = sorted[i].y;
+    const gap = prevBottom - currTop;
+    if (gap > largestGap) {
+      largestGap = gap;
+      position = (prevBottom + currTop) / 2;
     }
-    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 { position, gap: largestGap };
+}
+function findVerticalCutWithOutlierFilter(items, minGap) {
+  const edgeCut = findVerticalCut(items);
+  if (edgeCut.gap >= minGap) return edgeCut;
+  if (items.length >= 3) {
+    let minX = Infinity, maxX = -Infinity;
+    for (const i of items) {
+      if (i.x < minX) minX = i.x;
+      const r = i.x + i.w;
+      if (r > maxX) maxX = r;
+    }
+    const narrowThreshold = (maxX - minX) * NARROW_ELEMENT_WIDTH_RATIO;
+    const filtered = items.filter((i) => i.w >= narrowThreshold);
+    if (filtered.length >= 2 && filtered.length < items.length && filtered.length >= items.length * 0.7) {
+      const filteredCut = findVerticalCut(filtered);
+      if (filteredCut.gap > edgeCut.gap && filteredCut.gap >= minGap) {
+        return filteredCut;
+      }
     }
   }
+  return edgeCut;
 }
-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 };
-  }
-  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 };
+function findVerticalCut(items) {
+  if (items.length < 2) return { position: 0, gap: 0 };
+  const sorted = [...items].sort((a, b) => a.x - b.x || a.x + a.w - (b.x + b.w));
+  let largestGap = 0;
+  let position = 0;
+  let prevRight = null;
+  for (const it of sorted) {
+    const left = it.x;
+    const right = it.x + it.w;
+    if (prevRight !== null && left > prevRight) {
+      const gap = left - prevRight;
+      if (gap > largestGap) {
+        largestGap = gap;
+        position = (prevRight + left) / 2;
+      }
+    }
+    prevRight = prevRight === null ? right : Math.max(prevRight, right);
   }
-  m = text.match(/^([①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮])\s*/);
-  if (m) return { family: "circled", ord: m[1].charCodeAt(0) - 9312 + 1 };
-  return null;
+  return { position, gap: largestGap };
 }
-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 });
+
+// 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));
   }
-  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);
+  const maxGap = safeMax(gaps);
+  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
+  return maxGap < 40 && avgLen < 5;
+}
+function detectColumns(yLines) {
+  const allItems = yLines.flat();
+  if (allItems.length === 0) return null;
+  const pageWidth = safeMax(allItems.map((i) => i.x + i.w)) - safeMin(allItems.map((i) => i.x));
+  if (pageWidth < 100) return null;
+  let bigoLineIdx = -1;
+  for (let i = 0; i < yLines.length; i++) {
+    if (yLines[i].length <= 2 && yLines[i].some((item) => item.text === "\uBE44\uACE0")) {
+      bigoLineIdx = i;
+      break;
+    }
   }
-  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];
+  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 });
       }
     }
-    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;
-      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;
-    }
-    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);
+  const peaks = xClusters.filter((c) => c.count >= 3).sort((a, b) => a.minX - b.minX);
+  if (peaks.length < 3) return null;
+  const MERGE_TOL = 40;
+  const merged = [peaks[0]];
+  for (let i = 1; i < peaks.length; i++) {
+    const prev = merged[merged.length - 1];
+    if (peaks[i].minX - prev.minX < MERGE_TOL) {
+      if (peaks[i].count > prev.count) {
+        prev.center = peaks[i].center;
+      }
+      prev.count += peaks[i].count;
+      prev.minX = Math.min(prev.minX, peaks[i].minX);
     } else {
-      blocks[i] = listBlock;
-      lastTopLevelList = listBlock;
+      merged.push({ ...peaks[i] });
     }
   }
-  if (toRemove.size > 0) {
-    const sorted = [...toRemove].sort((a, b) => b - a);
-    for (const idx of sorted) blocks.splice(idx, 1);
+  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 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);
+function findColumn(x, columns) {
+  for (let i = columns.length - 1; i >= 0; i--) {
+    if (x >= columns[i] - 10) return i;
   }
-  return result;
+  return 0;
 }
-var KOREAN_TABLE_HEADER_RE = /^\(?(구분|항목|종류|분류|유형|대상|내용|기간|금액|비율|방법|절차|요건|조건|근거|목적|범위|기준)\)?[:\s]/;
-var KV_FALSE_POSITIVE_RE = /\d{1,2}:\d{2}|:\/\/|\d+:\d+/;
-function detectSpecialKoreanTables(blocks) {
+function extractWithColumns(yLines, columns) {
   const result = [];
-  let kvLines = [];
-  const flushKvTable = () => {
-    if (kvLines.length < 2) {
-      for (const kv of kvLines) result.push(kv.block);
-      kvLines = [];
-      return;
+  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;
     }
-    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;
+  }
+  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 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
-        });
+  }
+  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 {
-        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 });
+        if (gridLines.length > 0) {
+          result.push(buildGridTable(gridLines.splice(0), columns));
         }
+        result.push(mergeLineSimple(line));
       }
+    }
+    if (gridLines.length > 0) {
+      result.push(buildGridTable(gridLines, columns));
+    }
+  }
+  if (bigoIdx >= 0) {
+    result.push("");
+    for (let i = bigoIdx; i < yLines.length; i++) {
+      result.push(mergeLineSimple(yLines[i]));
+    }
+  }
+  return result.join("\n");
+}
+function buildGridTable(lines, columns) {
+  const numCols = columns.length;
+  const yRows = lines.map((items) => {
+    const row = Array(numCols).fill("");
+    for (const item of items) {
+      const col = findColumn(item.x, columns);
+      row[col] = row[col] ? row[col] + " " + item.text : item.text;
+    }
+    return row;
+  });
+  const dataColStart = Math.max(2, Math.floor(numCols / 2));
+  const merged = [];
+  for (const row of yRows) {
+    if (row.every((c) => c === "")) continue;
+    if (merged.length === 0) {
+      merged.push([...row]);
       continue;
     }
-    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;
+    const prev = merged[merged.length - 1];
+    const filledCols = row.map((c, i) => c ? i : -1).filter((i) => i >= 0);
+    const filledCount = filledCols.length;
+    let isNewRow = false;
+    if (row[0] && row[0].length >= 3) {
+      isNewRow = true;
+    }
+    if (!isNewRow && numCols > 1 && row[1]) {
+      isNewRow = true;
+    }
+    if (!isNewRow) {
+      const hasData = row.slice(dataColStart).some((c) => c !== "");
+      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
+      if (hasData && prevHasData) {
+        isNewRow = true;
+      }
+    }
+    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
+      isNewRow = false;
+    }
+    if (isNewRow) {
+      merged.push([...row]);
+    } else {
+      for (let c = 0; c < numCols; c++) {
+        if (row[c]) {
+          prev[c] = prev[c] ? prev[c] + " " + row[c] : row[c];
         }
       }
     }
-    flushKvTable();
-    result.push(block);
   }
-  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 (merged.length < 2) {
+    return merged.map((r) => r.filter((c) => c).join(" ")).join("\n");
   }
-  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);
+  let headerEnd = 0;
+  for (let r = 0; r < merged.length; r++) {
+    const hasDataValues = merged[r].slice(dataColStart).some((c) => c && /\d/.test(c));
+    if (hasDataValues) break;
+    headerEnd = r + 1;
+  }
+  if (headerEnd > 1) {
+    const headerRow = Array(numCols).fill("");
+    for (let r = 0; r < headerEnd; r++) {
+      for (let c = 0; c < numCols; c++) {
+        if (merged[r][c]) {
+          headerRow[c] = headerRow[c] ? headerRow[c] + " " + merged[r][c] : merged[r][c];
+        }
       }
     }
-    for (const e of entries) {
-      const norm = e.text.replace(/\d+/g, "#");
-      if (repeatedPatterns.has(norm)) {
-        removeSet.add(e.blockIdx);
-      }
+    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]);
     }
   }
-  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" });
+  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 [...removeSet].sort((a, b) => a - b);
+  const escCell = (c) => c.replace(/\t/g, " ").replace(/\|/g, "\\|");
+  const md = [];
+  md.push("| " + merged[0].map(escCell).join(" | ") + " |");
+  md.push("| " + merged[0].map(() => "---").join(" | ") + " |");
+  for (let r = 1; r < merged.length; r++) {
+    md.push("| " + merged[r].map(escCell).join(" | ") + " |");
+  }
+  return md.join("\n");
 }
 
 // src/pdf/page-blocks.ts
@@ -3199,6 +3006,8 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       hasSpaceBefore: i.hasSpaceBefore
     }));
     const cellTextMap = mapTextToCells(textItems, cells);
+    const assignedItems = /* @__PURE__ */ new Set();
+    for (const arr of cellTextMap.values()) for (const it of arr) assignedItems.add(it);
     const numRows = grid.rowYs.length - 1;
     const numCols = grid.colXs.length - 1;
     const irGrid = Array.from(
@@ -3218,9 +3027,11 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
     }
     let finalGrid = irGrid;
     let finalRows = numRows;
+    let rebuiltUsed = false;
     if (numRows <= 2 && numCols >= 3) {
       const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
       if (rebuilt) {
+        rebuiltUsed = true;
         finalGrid = rebuilt.map((row) => row.map((rawText) => {
           const cleaned = rawText.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
           return {
@@ -3232,6 +3043,11 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
         finalRows = finalGrid.length;
       }
     }
+    if (!rebuiltUsed) {
+      for (let ti = 0; ti < textItems.length; ti++) {
+        if (!assignedItems.has(textItems[ti])) usedItems.delete(tableItems[ti]);
+      }
+    }
     const irTable = {
       rows: finalRows,
       cols: numCols,
@@ -3288,6 +3104,8 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       }
       remaining = remaining.filter((_, idx) => !usedClusterIndices.has(idx));
     }
+    const groupSizes = [];
+    let finalTextBlocks = [];
     if (remaining.length > 0) {
       const allY = remaining.map((i) => i.y);
       const pageH = safeMax(allY) - safeMin(allY);
@@ -3297,16 +3115,28 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
         if (group.length === 0) continue;
         const groupBlocks = extractPageBlocksFallback(group, pageNum);
         for (const b of groupBlocks) textBlocks.push(b);
+        groupSizes.push(groupBlocks.length);
       }
-      const finalTextBlocks = detectListBlocks(textBlocks);
-      for (const b of finalTextBlocks) blocks.push(b);
+      finalTextBlocks = detectListBlocks(textBlocks);
     }
-    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);
+    const units = blocks.map((b) => [b]);
+    let off = 0;
+    for (const size of groupSizes) {
+      const unit = finalTextBlocks.slice(off, off + size);
+      off += size;
+      if (unit.length > 0) units.push(unit);
+    }
+    const unitTopY = (u) => {
+      let top = 0;
+      for (const b of u) {
+        if (b.bbox && b.bbox.y + b.bbox.height > top) top = b.bbox.y + b.bbox.height;
+      }
+      return top;
+    };
+    units.sort((a, b) => unitTopY(b) - unitTopY(a));
+    const ordered = [];
+    for (const u of units) for (const b of u) ordered.push(b);
+    return mergeAdjacentTableBlocks(ordered);
   }
   return mergeAdjacentTableBlocks(blocks);
 }
@@ -3380,7 +3210,7 @@ function splitTwoColumnProse(items, cutX) {
     else cross.push(i);
   }
   if (cross.length === 0) {
-    return [left, right].filter((g2) => g2.length > 0);
+    return [left, right].filter((g) => g.length > 0);
   }
   cross.sort((a, b) => b.y - a.y);
   const crossLines = [];
@@ -3491,448 +3321,18 @@ function extractPageBlocksFallback(items, pageNum, fullPage = false) {
   return detectSpecialKoreanTables(blocks);
 }
 
-// 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);
-  }
-}
-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 "";
-  const lines = text.split("\n");
-  if (lines.length <= 1) return text;
-  const result = [lines[0]];
-  for (let i = 1; i < lines.length; i++) {
-    const prev = result[result.length - 1];
-    const curr = lines[i];
-    const currTrimmed = curr.trim();
-    if (/^#{1,6}\s/.test(prev) || /^#{1,6}\s/.test(curr) || /^\|/.test(currTrimmed) || /^---/.test(currTrimmed)) {
-      result.push(curr);
-      continue;
-    }
-    if (/,$/.test(prev.trim()) && currTrimmed.length > 0) {
-      result[result.length - 1] = prev + "\n" + curr;
-      continue;
-    }
-    if (/^\(※/.test(currTrimmed)) {
-      result[result.length - 1] = prev + " " + currTrimmed;
-      continue;
-    }
-    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev) && !startsWithMarker(prev)) {
-      result[result.length - 1] = prev + " " + curr;
-    } else {
-      result.push(curr);
-    }
-  }
-  return result.join("\n");
-}
-
-// src/pdf/formula-ocr.ts
-async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
-  const formulaMod = await import("./formula-RXVSQPXI.js");
-  const { FormulaPipeline, ensureFormulaModels } = formulaMod;
-  await ensureFormulaModels((p) => {
-    if (p.phase === "download" && p.total) {
-      const pct = Math.floor(p.downloaded / p.total * 100);
-      process.stderr.write(`\r[kordoc-formula] ${p.spec.name} ${pct}% (${formatMb(p.downloaded)}/${formatMb(p.total)})`);
-      if (p.downloaded >= p.total) process.stderr.write("\n");
-    } else if (p.phase === "verify") {
-      process.stderr.write(`[kordoc-formula] ${p.spec.name} SHA-256 \uAC80\uC99D \uC911...
-`);
-    } else if (p.phase === "done") {
-      process.stderr.write(`[kordoc-formula] ${p.spec.name} \uC900\uBE44 \uC644\uB8CC
-`);
-    } else if (p.phase === "skip") {
-    }
-  });
-  const pipeline = await FormulaPipeline.create();
-  try {
-    const pagesResult = await pipeline.runOnBuffer(buffer, pageFilter);
-    if (pagesResult.length === 0) return;
-    let insertedCount = 0;
-    let removedDupCount = 0;
-    for (const page of pagesResult) {
-      const pageNumber = page.pageNumber;
-      const pdfHeight = page.pdfHeight;
-      const scaleX = page.renderedWidth > 0 ? page.pdfWidth / page.renderedWidth : 0.5;
-      const scaleY = page.renderedHeight > 0 ? page.pdfHeight / page.renderedHeight : 0.5;
-      const candidates = [];
-      for (const r of page.regions) {
-        if (!r.latex || !r.latex.trim()) continue;
-        const wrapped = r.kind === "display" ? `$$${r.latex}$$` : `$${r.latex}$`;
-        const x1 = r.bbox.x1 * scaleX;
-        const x2 = r.bbox.x2 * scaleX;
-        const yTop = pdfHeight - r.bbox.y1 * scaleY;
-        const yBottom = pdfHeight - r.bbox.y2 * scaleY;
-        const centerY = (yTop + yBottom) / 2;
-        const width = x2 - x1;
-        const height = yTop - yBottom;
-        candidates.push({
-          block: {
-            type: "paragraph",
-            text: wrapped,
-            pageNumber,
-            bbox: { page: pageNumber, x: x1, y: yBottom, width, height }
-          },
-          pdfBbox: { x1, x2, yTop, yBottom },
-          centerY
-        });
-      }
-      if (candidates.length === 0) continue;
-      const OVERLAP_THRESHOLD = 0.6;
-      const indicesToRemove = /* @__PURE__ */ new Set();
-      for (let i = 0; i < blocks.length; i++) {
-        const b = blocks[i];
-        if (b.pageNumber !== pageNumber) continue;
-        if (b.type === "table") continue;
-        if (!b.bbox || b.bbox.width <= 0 || b.bbox.height <= 0) continue;
-        const blockArea = b.bbox.width * b.bbox.height;
-        if (blockArea <= 0) continue;
-        for (const c of candidates) {
-          const ox1 = Math.max(b.bbox.x, c.pdfBbox.x1);
-          const ox2 = Math.min(b.bbox.x + b.bbox.width, c.pdfBbox.x2);
-          const oy1 = Math.max(b.bbox.y, c.pdfBbox.yBottom);
-          const oy2 = Math.min(b.bbox.y + b.bbox.height, c.pdfBbox.yTop);
-          const interArea = Math.max(0, ox2 - ox1) * Math.max(0, oy2 - oy1);
-          if (interArea / blockArea >= OVERLAP_THRESHOLD) {
-            indicesToRemove.add(i);
-            break;
-          }
-        }
-      }
-      if (indicesToRemove.size > 0) {
-        const sorted = [...indicesToRemove].sort((a, b) => b - a);
-        for (const idx of sorted) blocks.splice(idx, 1);
-        removedDupCount += indicesToRemove.size;
-      }
-      candidates.sort((a, b) => b.centerY - a.centerY);
-      for (const c of candidates) {
-        let insertIdx = -1;
-        let pageFirstIdx = -1;
-        let pageLastIdx = -1;
-        for (let i = 0; i < blocks.length; i++) {
-          const b = blocks[i];
-          if (b.pageNumber !== pageNumber) continue;
-          if (pageFirstIdx === -1) pageFirstIdx = i;
-          pageLastIdx = i;
-          if (!b.bbox) continue;
-          const blockCenter = b.bbox.y + b.bbox.height / 2;
-          if (blockCenter < c.centerY) {
-            insertIdx = i;
-            break;
-          }
-        }
-        if (insertIdx !== -1) {
-          blocks.splice(insertIdx, 0, c.block);
-        } else if (pageLastIdx !== -1) {
-          blocks.splice(pageLastIdx + 1, 0, c.block);
-        } else {
-          blocks.push(c.block);
-        }
-        insertedCount++;
-      }
-    }
-    if (insertedCount > 0 || removedDupCount > 0) {
-      process.stderr.write(
-        `[kordoc-formula] ${insertedCount}\uAC1C \uC218\uC2DD \uC0BD\uC785, ${removedDupCount}\uAC1C \uC911\uBCF5 block \uC81C\uAC70 (${pagesResult.length}\uAC1C \uD398\uC774\uC9C0)
-`
-      );
-    }
-  } finally {
-    await pipeline.destroy().catch(() => {
-    });
-  }
-}
-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();
-    const imageState = createPdfImageState();
-    const extractedImages = [];
-    const pageImageBlocks = /* @__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);
-        try {
-          const { blocks: imgBlocks, images: pageImages } = await extractPageImages(page, opList.fnArray, opList.argsArray, i, imageState, warnings);
-          if (imgBlocks.length > 0) pageImageBlocks.set(i, imgBlocks);
-          extractedImages.push(...pageImages);
-        } catch {
-        }
-        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), images: extractedImages.length > 0 ? extractedImages : void 0 };
-          }
-        } 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",
-        garbled_hangul: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (\uD55C\uAE00 \uC790\uC18C \uBD84\uD3EC \uC774\uC0C1) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8\uAC00 \uAE68\uC84C\uC744 \uC218 \uC788\uC74C"
-      };
-      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);
-    injectPageImageBlocks(blocks, pageImageBlocks);
-    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),
-      images: extractedImages.length > 0 ? extractedImages : void 0
-    };
-  } finally {
-    await doc.destroy().catch(() => {
-    });
-  }
-}
-async function extractPdfMetadata(doc, metadata) {
-  try {
-    const result = await doc.getMetadata();
-    if (!result?.info) return;
-    const info = result.info;
-    if (typeof info.Title === "string" && info.Title.trim()) metadata.title = info.Title.trim();
-    if (typeof info.Author === "string" && info.Author.trim()) metadata.author = info.Author.trim();
-    if (typeof info.Creator === "string" && info.Creator.trim()) metadata.creator = info.Creator.trim();
-    if (typeof info.Subject === "string" && info.Subject.trim()) metadata.description = info.Subject.trim();
-    if (typeof info.Keywords === "string" && info.Keywords.trim()) {
-      metadata.keywords = info.Keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean);
-    }
-    if (typeof info.CreationDate === "string") metadata.createdAt = parsePdfDate(info.CreationDate);
-    if (typeof info.ModDate === "string") metadata.modifiedAt = parsePdfDate(info.ModDate);
-  } catch {
-  }
-}
-function parsePdfDate(dateStr) {
-  const m = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
-  if (!m) return void 0;
-  const [, year, month = "01", day = "01", hour = "00", min = "00", sec = "00"] = m;
-  return `${year}-${month}-${day}T${hour}:${min}:${sec}`;
-}
-async function extractPdfMetadataOnly(buffer) {
-  const doc = await loadPdfWithTimeout(buffer);
-  try {
-    const metadata = { pageCount: doc.numPages };
-    await extractPdfMetadata(doc, metadata);
-    return metadata;
-  } finally {
-    await doc.destroy().catch(() => {
-    });
-  }
-}
 export {
-  cleanPdfText,
-  detectKoreanListBlocks,
+  extractImageRegions,
+  filterHiddenText,
+  collapseEvenSpacing,
+  normalizeItems,
+  computeMedianFontSizeFromFreq,
+  detectHeadings,
+  detectMarkerHeadings,
   detectTableCaptions,
-  extractPdfMetadataOnly,
-  mergeCrossPageTables,
-  parsePdfDocument,
-  removeHeaderFooterBlocks
+  detectKoreanListBlocks,
+  removeHeaderFooterBlocks,
+  extractPageBlocksWithLines,
+  mergeCrossPageTables
 };
-//# sourceMappingURL=parser-KMMUS73Q.js.map
+//# sourceMappingURL=chunk-4JPPLIIV.js.map