kordoc 4.14.2 → 4.14.3

package/dist/{chunk-A7QC2ZVP.js → chunk-UVVEBI22.js}

@@ -2,11 +2,11 @@ import {
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3
-} from "./chunk-FOJZNMMK.js";
+} from "./chunk-2LQGSDZ6.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-JQEFP45L.js";
+} from "./chunk-L5EH2NVO.js";
 
 // src/pdf/image-regions.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -69,6 +69,8 @@ function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
   const clipRects = [];
+  const fillRects = [];
+  let pathRects = [];
   let pendingClip = false;
   let lineWidth = 1;
   let ctm = [1, 0, 0, 1, 0, 0];
@@ -84,6 +86,8 @@ function extractLines(fnArray, argsArray) {
     currentPath.push({ x1: tx1, y1: ty1, x2: tx2, y2: ty2 });
   }
   function pushRectangle(rx, ry, rw, rh) {
+    const [ax, ay] = applyCtm(rx, ry), [bx, by] = applyCtm(rx + rw, ry + rh);
+    pathRects.push({ x1: Math.min(ax, bx), y1: Math.min(ay, by), x2: Math.max(ax, bx), y2: Math.max(ay, by) });
     const effH = Math.abs(rh) * Math.hypot(ctm[2], ctm[3]);
     const effW = Math.abs(rw) * Math.hypot(ctm[0], ctm[1]);
     if (effH < ORIENTATION_TOL * 2) {
@@ -97,7 +101,12 @@ function extractLines(fnArray, argsArray) {
       pushSeg(rx, ry + rh, rx, ry);
     }
   }
-  function flushPath(isStroke, fromFill = false) {
+  function flushPath(isStroke, fromFill = false, filled = fromFill) {
+    if (filled) {
+      if (pathRects.length) for (const r of pathRects) fillRects.push(r);
+      else captureClipRect(currentPath, fillRects, 0.3, 0.3);
+    }
+    pathRects = [];
     if (!isStroke) {
       if (pendingClip) captureClipRect(currentPath, clipRects);
       pendingClip = false;
@@ -208,7 +217,7 @@ function extractLines(fnArray, argsArray) {
           } else if (afterOp === OPS2.fill || afterOp === OPS2.eoFill) {
             flushPath(true, true);
           } else if (afterOp === OPS2.fillStroke || afterOp === OPS2.eoFillStroke || afterOp === OPS2.closeFillStroke || afterOp === OPS2.closeEOFillStroke) {
-            flushPath(true);
+            flushPath(true, false, true);
           } else if (afterOp === OPS2.endPath) {
             flushPath(false);
           }
@@ -227,7 +236,7 @@ function extractLines(fnArray, argsArray) {
       case OPS2.eoFillStroke:
       case OPS2.closeFillStroke:
       case OPS2.closeEOFillStroke:
-        flushPath(true);
+        flushPath(true, false, true);
         break;
       case OPS2.endPath:
         flushPath(false);
@@ -238,11 +247,11 @@ function extractLines(fnArray, argsArray) {
         break;
     }
   }
-  return { horizontals, verticals, clipRects };
+  return { horizontals, verticals, clipRects, fillRects };
 }
 var CLIP_MIN_W = 4;
 var CLIP_MIN_H = 2;
-function captureClipRect(path, out) {
+function captureClipRect(path, out, minW = CLIP_MIN_W, minH = CLIP_MIN_H) {
   if (path.length < 3 || path.length > 5) return;
   let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
   for (const s of path) {
@@ -253,7 +262,7 @@ function captureClipRect(path, out) {
     y1 = Math.min(y1, s.y1, s.y2);
     y2 = Math.max(y2, s.y1, s.y2);
   }
-  if (x2 - x1 < CLIP_MIN_W || y2 - y1 < CLIP_MIN_H) return;
+  if (x2 - x1 < minW || y2 - y1 < minH) return;
   out.push({ x1, y1, x2, y2 });
 }
 function classifyAndAdd(seg, lineWidth, horizontals, verticals, fromFill = false) {
@@ -960,20 +969,24 @@ function linesIntersect(a, b) {
 
 // src/pdf/clip-cells.ts
 var CLIP_EDGE_TOL = 1.5;
+var CLIP_ADJ_GAP = 0.15;
 var CLIP_MIN_GROUP = 2;
 var CLIP_MAX_PAGE_FRAC = 0.75;
 var TITLED_FRAME_MIN_TOP = 0.2;
 var TITLED_FRAME_MIN_WIDTH = 0.6;
 var HEADER_BAND = 0.08;
 var CLIP_MIN_W2 = 4;
+var NARROW_FILL_MIN_W = 1;
 var CLIP_MIN_H2 = 2;
 var STROKE_NEAR = 2;
 var STROKE_COVER = 0.5;
 var CLIP_MIN_INVISIBLE = 0;
+var CLIP_COORD_TOL = 0.3;
 var overlap = (a1, a2, b1, b2) => Math.min(a2, b2) - Math.max(a1, b1);
 function adjacent(a, b) {
-  if ((Math.abs(a.x2 - b.x1) <= CLIP_EDGE_TOL || Math.abs(b.x2 - a.x1) <= CLIP_EDGE_TOL) && overlap(a.y1, a.y2, b.y1, b.y2) > CLIP_EDGE_TOL) return true;
-  if ((Math.abs(a.y2 - b.y1) <= CLIP_EDGE_TOL || Math.abs(b.y2 - a.y1) <= CLIP_EDGE_TOL) && overlap(a.x1, a.x2, b.x1, b.x2) > CLIP_EDGE_TOL) return true;
+  const al = (u, v) => Math.abs(u - v) <= CLIP_COORD_TOL;
+  if ((Math.abs(a.x2 - b.x1) <= CLIP_ADJ_GAP || Math.abs(b.x2 - a.x1) <= CLIP_ADJ_GAP) && overlap(a.y1, a.y2, b.y1, b.y2) > CLIP_EDGE_TOL && (al(a.y1, b.y1) || al(a.y2, b.y2))) return true;
+  if ((Math.abs(a.y2 - b.y1) <= CLIP_ADJ_GAP || Math.abs(b.y2 - a.y1) <= CLIP_ADJ_GAP) && overlap(a.x1, a.x2, b.x1, b.x2) > CLIP_EDGE_TOL && (al(a.x1, b.x1) || al(a.x2, b.x2))) return true;
   return false;
 }
 function contains(a, b) {
@@ -984,7 +997,7 @@ function clusterCoords(values) {
   const out = [];
   let run = [];
   for (const v of sorted) {
-    if (run.length > 0 && v - run[run.length - 1] > CLIP_EDGE_TOL) {
+    if (run.length > 0 && v - run[run.length - 1] > CLIP_COORD_TOL) {
       out.push(run.reduce((s, x) => s + x, 0) / run.length);
       run = [];
     }
@@ -1010,7 +1023,7 @@ function edgeStroked(lines, dir, pos, a1, a2) {
   }
   return false;
 }
-function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, textPoints = []) {
+function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, textPoints = [], fillRects = []) {
   const pageArea = pageWidth * pageHeight;
   const sameRect = (a, b) => Math.abs(a.x1 - b.x1) <= CLIP_EDGE_TOL && Math.abs(a.x2 - b.x2) <= CLIP_EDGE_TOL && Math.abs(a.y1 - b.y1) <= CLIP_EDGE_TOL && Math.abs(a.y2 - b.y2) <= CLIP_EDGE_TOL;
   const cells = [];
@@ -1021,15 +1034,45 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   }
   if (cells.length < 1) return { grids: [], containers: [] };
   const parent = new Array(cells.length).fill(-1);
+  const area = (r) => (r.x2 - r.x1) * (r.y2 - r.y1);
   for (let i = 0; i < cells.length; i++) {
     for (let j = 0; j < cells.length; j++) {
-      if (i === j || !contains(cells[j], cells[i])) continue;
+      if (i === j || area(cells[j]) <= area(cells[i]) || !contains(cells[j], cells[i])) continue;
       const cur = parent[i];
       if (cur < 0 || contains(cells[cur], cells[j])) parent[i] = j;
     }
   }
   const isContainer = new Array(cells.length).fill(false);
   for (const p of parent) if (p >= 0) isContainer[p] = true;
+  const tileParent = new Array(cells.length).fill(false);
+  const tableClip = new Array(cells.length).fill(false);
+  for (let p = 0; p < cells.length; p++) {
+    if (!isContainer[p]) continue;
+    let n = 0, x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+    for (let i = 0; i < cells.length; i++) {
+      if (parent[i] !== p) continue;
+      const k = cells[i];
+      n++;
+      x1 = Math.min(x1, k.x1);
+      y1 = Math.min(y1, k.y1);
+      x2 = Math.max(x2, k.x2);
+      y2 = Math.max(y2, k.y2);
+    }
+    if (n < CLIP_MIN_GROUP) continue;
+    const c = cells[p];
+    if (Math.max(Math.abs(x1 - c.x1), Math.abs(x2 - c.x2), Math.abs(y1 - c.y1), Math.abs(y2 - c.y2)) <= CLIP_COORD_TOL) tileParent[p] = true;
+  }
+  for (let p = 0; p < cells.length; p++) {
+    if (tileParent[p]) tableClip[p] = !cells.some((q, i) => i !== p && parent[i] === parent[p] && !tileParent[i] && adjacent(q, cells[p]));
+  }
+  const effParent = (i) => {
+    let p = parent[i];
+    for (let steps = 0; p >= 0 && steps <= cells.length; steps++) {
+      if (!tableClip[p] && (isGridMember(p) || loneFrame(p))) return p;
+      p = parent[p];
+    }
+    return -1;
+  };
   const root = cells.map((_, i) => i);
   const find = (i) => {
     while (root[i] !== i) {
@@ -1039,8 +1082,9 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     return i;
   };
   for (let i = 0; i < cells.length; i++) {
+    if (tableClip[i]) continue;
     for (let j = i + 1; j < cells.length; j++) {
-      if (parent[i] !== parent[j]) continue;
+      if (tableClip[j] || parent[i] !== parent[j]) continue;
       if (adjacent(cells[i], cells[j])) {
         const ra = find(i), rb = find(j);
         if (ra !== rb) root[ra] = rb;
@@ -1060,12 +1104,13 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   const framed = (r) => edgeStroked(strokedH, "h", r.y1, r.x1, r.x2) && edgeStroked(strokedH, "h", r.y2, r.x1, r.x2) && edgeStroked(strokedV, "v", r.x1, r.y1, r.y2) && edgeStroked(strokedV, "v", r.x2, r.y1, r.y2);
   const titledFrame = (r) => r.y1 >= pageHeight * TITLED_FRAME_MIN_TOP && r.x2 - r.x1 >= pageWidth * TITLED_FRAME_MIN_WIDTH && textPoints.some((p) => p.y < r.y1 && p.y > pageHeight * HEADER_BAND && p.x >= r.x1 - CLIP_EDGE_TOL && p.x <= r.x2 + CLIP_EDGE_TOL) && textPoints.some((p) => p.x > r.x1 && p.x < r.x2 && p.y > r.y1 && p.y < r.y2);
   const loneFrame = (i) => isContainer[i] && !isGridMember(i) && (framed(cells[i]) || titledFrame(cells[i]));
-  const parentAttachable = (i) => parent[i] >= 0 && (isGridMember(parent[i]) || loneFrame(parent[i]));
+  const parentAttachable = (i) => effParent(i) >= 0;
   const onlyChild = (i) => parent[i] >= 0 && parent.filter((p) => p === parent[i]).length === 1;
   const grids = [];
   for (const idxs of groups.values()) {
     const first = idxs[0];
-    const parentRect = parentAttachable(first) ? cells[parent[first]] : void 0;
+    if (tableClip[first]) continue;
+    const parentRect = parentAttachable(first) ? cells[effParent(first)] : void 0;
     if (idxs.length < CLIP_MIN_GROUP) {
       if (!loneFrame(first) && !((parentRect || onlyChild(first)) && framed(cells[first]))) continue;
       const r = cells[first];
@@ -1111,13 +1156,14 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     for (let rr = 0; rr < numRows; rr++) {
       for (let cc = 0; cc < numCols; cc++) {
         if (occupied[rr][cc]) continue;
-        out.push({ row: rr, col: cc, rowSpan: 1, colSpan: 1, bbox: { x1: colXs[cc], y1: rowYs[rr + 1], x2: colXs[cc + 1], y2: rowYs[rr] } });
+        out.push({ row: rr, col: cc, rowSpan: 1, colSpan: 1, bbox: { x1: colXs[cc], y1: rowYs[rr + 1], x2: colXs[cc + 1], y2: rowYs[rr] }, filler: true });
       }
     }
+    addNarrowEdgeCols(colXs, rowYs, out, fillRects);
     grids.push({
       rowYs,
       colXs,
-      bbox: { x1: colXs[0], y1: rowYs[numRows], x2: colXs[numCols], y2: rowYs[0] },
+      bbox: { x1: colXs[0], y1: rowYs[numRows], x2: colXs[colXs.length - 1], y2: rowYs[0] },
       vertexRadius: 1,
       cells: out,
       ...parentRect ? { clipParent: parentRect } : {}
@@ -1125,6 +1171,41 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   }
   return { grids, containers };
 }
+function addNarrowEdgeCols(colXs, rowYs, out, fills) {
+  if (!fills.length) return;
+  const rowIdx = (y) => {
+    const i = nearestIndex(rowYs, y);
+    return Math.abs(rowYs[i] - y) <= CLIP_COORD_TOL ? i : -1;
+  };
+  for (const side of ["l", "r"]) {
+    const edge = side === "l" ? colXs[0] : colXs[colXs.length - 1];
+    const hits = fills.filter((f) => {
+      const w = f.x2 - f.x1;
+      if (w < NARROW_FILL_MIN_W || w >= CLIP_MIN_W2 || Math.abs((side === "l" ? f.x2 : f.x1) - edge) > CLIP_COORD_TOL) return false;
+      const r0 = rowIdx(f.y2), r1 = rowIdx(f.y1);
+      return r0 >= 0 && r1 > r0;
+    });
+    if (!hits.length) continue;
+    let x = side === "l" ? Infinity : -Infinity;
+    for (const f of hits) x = side === "l" ? Math.min(x, f.x1) : Math.max(x, f.x2);
+    if (side === "l") {
+      colXs.unshift(x);
+      for (const c of out) c.col++;
+    } else colXs.push(x);
+    const col = side === "l" ? 0 : colXs.length - 2;
+    const [cx1, cx2] = [colXs[col], colXs[col + 1]];
+    const taken = new Array(rowYs.length - 1).fill(false);
+    for (const f of hits) {
+      const r0 = rowIdx(f.y2), r1 = rowIdx(f.y1);
+      if (taken.slice(r0, r1).some(Boolean)) continue;
+      taken.fill(true, r0, r1);
+      out.push({ row: r0, col, rowSpan: r1 - r0, colSpan: 1, bbox: { x1: cx1, y1: rowYs[r1], x2: cx2, y2: rowYs[r0] } });
+    }
+    for (let r = 0; r < taken.length; r++) {
+      if (!taken[r]) out.push({ row: r, col, rowSpan: 1, colSpan: 1, bbox: { x1: cx1, y1: rowYs[r + 1], x2: cx2, y2: rowYs[r] }, filler: true });
+    }
+  }
+}
 function dropGridsInside(lineGrids, clipGrids, containers = []) {
   if (clipGrids.length === 0 && containers.length === 0) return lineGrids;
   const area = (b) => Math.max(0, b.x2 - b.x1) * Math.max(0, b.y2 - b.y1);
@@ -1296,7 +1377,7 @@ function cellTextToString(items) {
   lines.push(curLine);
   const merged = mergeSuperscriptRows(lines);
   const textLines = merged.map((line) => {
-    const s = line.sort((a, b) => a.x - b.x);
+    const s = sortLineByX(line);
     if (s.length === 1) return s[0].text;
     const evenSpaced = detectEvenSpacedItems(s);
     let result = s[0].text;
@@ -1418,7 +1499,7 @@ function mergeCellTextLines(textLines) {
       merged[merged.length - 1] = prev + curr.trim();
     } else if (/[,(]$/.test(prev.trim()) && curr.trim().length <= 15) {
       merged[merged.length - 1] = prev + curr.trim();
-    } else if (/[\d,]$/.test(prev) && /^[\d,]+[)\]]?$/.test(curr.trim()) && curr.trim().length <= 10) {
+    } else if (/[\d,]$/.test(prev) && /^[\d,]+[)\]]?$/.test(curr.trim()) && curr.trim().length <= 10 && !(/\d{1,3}(,\d{3})+$/.test(prev) && /^\d{1,3}(,\d{3})+$/.test(curr.trim()))) {
       merged[merged.length - 1] = prev + curr.trim();
     } else {
       merged.push(curr);
@@ -1538,11 +1619,24 @@ function normalizeUndersegmentedTable(originalCells, colXs, items) {
     return n;
   };
   if (countNonEmptyRows(rebuilt) <= countNonEmptyRows(originalCells)) return null;
-  if (countNonEmptyCols(rebuilt, numCols) < countNonEmptyCols(originalCells, numCols)) return null;
+  const origBody = numRows > 1 ? originalCells.slice(1) : originalCells;
+  if (countNonEmptyCols(rebuilt, numCols) < countNonEmptyCols(origBody, numCols)) return null;
   return rebuilt;
 }
 
 // src/pdf/text-line.ts
+function sortLineByX(items) {
+  items.sort((a, b) => a.x - b.x);
+  for (let i = 1; i < items.length; i++) {
+    for (let j = i; j > 0; j--) {
+      const a = items[j - 1], b = items[j];
+      if (b.x - a.x > 1 || a.seq === void 0 || b.seq === void 0 || b.seq >= a.seq) break;
+      items[j - 1] = b;
+      items[j] = a;
+    }
+  }
+  return items;
+}
 function filterHiddenText(items, pageWidth, pageHeight) {
   let hiddenCount = 0;
   const visible = [];
@@ -1605,7 +1699,9 @@ function dominantStyle(items) {
 function normalizeItems(rawItems) {
   const items = [];
   const spacePositions = [];
+  let seq = 0;
   for (const i of rawItems) {
+    seq++;
     if (typeof i.str !== "string") continue;
     const x = Math.round(i.transform[4]);
     const y = Math.round(i.transform[5]);
@@ -1625,11 +1721,11 @@ function normalizeItems(rawItems) {
     }
     const split = splitEvenSpacedItem(text, x, w, fontSize);
     if (split) {
-      for (const s of split) {
-        items.push({ text: s.text, x: s.x, y, w: s.w, h, fontSize, fontName: i.fontName || "", isHidden });
-      }
+      split.forEach((s, k) => {
+        items.push({ text: s.text, x: s.x, y, w: s.w, h, fontSize, fontName: i.fontName || "", isHidden, seq: seq + k / 1e3 });
+      });
     } else {
-      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden });
+      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden, seq });
     }
   }
   const sorted = items.sort((a, b) => b.y - a.y || a.x - b.x);
@@ -1727,7 +1823,7 @@ function mergeSuperscriptLines(lines) {
 }
 function mergeLineSimple(items) {
   if (items.length <= 1) return items[0]?.text || "";
-  const sorted = [...items].sort((a, b) => a.x - b.x);
+  const sorted = sortLineByX([...items]);
   const isEvenSpaced = detectEvenSpacedItems(sorted);
   let result = sorted[0].text;
   for (let i = 1; i < sorted.length; i++) {
@@ -2145,6 +2241,52 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
   return [...removeSet].sort((a, b) => a - b);
 }
 
+// src/pdf/table-meta.ts
+var CLIP_TABLES = /* @__PURE__ */ new WeakSet();
+var TABLE_COLXS = /* @__PURE__ */ new WeakMap();
+var EMPTY_PARTS = /* @__PURE__ */ new WeakSet();
+var IMAGE_CELLS = /* @__PURE__ */ new WeakSet();
+var FILLER_CELLS = /* @__PURE__ */ new WeakSet();
+var CELL_LINES = /* @__PURE__ */ new WeakMap();
+function recordCellLines(cell, items) {
+  const lines = [];
+  for (const it of [...items].sort((a, b) => b.y - a.y)) {
+    const fs = it.fontSize || it.h;
+    const last = lines[lines.length - 1];
+    if (last && Math.abs(last.y - it.y) <= Math.max(3, Math.min(fs, last.h) * 0.6)) {
+      last.l = Math.min(last.l, it.x);
+      last.r = Math.max(last.r, it.x + it.w);
+      last.h = Math.max(last.h, fs);
+    } else lines.push({ y: it.y, l: it.x, r: it.x + it.w, h: fs });
+  }
+  CELL_LINES.set(cell, lines);
+}
+
+// src/pdf/table-trim.ts
+function markImageCell(cell) {
+  IMAGE_CELLS.add(cell);
+}
+var emptyCell = (cell) => !cell || !cell.text?.trim() && !cell.blocks?.length && !IMAGE_CELLS.has(cell);
+function trimTable(table) {
+  let cols = table.cols;
+  while (cols > 0 && table.cells.every((row) => emptyCell(row[cols - 1]))) cols--;
+  if (cols === table.cols || cols === 0) return;
+  table.cells = table.cells.map((row) => row.slice(0, cols));
+  for (const row of table.cells) {
+    for (let c = 0; c < row.length; c++) {
+      if (c + row[c].colSpan > cols) row[c].colSpan = cols - c;
+    }
+  }
+  table.cols = cols;
+}
+function trimTrailingEmptyTableCols(blocks) {
+  for (const b of blocks) {
+    if (b.type !== "table" || !b.table) continue;
+    for (const row of b.table.cells) for (const cell of row) if (cell.blocks?.length) trimTrailingEmptyTableCols(cell.blocks);
+    trimTable(b.table);
+  }
+}
+
 // src/pdf/cluster-detector.ts
 var Y_TOL = 3;
 var COL_CLUSTER_TOL = 15;
@@ -2241,18 +2383,16 @@ function findTwoColumnProseCutX(items) {
   const right = [];
   let twoSide = 0;
   for (const line of lines) {
-    let hasL = false;
-    let hasR = false;
+    const L = [], R = [];
     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 (i.x + i.w <= cutX) L.push(i);
+      else if (i.x >= cutX) R.push(i);
+    }
+    if (L.length && R.length) {
+      twoSide++;
+      left.push(...L);
+      right.push(...R);
     }
-    if (hasL && hasR) twoSide++;
   }
   if (twoSide / lines.length < 0.55) return null;
   if (left.length < 5 || right.length < 5) return null;
@@ -3376,7 +3516,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   if (items.length === 0) return [];
   const extracted = extractLines(opList.fnArray, opList.argsArray);
   let { horizontals, verticals } = extracted;
-  const clipResult = detectTables ? buildClipCellGrids(extracted.clipRects, horizontals, verticals, pageWidth, pageHeight, items.map((it) => ({ x: it.x + it.w / 2, y: it.y + it.h / 2 }))) : { grids: [], containers: [] };
+  const clipResult = detectTables ? buildClipCellGrids(extracted.clipRects, horizontals, verticals, pageWidth, pageHeight, items.map((it) => ({ x: it.x + it.w / 2, y: it.y + it.h / 2 })), extracted.fillRects) : { grids: [], containers: [] };
   const clipGrids = clipResult.grids;
   if (extraLines) {
     horizontals = horizontals.concat(extraLines.horizontals);
@@ -3394,7 +3534,8 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   const lineGrids = detectTables ? buildTableGrids(horizontals, verticals) : [];
   const grids = [...clipGrids, ...dropGridsInside(lineGrids, clipGrids, clipResult.containers)];
   if (grids.length > 0) {
-    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
+    const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
+    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, imageRegions);
   }
   return extractPageBlocksFallback(items, pageNum, true, detectTables);
 }
@@ -3526,7 +3667,7 @@ function buildFrameCellBlocks(cellItems, nested, pageNum) {
   const text = blocks.map((b) => b.type === "table" && b.table ? b.table.cells.flat().map((c) => c.text).filter(Boolean).join("\n") : b.text ?? "").filter(Boolean).join("\n");
   return { blocks, text };
 }
-function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
+function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, imageRegions = []) {
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
   const pendingNested = [];
@@ -3558,7 +3699,8 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       h: i.h,
       fontSize: i.fontSize,
       fontName: i.fontName,
-      hasSpaceBefore: i.hasSpaceBefore
+      hasSpaceBefore: i.hasSpaceBefore,
+      seq: i.seq
     }));
     const cellTextMap = mapTextToCells(textItems, cells);
     const assignedItems = /* @__PURE__ */ new Set();
@@ -3584,11 +3726,21 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
         colSpan: cell.colSpan,
         rowSpan: cell.rowSpan
       };
+      const b = cell.bbox;
+      const isBackdrop = (r) => r.x1 <= b.x1 + 1 && r.x2 >= b.x2 - 1 && r.y1 <= b.y1 + 1 && r.y2 >= b.y2 - 1;
+      if (imageRegions.some((r) => {
+        const cx = (r.x1 + r.x2) / 2, cy = (r.y1 + r.y2) / 2;
+        return cx > b.x1 && cx < b.x2 && cy > b.y1 && cy < b.y2 && !isBackdrop(r);
+      })) {
+        markImageCell(irGrid[cell.row][cell.col]);
+      }
+      if (cell.filler && !cellItems.length) FILLER_CELLS.add(irGrid[cell.row][cell.col]);
+      if (grid.cells && cellItems.length) recordCellLines(irGrid[cell.row][cell.col], cellItems);
     }
     let finalGrid = irGrid;
     let finalRows = numRows;
     let rebuiltUsed = false;
-    if (numRows <= 2 && numCols >= 3 && !nestedAttached) {
+    if (!grid.cells && numRows <= 2 && numCols >= 3 && !nestedAttached) {
       const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
       if (rebuilt) {
         rebuiltUsed = true;
@@ -3607,8 +3759,11 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       cells: finalGrid,
       hasHeader: finalRows > 1
     };
+    TABLE_COLXS.set(irTable, grid.colXs);
     const hasContent = finalGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
-    if (!hasContent) continue;
+    const emptyPart = !hasContent && !!grid.cells && !grid.clipParent && !nestedAttached;
+    if (!hasContent && !emptyPart) continue;
+    if (emptyPart) EMPTY_PARTS.add(irTable);
     if (grid.clipParent) {
       const nb = { page: pageNum, x: grid.bbox.x1, y: grid.bbox.y1, width: grid.bbox.x2 - grid.bbox.x1, height: grid.bbox.y2 - grid.bbox.y1 };
       pendingNested.push({ parent: grid.clipParent, block: { type: "table", table: irTable, pageNumber: pageNum, bbox: nb } });
@@ -3633,6 +3788,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       }
       continue;
     }
+    if (grid.cells) CLIP_TABLES.add(irTable);
     blocks.push({ type: "table", table: irTable, pageNumber: pageNum, bbox: tableBbox });
   }
   for (const p of pendingNested) blocks.push(p.block);
@@ -3670,7 +3826,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
   {
     const rects = remaining.map((i) => ({ x: i.x, y: i.y, w: i.w, h: i.h > 0 ? i.h : i.fontSize }));
     for (const b of blocks) {
-      if (b.bbox) rects.push({ x: b.bbox.x, y: b.bbox.y, w: b.bbox.width, h: b.bbox.height });
+      if (b.bbox && !(b.table && EMPTY_PARTS.has(b.table))) rects.push({ x: b.bbox.x, y: b.bbox.y, w: b.bbox.width, h: b.bbox.height });
     }
     gutterX = detectColumnGutter(rects);
   }
@@ -3747,53 +3903,13 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
   for (const u of units) for (const b of u) ordered.push(b);
   return mergeAdjacentTableBlocks(ordered);
 }
-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]];
   for (let i = 1; i < blocks.length; i++) {
     const prev = result[result.length - 1];
     const curr = blocks[i];
-    if (prev.type === "table" && curr.type === "table" && prev.table && curr.table && prev.table.cols === curr.table.cols) {
+    if (prev.type === "table" && curr.type === "table" && prev.table && curr.table && prev.table.cols === curr.table.cols && !CLIP_TABLES.has(prev.table) && !CLIP_TABLES.has(curr.table)) {
       const merged = {
         rows: prev.table.rows + curr.table.rows,
         cols: prev.table.cols,
@@ -3942,7 +4058,13 @@ export {
   detectTableCaptions,
   detectKoreanListBlocks,
   removeHeaderFooterBlocks,
-  extractPageBlocksWithLines,
-  mergeCrossPageTables
+  CLIP_TABLES,
+  TABLE_COLXS,
+  EMPTY_PARTS,
+  IMAGE_CELLS,
+  FILLER_CELLS,
+  CELL_LINES,
+  trimTrailingEmptyTableCols,
+  extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-A7QC2ZVP.js.map
+//# sourceMappingURL=chunk-UVVEBI22.js.map