kordoc 2.9.1 → 3.0.1

package/dist/{parser-BKYM3LKN.js → parser-LZH7ZELV.js}

@@ -6,7 +6,7 @@ import {
   blocksToMarkdown,
   safeMax,
   safeMin
-} from "./chunk-Z6TLTWYK.js";
+} from "./chunk-X3SCCO5Q.js";
 import {
   parsePageRange
 } from "./chunk-SBVRCJFH.js";
@@ -156,6 +156,55 @@ function extractLines(fnArray, argsArray) {
   }
   return { horizontals, verticals };
 }
+function multiplyTransform(m, t) {
+  return [
+    m[0] * t[0] + m[2] * t[1],
+    m[1] * t[0] + m[3] * t[1],
+    m[0] * t[2] + m[2] * t[3],
+    m[1] * t[2] + m[3] * t[3],
+    m[0] * t[4] + m[2] * t[5] + m[4],
+    m[1] * t[4] + m[3] * t[5] + m[5]
+  ];
+}
+function extractImageRegions(fnArray, argsArray) {
+  const regions = [];
+  let ctm = [1, 0, 0, 1, 0, 0];
+  const stack = [];
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    switch (op) {
+      case OPS.save:
+        stack.push(ctm);
+        break;
+      case OPS.restore:
+        ctm = stack.pop() || [1, 0, 0, 1, 0, 0];
+        break;
+      case OPS.transform: {
+        const t = argsArray[i];
+        if (Array.isArray(t) && t.length >= 6) ctm = multiplyTransform(ctm, t);
+        break;
+      }
+      case OPS.paintImageXObject:
+      case OPS.paintInlineImageXObject:
+      case OPS.paintImageMaskXObject:
+      case OPS.paintImageXObjectRepeat: {
+        const corners = [[0, 0], [1, 0], [0, 1], [1, 1]];
+        let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+        for (const [u, v] of corners) {
+          const x = ctm[0] * u + ctm[2] * v + ctm[4];
+          const y = ctm[1] * u + ctm[3] * v + ctm[5];
+          if (x < x1) x1 = x;
+          if (x > x2) x2 = x;
+          if (y < y1) y1 = y;
+          if (y > y2) y2 = y;
+        }
+        if (x2 - x1 > 0 && y2 - y1 > 0) regions.push({ x1, y1, x2, y2 });
+        break;
+      }
+    }
+  }
+  return regions;
+}
 function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
   const dx = Math.abs(seg.x2 - seg.x1);
   const dy = Math.abs(seg.y2 - seg.y1);
@@ -541,6 +590,10 @@ function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
   }
   return false;
 }
+var SPACE_GAP_RATIO = 0.17;
+function spaceGapThreshold(fontSize) {
+  return Math.max(fontSize * SPACE_GAP_RATIO, 1);
+}
 function mapTextToCells(items, cells) {
   const result = /* @__PURE__ */ new Map();
   for (const cell of cells) {
@@ -600,14 +653,12 @@ function cellTextToString(items) {
       }
       const gap = s[j].x - (s[j - 1].x + s[j - 1].w);
       const avgFs = (s[j].fontSize + s[j - 1].fontSize) / 2;
-      const prevIsKorean = /[가-힣]$/.test(result);
-      const currIsKorean = /^[가-힣]/.test(s[j].text);
-      if (gap < avgFs * 0.15) {
-        result += s[j].text;
-      } else if (gap < avgFs * 0.35 && (prevIsKorean || currIsKorean)) {
-        result += s[j].text;
-      } else {
+      if (s[j].hasSpaceBefore && gap >= avgFs * 0.05) {
         result += " " + s[j].text;
+      } else if (gap > spaceGapThreshold(avgFs)) {
+        result += " " + s[j].text;
+      } else {
+        result += s[j].text;
       }
     }
     return result;
@@ -620,6 +671,11 @@ function detectEvenSpacedItems(items) {
   let runStart = -1;
   for (let i = 0; i < items.length; i++) {
     const isShortKorean = /^[가-힣]{1}$/.test(items[i].text) || /^[\d]{1}$/.test(items[i].text);
+    if (isShortKorean && runStart >= 0 && items[i].hasSpaceBefore) {
+      if (i - runStart >= 3) markEvenRun(items, result, runStart, i);
+      runStart = i;
+      continue;
+    }
     if (isShortKorean && runStart >= 0 && i > 0) {
       const gap = items[i].x - (items[i - 1].x + items[i - 1].w);
       const maxRunGap = Math.max(items[i].fontSize * 3, 30);
@@ -662,6 +718,119 @@ function markEvenRun(items, result, start, end) {
     }
   }
 }
+var MAX_UNDERSEGMENTED_ROWS = 2;
+var MIN_UNDERSEGMENTED_COLUMNS = 3;
+var MIN_UNDERSEGMENTED_TEXT_LINES = 8;
+var MIN_ROW_BAND_MISMATCH = 2;
+var MIN_ROW_BAND_EPSILON = 3;
+var ROW_BAND_EPSILON_RATIO = 0.6;
+function itemCenterY(item) {
+  return item.y + (item.h > 0 ? item.h : item.fontSize) / 2;
+}
+function itemHeight(item) {
+  return item.h > 0 ? item.h : item.fontSize;
+}
+function findColumnIndex(item, colXs) {
+  const cx = item.x + item.w / 2;
+  for (let c = 0; c < colXs.length - 1; c++) {
+    if (cx >= colXs[c] && cx <= colXs[c + 1]) return c;
+  }
+  let best = 0;
+  let bestDist = Infinity;
+  for (let c = 0; c < colXs.length - 1; c++) {
+    const center = (colXs[c] + colXs[c + 1]) / 2;
+    const d = Math.abs(cx - center);
+    if (d < bestDist) {
+      bestDist = d;
+      best = c;
+    }
+  }
+  return best;
+}
+function groupItemsToVisualLines(items) {
+  if (items.length === 0) return [];
+  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
+  const lines = [];
+  let cur = [sorted[0]];
+  let curY = sorted[0].y;
+  for (let i = 1; i < sorted.length; i++) {
+    const tol = Math.max(3, Math.min(sorted[i].fontSize, cur[0].fontSize) * 0.6);
+    if (Math.abs(sorted[i].y - curY) <= tol) {
+      cur.push(sorted[i]);
+    } else {
+      lines.push(cur);
+      cur = [sorted[i]];
+      curY = sorted[i].y;
+    }
+  }
+  lines.push(cur);
+  return lines;
+}
+function normalizeUndersegmentedTable(originalCells, colXs, items) {
+  const numRows = originalCells.length;
+  const numCols = colXs.length - 1;
+  if (numRows > MAX_UNDERSEGMENTED_ROWS || numCols < MIN_UNDERSEGMENTED_COLUMNS) return null;
+  if (items.length === 0) return null;
+  const itemsByCol = Array.from({ length: numCols }, () => []);
+  for (const item of items) {
+    if (!item.text.trim()) continue;
+    itemsByCol[findColumnIndex(item, colXs)].push(item);
+  }
+  let denseColumns = 0;
+  for (const colItems of itemsByCol) {
+    if (groupItemsToVisualLines(colItems).length >= MIN_UNDERSEGMENTED_TEXT_LINES) denseColumns++;
+  }
+  if (denseColumns < 2) return null;
+  const allLines = groupItemsToVisualLines(items.filter((i) => i.text.trim()));
+  const bands = [];
+  for (const line of allLines) {
+    let cy = 0, h = 0;
+    for (const it of line) {
+      cy += itemCenterY(it);
+      h += itemHeight(it);
+    }
+    cy /= line.length;
+    h /= line.length;
+    const top = cy + h / 2;
+    const bottom = cy - h / 2;
+    let matched = null;
+    for (const band of bands) {
+      const epsilon = Math.max(MIN_ROW_BAND_EPSILON, Math.min(band.avgHeight, h) * ROW_BAND_EPSILON_RATIO);
+      if (Math.abs(band.centerY - cy) <= epsilon || bottom <= band.topY && top >= band.bottomY) {
+        matched = band;
+        break;
+      }
+    }
+    if (!matched) {
+      matched = { centerY: 0, avgHeight: 0, topY: -Infinity, bottomY: Infinity, lineCount: 0, itemsByCol: Array.from({ length: numCols }, () => []) };
+      bands.push(matched);
+    }
+    matched.centerY = (matched.centerY * matched.lineCount + cy) / (matched.lineCount + 1);
+    matched.avgHeight = (matched.avgHeight * matched.lineCount + h) / (matched.lineCount + 1);
+    matched.topY = Math.max(matched.topY, top);
+    matched.bottomY = Math.min(matched.bottomY, bottom);
+    matched.lineCount++;
+    for (const it of line) {
+      matched.itemsByCol[findColumnIndex(it, colXs)].push(it);
+    }
+  }
+  if (bands.length < numRows + MIN_ROW_BAND_MISMATCH) return null;
+  bands.sort((a, b) => b.centerY - a.centerY);
+  const rebuilt = bands.map(
+    (band) => band.itemsByCol.map((colItems) => colItems.length > 0 ? cellTextToString(colItems) : "")
+  );
+  const countNonEmptyRows = (cells) => cells.filter((row) => row.some((c) => (typeof c === "string" ? c : c.text).trim() !== "")).length;
+  const countNonEmptyCols = (cells, cols) => {
+    let n = 0;
+    for (let c = 0; c < cols; c++) {
+      if (cells.some((row) => row[c] != null && (typeof row[c] === "string" ? row[c] : row[c].text).trim() !== "")) n++;
+    }
+    return n;
+  };
+  if (countNonEmptyRows(rebuilt) <= countNonEmptyRows(originalCells)) return null;
+  if (countNonEmptyCols(rebuilt, numCols) < countNonEmptyCols(originalCells, numCols)) return null;
+  return rebuilt;
+}
 function mergeCellTextLines(textLines) {
   if (textLines.length <= 1) return textLines[0] || "";
   const merged = [textLines[0]];
@@ -694,7 +863,7 @@ var MIN_COL_FILL_RATIO = 0.4;
 function detectClusterTables(items, pageNum) {
   if (items.length < MIN_ROWS * MIN_COLS) return [];
   const { merged, originMap } = mergeEvenSpacedClusters(items);
-  const rows = groupByBaseline(merged);
+  const rows = mergeOverlappingRows(groupByBaseline(merged));
   if (rows.length < MIN_ROWS) return [];
   const results = [];
   const headerResult = detectHeaderRow(rows);
@@ -743,6 +912,7 @@ function mergeEvenSpacedClusters(items) {
       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;
@@ -833,6 +1003,38 @@ function detectHeaderRow(rows) {
   }
   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]];
@@ -1319,6 +1521,8 @@ async function parsePdfDocument(buffer, options) {
     const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
     const fontSizeFreq = /* @__PURE__ */ new Map();
     const pageHeights = /* @__PURE__ */ new Map();
+    const pagesWithLargeImage = /* @__PURE__ */ new Set();
+    const skippedImagePages = /* @__PURE__ */ new Map();
     let parsedPages = 0;
     for (let i = 1; i <= effectivePageCount; i++) {
       if (pageFilter && !pageFilter.has(i)) continue;
@@ -1337,6 +1541,23 @@ async function parsePdfDocument(buffer, options) {
           if (item.fontSize > 0) fontSizeFreq.set(item.fontSize, (fontSizeFreq.get(item.fontSize) || 0) + 1);
         }
         const opList = await page.getOperatorList();
+        const pageArea = viewport.width * viewport.height;
+        if (pageArea > 0) {
+          const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray);
+          let uncovered = 0;
+          for (const r of imageRegions) {
+            const area = (r.x2 - r.x1) * (r.y2 - r.y1);
+            if (area < pageArea * 0.05) continue;
+            pagesWithLargeImage.add(i);
+            const hasText = visible.some((it) => {
+              const cx = it.x + it.w / 2;
+              const cy = it.y + (it.h || it.fontSize) / 2;
+              return cx >= r.x1 && cx <= r.x2 && cy >= r.y1 && cy <= r.y2;
+            });
+            if (!hasText) uncovered++;
+          }
+          if (uncovered > 0) skippedImagePages.set(i, uncovered);
+        }
         const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
         for (const b of pageBlocks) blocks.push(b);
         let pageText = "";
@@ -1356,6 +1577,7 @@ async function parsePdfDocument(buffer, options) {
       }
     }
     const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
+    let isImageBased = false;
     if (totalChars / Math.max(parsedPageCount, 1) < 10) {
       if (options?.ocr) {
         try {
@@ -1368,7 +1590,29 @@ async function parsePdfDocument(buffer, options) {
         } catch {
         }
       }
-      throw Object.assign(new KordocError(`\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`), { isImageBased: true });
+      isImageBased = true;
+      warnings.push({
+        message: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, \uD14D\uC2A4\uD2B8 ${totalChars}\uC790) \u2014 \uD14D\uC2A4\uD2B8 \uB808\uC774\uC5B4\uAC00 \uC5C6\uC5B4 OCR\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+        code: "NEEDS_OCR"
+      });
+    }
+    if (!isImageBased) {
+      const OCR_REASON_MESSAGES = {
+        low_text: "\uD14D\uC2A4\uD2B8\uAC00 \uAC70\uC758 \uC5C6\uB294 \uD398\uC774\uC9C0 (\uC2A4\uCE94/\uC774\uBBF8\uC9C0 \uCD94\uC815)",
+        high_pua: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (PUA \uBE44\uC728 \uB192\uC74C) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_control: "\uC81C\uC5B4\uBB38\uC790 \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_replacement: "\uB300\uCCB4\uBB38\uC790(U+FFFD) \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00"
+      };
+      for (const pq of pageQuality) {
+        if (!pq.needsOcr || !pq.ocrReason) continue;
+        if (pq.ocrReason === "low_text" && !pagesWithLargeImage.has(pq.page)) continue;
+        warnings.push({ page: pq.page, message: `${OCR_REASON_MESSAGES[pq.ocrReason]} \u2014 OCR \uAC80\uD1A0 \uD544\uC694`, code: "NEEDS_OCR" });
+      }
+    }
+    if (!isImageBased) {
+      for (const [page, count] of [...skippedImagePages.entries()].sort((a, b) => a[0] - b[0])) {
+        warnings.push({ page, message: `${count}\uAC1C \uC774\uBBF8\uC9C0 \uC601\uC5ED\uC5D0 \uCD94\uCD9C \uAC00\uB2A5\uD55C \uD14D\uC2A4\uD2B8 \uC5C6\uC74C (\uADF8\uB9BC/\uCC28\uD2B8/\uB3C4\uC7A5 \uB0B4\uC6A9 \uB204\uB77D \uAC00\uB2A5)`, code: "SKIPPED_IMAGE" });
+      }
     }
     if (options?.removeHeaderFooter !== false && parsedPageCount >= 3) {
       const removed = removeHeaderFooterBlocks(blocks, pageHeights, warnings);
@@ -1376,6 +1620,7 @@ async function parsePdfDocument(buffer, options) {
         blocks.splice(removed[ri], 1);
       }
     }
+    mergeCrossPageTables(blocks);
     if (options?.formulaOcr && formulaBuffer) {
       try {
         await applyFormulaOcr(formulaBuffer, blocks, pageFilter, effectivePageCount, warnings, options.onProgress);
@@ -1391,6 +1636,8 @@ async function parsePdfDocument(buffer, options) {
       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));
@@ -1400,6 +1647,7 @@ async function parsePdfDocument(buffer, options) {
       metadata,
       outline: outline.length > 0 ? outline : void 0,
       warnings: warnings.length > 0 ? warnings : void 0,
+      isImageBased: isImageBased || void 0,
       pageQuality,
       qualitySummary: summarizeDocumentQuality(pageQuality)
     };
@@ -1555,79 +1803,218 @@ function detectMarkerHeadings(blocks) {
   }
 }
 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];
-  const region = computeRegion(items);
-  const ySplit = findYSplit(items, region, gapThreshold);
-  if (ySplit !== null) {
-    const upper = items.filter((i) => i.y > ySplit);
-    const lower = items.filter((i) => i.y <= ySplit);
+  if (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]);
+      }
+    }
+  }
+  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)];
     }
-  }
-  const xSplit = findXSplit(items, region, gapThreshold);
-  if (xSplit !== null) {
-    const left = items.filter((i) => i.x + i.w / 2 < xSplit);
-    const right = items.filter((i) => i.x + i.w / 2 >= xSplit);
+  } 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 computeRegion(items) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+function identifyCrossLayoutItems(items) {
+  const cross = /* @__PURE__ */ new Set();
+  if (items.length < 3) return cross;
+  let maxWidth = 0;
   for (const i of items) {
-    if (i.x < minX) minX = i.x;
-    if (i.y < minY) minY = i.y;
-    if (i.x + i.w > maxX) maxX = i.x + i.w;
-    if (i.y + i.h > maxY) maxY = i.y + i.h;
+    if (i.w > maxWidth) maxWidth = i.w;
   }
-  return { items, minX, minY, maxX, maxY };
+  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 cross;
 }
-function findYSplit(items, _region, gapThreshold) {
+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;
+    }
+    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 bestGap = gapThreshold;
-  let bestSplit = null;
+  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 > bestGap) {
-      bestGap = gap;
-      bestSplit = (prevBottom + currTop) / 2;
+    if (gap > largestGap) {
+      largestGap = gap;
+      position = (prevBottom + currTop) / 2;
     }
   }
-  return bestSplit;
+  return { position, gap: largestGap };
 }
-function findXSplit(items, _region, gapThreshold) {
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  let bestGap = gapThreshold;
-  let bestSplit = null;
-  for (let i = 1; i < sorted.length; i++) {
-    const prevRight = sorted[i - 1].x + sorted[i - 1].w;
-    const currLeft = sorted[i].x;
-    const gap = currLeft - prevRight;
-    if (gap > bestGap) {
-      bestGap = gap;
-      bestSplit = (prevRight + currLeft) / 2;
+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;
+}
+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);
   }
-  return bestSplit;
+  return { position, gap: largestGap };
 }
 function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight) {
   if (items.length === 0) return [];
   let { horizontals, verticals } = extractLines(opList.fnArray, opList.argsArray);
   ({ horizontals, verticals } = filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight));
   ({ horizontals, verticals } = preprocessLines(horizontals, verticals));
+  markStrikethroughItems(items, horizontals);
+  wrapStrikethroughRuns(items);
   const grids = buildTableGrids(horizontals, verticals);
   if (grids.length > 0) {
     return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
   }
   return extractPageBlocksFallback(items, pageNum);
 }
+var STRIKE_MAX_THICKNESS = 2;
+var STRIKE_MAX_THICKNESS_RATIO = 0.25;
+var STRIKE_CENTER_TOLERANCE = 0.25;
+var STRIKE_MIN_OVERLAP_RATIO = 0.8;
+var STRIKE_MAX_LINE_TO_TEXT_RATIO = 1.5;
+function markStrikethroughItems(items, horizontals) {
+  if (items.length === 0 || horizontals.length === 0) return;
+  for (const line of horizontals) {
+    if (line.lineWidth > STRIKE_MAX_THICKNESS) continue;
+    const matches = [];
+    for (const item of items) {
+      const h = item.h > 0 ? item.h : item.fontSize;
+      if (h <= 0 || item.w <= 0) continue;
+      if (line.lineWidth > h * STRIKE_MAX_THICKNESS_RATIO) continue;
+      const centerY = item.y + h * 0.4;
+      if (Math.abs(line.y1 - centerY) > h * STRIKE_CENTER_TOLERANCE) continue;
+      const overlap = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
+      if (overlap / item.w < STRIKE_MIN_OVERLAP_RATIO) continue;
+      matches.push(item);
+    }
+    if (matches.length === 0) continue;
+    let totalW = 0;
+    for (const m of matches) totalW += m.w;
+    if (totalW <= 0 || (line.x2 - line.x1) / totalW > STRIKE_MAX_LINE_TO_TEXT_RATIO) continue;
+    for (const m of matches) m.strike = true;
+  }
+}
+function wrapStrikethroughRuns(items) {
+  const struck = items.filter((i) => i.strike);
+  if (struck.length === 0) return;
+  const lines = /* @__PURE__ */ new Map();
+  for (const item of struck) {
+    const key = Math.round(item.y / 3);
+    const arr = lines.get(key) || [];
+    arr.push(item);
+    lines.set(key, arr);
+  }
+  for (const arr of lines.values()) {
+    arr.sort((a, b) => a.x - b.x);
+    arr[0].text = "~~" + arr[0].text;
+    arr[arr.length - 1].text = arr[arr.length - 1].text + "~~";
+  }
+}
 function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
@@ -1657,7 +2044,8 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       w: i.w,
       h: i.h,
       fontSize: i.fontSize,
-      fontName: i.fontName
+      fontName: i.fontName,
+      hasSpaceBefore: i.hasSpaceBefore
     }));
     const cellTextMap = mapTextToCells(textItems, cells);
     const numRows = grid.rowYs.length - 1;
@@ -1677,13 +2065,29 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
         rowSpan: cell.rowSpan
       };
     }
+    let finalGrid = irGrid;
+    let finalRows = numRows;
+    if (numRows <= 2 && numCols >= 3) {
+      const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
+      if (rebuilt) {
+        finalGrid = rebuilt.map((row) => row.map((rawText) => {
+          const cleaned = rawText.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
+          return {
+            text: cleaned.split("\n").map((line) => collapseEvenSpacing(line)).join("\n"),
+            colSpan: 1,
+            rowSpan: 1
+          };
+        }));
+        finalRows = finalGrid.length;
+      }
+    }
     const irTable = {
-      rows: numRows,
+      rows: finalRows,
       cols: numCols,
-      cells: irGrid,
-      hasHeader: numRows > 1
+      cells: finalGrid,
+      hasHeader: finalRows > 1
     };
-    const hasContent = irGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
+    const hasContent = finalGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
     if (!hasContent) continue;
     const tableBbox = {
       page: pageNum,
@@ -1712,7 +2116,8 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       w: i.w,
       h: i.h,
       fontSize: i.fontSize,
-      fontName: i.fontName
+      fontName: i.fontName,
+      hasSpaceBefore: i.hasSpaceBefore
     }));
     const clusterResults = detectClusterTables(clusterItems, pageNum);
     if (clusterResults.length > 0) {
@@ -1750,6 +2155,46 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
   }
   return mergeAdjacentTableBlocks(blocks);
 }
+var NEIGHBOR_TABLE_EPSILON = 0.2;
+function mergeCrossPageTables(blocks) {
+  for (let i = blocks.length - 2; i >= 0; i--) {
+    const prev = blocks[i];
+    const curr = blocks[i + 1];
+    if (prev.type !== "table" || curr.type !== "table" || !prev.table || !curr.table) continue;
+    if (!prev.pageNumber || !curr.pageNumber || curr.pageNumber !== prev.pageNumber + 1) continue;
+    if (prev.table.cols !== curr.table.cols) continue;
+    if (!prev.bbox || !curr.bbox) continue;
+    const width = Math.max(prev.bbox.width, curr.bbox.width, 1);
+    const leftDiff = Math.abs(prev.bbox.x - curr.bbox.x);
+    const rightDiff = Math.abs(prev.bbox.x + prev.bbox.width - (curr.bbox.x + curr.bbox.width));
+    if (leftDiff > width * NEIGHBOR_TABLE_EPSILON || rightDiff > width * NEIGHBOR_TABLE_EPSILON) continue;
+    let currCells = curr.table.cells;
+    if (currCells.length > 1 && prev.table.cells.length > 0 && rowTextsEqual(prev.table.cells[0], currCells[0])) {
+      currCells = currCells.slice(1);
+    }
+    if (currCells.length === 0) {
+      blocks.splice(i + 1, 1);
+      continue;
+    }
+    const merged = {
+      rows: prev.table.rows + currCells.length,
+      cols: prev.table.cols,
+      cells: [...prev.table.cells, ...currCells],
+      hasHeader: prev.table.hasHeader,
+      caption: prev.table.caption
+    };
+    blocks[i] = { ...prev, table: merged };
+    blocks.splice(i + 1, 1);
+  }
+}
+function rowTextsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const norm = (t) => t.replace(/\s+/g, "");
+  for (let i = 0; i < a.length; i++) {
+    if (norm(a[i].text) !== norm(b[i].text)) return false;
+  }
+  return a.some((c) => c.text.trim() !== "");
+}
 function mergeAdjacentTableBlocks(blocks) {
   if (blocks.length <= 1) return blocks;
   const result = [blocks[0]];
@@ -1780,7 +2225,8 @@ function extractPageBlocksFallback(items, pageNum) {
     w: i.w,
     h: i.h,
     fontSize: i.fontSize,
-    fontName: i.fontName
+    fontName: i.fontName,
+    hasSpaceBefore: i.hasSpaceBefore
   }));
   const clusterResults = detectClusterTables(clusterItems, pageNum);
   if (clusterResults.length > 0) {
@@ -1796,7 +2242,7 @@ function extractPageBlocksFallback(items, pageNum) {
     }
     const remaining = items.filter((_, idx) => !usedIndices.has(idx));
     if (remaining.length > 0) {
-      const yLines = groupByY(remaining);
+      const yLines = mergeSuperscriptLines(groupByY(remaining));
       for (const line of yLines) {
         const text = mergeLineSimple(line);
         if (!text.trim()) continue;
@@ -1810,7 +2256,7 @@ function extractPageBlocksFallback(items, pageNum) {
       return by - ay;
     });
   } else {
-    const allYLines = groupByY(items);
+    const allYLines = mergeSuperscriptLines(groupByY(items));
     const columns = detectColumns(allYLines);
     if (columns && columns.length >= 3) {
       const tableText = extractWithColumns(allYLines, columns);
@@ -1823,7 +2269,7 @@ function extractPageBlocksFallback(items, pageNum) {
       const orderedGroups = xyCutOrder(items, gapThreshold);
       for (const group of orderedGroups) {
         if (group.length === 0) continue;
-        const yLines = groupByY(group);
+        const yLines = mergeSuperscriptLines(groupByY(group));
         const groupColumns = detectColumns(yLines);
         if (groupColumns && groupColumns.length >= 3) {
           const tableText = extractWithColumns(yLines, groupColumns);
@@ -1915,16 +2361,16 @@ function normalizeItems(rawItems) {
     if (!isDup) deduped.push(sorted[i]);
   }
   if (spacePositions.length > 0) {
-    for (const item of deduped) {
-      for (const sp of spacePositions) {
-        if (Math.abs(sp.y - item.y) <= 3) {
-          const dist = item.x - sp.x;
-          if (dist >= 0 && dist <= 20) {
-            item.hasSpaceBefore = true;
-            break;
-          }
+    for (const sp of spacePositions) {
+      let nearest = null;
+      for (const item of deduped) {
+        if (Math.abs(sp.y - item.y) > 3) continue;
+        const dist = item.x - sp.x;
+        if (dist >= -1 && dist <= 20 && (!nearest || item.x < nearest.x)) {
+          nearest = item;
         }
       }
+      if (nearest) nearest.hasSpaceBefore = true;
     }
   }
   return deduped;
@@ -1958,6 +2404,35 @@ function groupByY(items) {
   if (curLine.length > 0) lines.push(curLine);
   return lines;
 }
+function mergeSuperscriptLines(lines) {
+  if (lines.length <= 1) return lines;
+  const band = (line) => {
+    let bottom = Infinity, top = -Infinity;
+    for (const i of line) {
+      const h = i.h > 0 ? i.h : i.fontSize;
+      if (i.y < bottom) bottom = i.y;
+      if (i.y + h > top) top = i.y + h;
+    }
+    return { bottom, top, height: top - bottom };
+  };
+  const isFrag = (line) => line.length <= 3 && line.every((i) => i.text.trim().length <= 8);
+  const result = [lines[0]];
+  for (let i = 1; i < lines.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = lines[i];
+    const a = band(prev);
+    const b = band(curr);
+    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
+    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    if (prevIsFrag || currIsFrag) {
+      result[result.length - 1] = [...prev, ...curr];
+    } else {
+      result.push(curr);
+    }
+  }
+  return result;
+}
 function isProseSpread(items) {
   if (items.length < 4) return false;
   const sorted = [...items].sort((a, b) => a.x - b.x);
@@ -2199,9 +2674,7 @@ function mergeLineSimple(items) {
       result += sorted[i].text;
       continue;
     }
-    if (gap < avgFs * 0.15) {
-    } else if (gap < avgFs * 0.35 && (/[가-힣]$/.test(result) || /^[가-힣]/.test(sorted[i].text))) {
-    } else if (gap > 3) result += " ";
+    if (gap > spaceGapThreshold(avgFs)) result += " ";
     result += sorted[i].text;
   }
   return result;
@@ -2225,7 +2698,7 @@ function cleanPdfText(text) {
   ).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(/\n{3,}/g, "\n\n").trim();
+  }).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();
@@ -2234,6 +2707,134 @@ function startsWithMarker(line) {
 function isStandaloneHeader(line) {
   return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(line.trim());
 }
+var TABLE_CAPTION_RE = /^[<\[(【〈]?\s*(표|그림|도표|Table|Figure|Fig\.?)\s*[\d①-⑮][\d.\-]*\s*[\])】〉>]?[.:]?\s*/i;
+var CAPTION_MAX_LENGTH = 100;
+var CAPTION_MAX_GAP = 30;
+function detectTableCaptions(blocks) {
+  const isCaptionCandidate = (b, table) => {
+    if (!b || b.type !== "paragraph" || !b.text) return false;
+    if (b.pageNumber !== table.pageNumber) return false;
+    const text = b.text.trim();
+    if (!text || text.length > CAPTION_MAX_LENGTH || text.includes("\n")) return false;
+    if (!TABLE_CAPTION_RE.test(text)) return false;
+    if (b.bbox && table.bbox) {
+      const capTop = b.bbox.y + b.bbox.height;
+      const capBottom = b.bbox.y;
+      const tblTop = table.bbox.y + table.bbox.height;
+      const tblBottom = table.bbox.y;
+      const gap = capBottom >= tblTop ? capBottom - tblTop : tblBottom - capTop;
+      if (gap > CAPTION_MAX_GAP) return false;
+      const overlap = Math.min(b.bbox.x + b.bbox.width, table.bbox.x + table.bbox.width) - Math.max(b.bbox.x, table.bbox.x);
+      if (overlap < Math.min(b.bbox.width, table.bbox.width) * 0.3) return false;
+    }
+    return true;
+  };
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type !== "table" || !block.table || block.table.caption) continue;
+    if (isCaptionCandidate(blocks[i - 1], block)) {
+      block.table.caption = blocks[i - 1].text.trim();
+      blocks.splice(i - 1, 1);
+      i--;
+    } else if (isCaptionCandidate(blocks[i + 1], block)) {
+      block.table.caption = blocks[i + 1].text.trim();
+      blocks.splice(i + 1, 1);
+    }
+  }
+}
+var 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 };
+  }
+  m = text.match(/^([①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮])\s*/);
+  if (m) return { family: "circled", ord: m[1].charCodeAt(0) - 9312 + 1 };
+  return null;
+}
+var ATTACHMENT_RE = /^붙\s*임\s*(\d+[.:]?)?\s/;
+function detectKoreanListBlocks(blocks) {
+  const labeled = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b.type !== "paragraph" && b.type !== "list" || !b.text) continue;
+    const label = parseListLabel(b.text.trim());
+    if (label) labeled.push({ idx: i, label });
+  }
+  const validated = /* @__PURE__ */ new Set();
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const l of labeled) {
+    const arr = byFamily.get(l.label.family) || [];
+    arr.push(l);
+    byFamily.set(l.label.family, arr);
+  }
+  for (const arr of byFamily.values()) {
+    let chain = [];
+    for (const item of arr) {
+      const prev = chain[chain.length - 1];
+      if (prev && item.label.ord === prev.label.ord + 1 && item.idx - prev.idx <= 20) {
+        chain.push(item);
+      } else {
+        if (chain.length >= 2) for (const c of chain) validated.add(c.idx);
+        chain = [item];
+      }
+    }
+    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);
+    } else {
+      blocks[i] = listBlock;
+      lastTopLevelList = listBlock;
+    }
+  }
+  if (toRemove.size > 0) {
+    const sorted = [...toRemove].sort((a, b) => b - a);
+    for (const idx of sorted) blocks.splice(idx, 1);
+  }
+}
 function detectListBlocks(blocks) {
   const result = [];
   for (let i = 0; i < blocks.length; i++) {
@@ -2343,7 +2944,6 @@ function detectSpecialKoreanTables(blocks) {
 function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
   const ZONE_RATIO = 0.12;
   const MIN_REPEAT = 3;
-  const Y_BUCKET = 5;
   const topEntries = [];
   const bottomEntries = [];
   for (let bi = 0; bi < blocks.length; bi++) {
@@ -2353,7 +2953,7 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
     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, y: b.bbox.y, text: b.text.trim() };
+    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);
   }
@@ -2375,21 +2975,9 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
         repeatedPatterns.add(p);
       }
     }
-    const bucketPages = /* @__PURE__ */ new Map();
-    for (const e of entries) {
-      const bucket = Math.round(e.y / Y_BUCKET);
-      const pages = bucketPages.get(bucket) || /* @__PURE__ */ new Set();
-      pages.add(e.page);
-      bucketPages.set(bucket, pages);
-    }
-    const repeatedBuckets = /* @__PURE__ */ new Set();
-    for (const [b, pages] of bucketPages) {
-      if (pages.size >= MIN_REPEAT) repeatedBuckets.add(b);
-    }
     for (const e of entries) {
       const norm = e.text.replace(/\d+/g, "#");
-      const bucket = Math.round(e.y / Y_BUCKET);
-      if (repeatedPatterns.has(norm) || repeatedBuckets.has(bucket)) {
+      if (repeatedPatterns.has(norm)) {
         removeSet.add(e.blockIdx);
       }
     }
@@ -2548,7 +3136,11 @@ function formatMb(bytes) {
 }
 export {
   cleanPdfText,
+  detectKoreanListBlocks,
+  detectTableCaptions,
   extractPdfMetadataOnly,
-  parsePdfDocument
+  mergeCrossPageTables,
+  parsePdfDocument,
+  removeHeaderFooterBlocks
 };
-//# sourceMappingURL=parser-BKYM3LKN.js.map
+//# sourceMappingURL=parser-LZH7ZELV.js.map