kordoc 4.14.2 → 4.14.4

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

@@ -2,11 +2,11 @@ import {
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3
-} from "./chunk-FOJZNMMK.js";
+} from "./chunk-6CUIXJOC.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-JQEFP45L.js";
+} from "./chunk-GUJ4Q73I.js";
 
 // src/pdf/image-regions.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -68,7 +68,11 @@ var MAX_LINE_WIDTH = 5;
 function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
+  const shortH = [];
+  const shortV = [];
   const clipRects = [];
+  const fillRects = [];
+  let pathRects = [];
   let pendingClip = false;
   let lineWidth = 1;
   let ctm = [1, 0, 0, 1, 0, 0];
@@ -84,6 +88,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 +103,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;
@@ -107,7 +118,7 @@ function extractLines(fnArray, argsArray) {
     pendingClip = false;
     const effWidth = lineWidth * ctmScale();
     for (const seg of currentPath) {
-      classifyAndAdd(seg, effWidth, horizontals, verticals, fromFill);
+      classifyAndAdd(seg, effWidth, horizontals, verticals, fromFill, fromFill ? void 0 : { h: shortH, v: shortV });
     }
     currentPath = [];
   }
@@ -208,7 +219,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 +238,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 +249,60 @@ function extractLines(fnArray, argsArray) {
         break;
     }
   }
-  return { horizontals, verticals, clipRects };
+  return { horizontals, verticals, clipRects, fillRects, shortH, shortV };
+}
+var SHORT_CHAIN_POS_TOL = 0.5;
+var SHORT_CHAIN_GAP = 0.2;
+function chainShortSegments(longs, shorts, dir) {
+  if (shorts.length === 0) return longs;
+  const pos = (l) => dir === "h" ? l.y1 : l.x1;
+  const lo = (l) => dir === "h" ? l.x1 : l.y1;
+  const hi = (l) => dir === "h" ? l.x2 : l.y2;
+  const shortSet = new Set(shorts);
+  const all = [...longs.filter((l) => !l.fromFill), ...shorts].sort((a, b) => pos(a) - pos(b) || lo(a) - lo(b));
+  const absorbed = /* @__PURE__ */ new Set();
+  const chained = [];
+  const flush = (chain) => {
+    if (!chain.some((l) => shortSet.has(l))) return;
+    let s = Infinity, e = -Infinity, p = 0, w = 0;
+    for (const l of chain) {
+      s = Math.min(s, lo(l));
+      e = Math.max(e, hi(l));
+      p += pos(l);
+      w = Math.max(w, l.lineWidth);
+    }
+    if (e - s < MIN_LINE_LENGTH) return;
+    p /= chain.length;
+    for (const l of chain) absorbed.add(l);
+    chained.push(dir === "h" ? { x1: s, y1: p, x2: e, y2: p, lineWidth: w } : { x1: p, y1: s, x2: p, y2: e, lineWidth: w });
+  };
+  let band = [];
+  const flushBand = () => {
+    band.sort((a, b) => lo(a) - lo(b));
+    let chain = [];
+    let end = -Infinity;
+    for (const l of band) {
+      if (chain.length && lo(l) > end + SHORT_CHAIN_GAP) {
+        flush(chain);
+        chain = [];
+      }
+      chain.push(l);
+      end = chain.length === 1 ? hi(l) : Math.max(end, hi(l));
+    }
+    if (chain.length) flush(chain);
+    band = [];
+  };
+  for (const l of all) {
+    if (band.length && pos(l) - pos(band[0]) > SHORT_CHAIN_POS_TOL) flushBand();
+    band.push(l);
+  }
+  if (band.length) flushBand();
+  if (chained.length === 0) return longs;
+  return [...longs.filter((l) => !absorbed.has(l)), ...chained];
 }
 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,14 +313,24 @@ 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) {
+function classifyAndAdd(seg, lineWidth, horizontals, verticals, fromFill = false, short) {
   const dx = Math.abs(seg.x2 - seg.x1);
   const dy = Math.abs(seg.y2 - seg.y1);
   const length = Math.sqrt(dx * dx + dy * dy);
-  if (length < MIN_LINE_LENGTH) return;
+  if (length < MIN_LINE_LENGTH) {
+    if (!short || length <= 0) return;
+    if (dy <= ORIENTATION_TOL && dx > dy) {
+      const y = (seg.y1 + seg.y2) / 2;
+      short.h.push({ x1: Math.min(seg.x1, seg.x2), y1: y, x2: Math.max(seg.x1, seg.x2), y2: y, lineWidth });
+    } else if (dx <= ORIENTATION_TOL && dy > dx) {
+      const x = (seg.x1 + seg.x2) / 2;
+      short.v.push({ x1: x, y1: Math.min(seg.y1, seg.y2), x2: x, y2: Math.max(seg.y1, seg.y2), lineWidth });
+    }
+    return;
+  }
   if (dy <= ORIENTATION_TOL) {
     const y = (seg.y1 + seg.y2) / 2;
     const x1 = Math.min(seg.x1, seg.x2);
@@ -741,6 +811,23 @@ function buildTableGrids(horizontals, verticals) {
   }
   return mergeAdjacentGrids(grids);
 }
+var SHADE_CLIP_TOL = 1.5;
+var SHADE_CLIP_MAX_AREA = 0.5;
+function dropShadingClipGrids(clipGrids, lineGrids, fillRects, verticals = []) {
+  if (clipGrids.length === 0 || lineGrids.length === 0 || fillRects.length === 0) return clipGrids;
+  const near = (a, b) => Math.abs(a - b) <= SHADE_CLIP_TOL;
+  const area = (b) => Math.max(0, b.x2 - b.x1) * Math.max(0, b.y2 - b.y1);
+  const inter = (a, b) => area({ x1: Math.max(a.x1, b.x1), y1: Math.max(a.y1, b.y1), x2: Math.min(a.x2, b.x2), y2: Math.min(a.y2, b.y2) });
+  return clipGrids.filter((c) => {
+    if (!c.cells?.length || c.clipParent) return true;
+    const shaded = c.cells.every((cell) => fillRects.some((f) => near(f.x1, cell.bbox.x1) && near(f.x2, cell.bbox.x2) && near(f.y1, cell.bbox.y1) && near(f.y2, cell.bbox.y2)));
+    if (!shaded) return true;
+    const ruled = c.cells.every((cell) => cell.bbox.x2 >= c.bbox.x2 - SHADE_CLIP_TOL || verticals.some((v) => Math.abs(v.x1 - cell.bbox.x2) <= SHADE_CLIP_TOL * 2 && Math.min(v.y2, cell.bbox.y2) - Math.max(v.y1, cell.bbox.y1) >= (cell.bbox.y2 - cell.bbox.y1) * 0.75));
+    if (!ruled) return true;
+    const host = lineGrids.find((l) => c.bbox.x1 >= l.bbox.x1 - SHADE_CLIP_TOL && c.bbox.x2 <= l.bbox.x2 + SHADE_CLIP_TOL && c.bbox.y1 >= l.bbox.y1 - SHADE_CLIP_TOL && c.bbox.y2 <= l.bbox.y2 + SHADE_CLIP_TOL && c.colXs.every((x) => l.colXs.some((lx) => near(lx, x))) && clipGrids.reduce((s, o) => s + inter(o.bbox, l.bbox), 0) <= area(l.bbox) * SHADE_CLIP_MAX_AREA);
+    return !host;
+  });
+}
 function enforceMinWidth(colXs, minWidth) {
   if (colXs.length <= 2) return colXs;
   const result = [colXs[0]];
@@ -960,20 +1047,25 @@ 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 STRADDLE_MIN = 0.1;
 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 +1076,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 +1102,8 @@ function edgeStroked(lines, dir, pos, a1, a2) {
   }
   return false;
 }
-function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, textPoints = []) {
+var CONT_X_TOL = 0.1;
+function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, textPoints = [], fillRects = [], prev = { lastCells: [], clips: [] }) {
   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 = [];
@@ -1019,17 +1112,55 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     if (pageArea > 0 && (r.x2 - r.x1) * (r.y2 - r.y1) >= pageArea * CLIP_MAX_PAGE_FRAC) continue;
     if (!cells.some((c) => sameRect(c, r))) cells.push(r);
   }
-  if (cells.length < 1) return { grids: [], containers: [] };
+  if (cells.length < 1) return { grids: [], containers: [], page: { lastCells: [], clips: [] } };
   const parent = new Array(cells.length).fill(-1);
+  const area = (r) => (r.x2 - r.x1) * (r.y2 - r.y1);
+  const straddles = (a, b) => {
+    const ix = overlap(a.x1, a.x2, b.x1, b.x2), iy = overlap(a.y1, a.y2, b.y1, b.y2);
+    if (ix <= CLIP_EDGE_TOL || iy <= CLIP_EDGE_TOL || contains(a, b) || contains(b, a)) return false;
+    const inside = ix * iy / area(b);
+    return inside > STRADDLE_MIN && inside < 1 - STRADDLE_MIN;
+  };
+  const canParent = cells.map((a, i) => !cells.some((b, j) => i !== j && straddles(a, b)));
   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 || !canParent[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 ruledGaps = findRuledGaps(cells, parent, strokedH, strokedV);
   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) || continues(p))) return p;
+      p = parent[p];
+    }
+    return -1;
+  };
   const root = cells.map((_, i) => i);
   const find = (i) => {
     while (root[i] !== i) {
@@ -1039,14 +1170,20 @@ 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;
       }
     }
   }
+  for (const g of ruledGaps) {
+    if (tableClip[g.i] || tableClip[g.j]) continue;
+    const ra = find(g.i), rb = find(g.j);
+    if (ra !== rb) root[ra] = rb;
+  }
   const groups = /* @__PURE__ */ new Map();
   for (let i = 0; i < cells.length; i++) {
     const r = find(i);
@@ -1060,14 +1197,27 @@ 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 headY = pageHeight * (1 - HEADER_BAND);
+  const continues = (i) => {
+    if (!prev.lastCells.length || parent[i] >= 0 || tableClip[i] || isGridMember(i)) return void 0;
+    const c = cells[i];
+    const from = prev.lastCells.find((b) => Math.abs(b.x1 - c.x1) <= CONT_X_TOL && Math.abs(b.x2 - c.x2) <= CONT_X_TOL);
+    if (!from) return void 0;
+    if (prev.clips.some((k) => sameRect(k, c) && !sameRect(k, from))) return void 0;
+    if (textPoints.some((p) => p.y > c.y2 && p.y < headY)) return void 0;
+    if (cells.some((o) => o.y1 >= c.y2 - CLIP_EDGE_TOL && (o.y1 + o.y2) / 2 < headY)) return void 0;
+    return from;
+  };
+  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 from = continues(first);
+      if (!from && !loneFrame(first) && !((parentRect || onlyChild(first)) && framed(cells[first]))) continue;
       const r = cells[first];
       grids.push({
         rowYs: [r.y2, r.y1],
@@ -1075,11 +1225,13 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
         bbox: { x1: r.x1, y1: r.y1, x2: r.x2, y2: r.y2 },
         vertexRadius: 1,
         cells: [{ row: 0, col: 0, rowSpan: 1, colSpan: 1, bbox: { x1: r.x1, y1: r.y1, x2: r.x2, y2: r.y2 } }],
-        ...parentRect ? { clipParent: parentRect } : {}
+        ...parentRect ? { clipParent: parentRect } : {},
+        ...from ? { continues: from } : {}
       });
       continue;
     }
-    const members = idxs.map((i) => cells[i]);
+    const gs = ruledGaps.filter((g) => find(g.i) === find(first));
+    const members = gs.length ? closeGaps(idxs.map((i) => cells[i]), gs) : idxs.map((i) => cells[i]);
     let edges = 0, invisible = 0;
     for (const r of members) {
       edges += 4;
@@ -1111,19 +1263,178 @@ 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 } : {}
     });
   }
-  return { grids, containers };
+  const tops = grids.filter((g) => !g.clipParent).flatMap((g) => g.cells.filter((c) => !c.filler).map((c) => c.bbox));
+  let lastCells = [];
+  if (tops.length) {
+    const bottom = Math.min(...tops.map((b) => b.y1));
+    const footY = pageHeight * HEADER_BAND;
+    const below = (y) => y < bottom - CLIP_EDGE_TOL && y > footY;
+    if (!textPoints.some((p) => below(p.y)) && !cells.some((o) => o.y2 < bottom && below((o.y1 + o.y2) / 2))) {
+      lastCells = tops.filter((b) => Math.abs(b.y1 - bottom) <= CLIP_COORD_TOL && !cells.some((k) => Math.abs(k.x1 - b.x1) <= CONT_X_TOL && Math.abs(k.x2 - b.x2) <= CONT_X_TOL && k.y2 > b.y2 + CLIP_EDGE_TOL && contains(k, b)));
+    }
+  }
+  return { grids, containers, page: { lastCells, clips: cells } };
+}
+var CLIP_SPACING_MAX = 3;
+function findRuledGaps(cells, parent, strokedH, strokedV) {
+  const al = (u, v) => Math.abs(u - v) <= CLIP_COORD_TOL;
+  const occupied = (i, j, x1, y1, x2, y2) => cells.some((k, n) => n !== i && n !== j && parent[n] === parent[i] && overlap(k.x1, k.x2, x1, x2) > CLIP_ADJ_GAP && overlap(k.y1, k.y2, y1, y2) > CLIP_ADJ_GAP);
+  const gapBetween = (i, j) => {
+    const a = cells[i], b = cells[j];
+    const gv = a.y1 - b.y2;
+    if (gv > CLIP_ADJ_GAP && gv <= CLIP_SPACING_MAX && overlap(a.x1, a.x2, b.x1, b.x2) > CLIP_EDGE_TOL && (al(a.x1, b.x1) || al(a.x2, b.x2)) && !occupied(i, j, Math.max(a.x1, b.x1), b.y2, Math.min(a.x2, b.x2), a.y1)) {
+      const e1 = Math.max(a.x1, b.x1), e2 = Math.min(a.x2, b.x2);
+      return { i, j, axis: "y", lo: b.y2, hi: a.y1, e1, e2, to: ruleEnd(strokedH, "h", b.y2, a.y1, e1, e2) };
+    }
+    const gh = b.x1 - a.x2;
+    if (gh > CLIP_ADJ_GAP && gh <= CLIP_SPACING_MAX && overlap(a.y1, a.y2, b.y1, b.y2) > CLIP_EDGE_TOL && (al(a.y1, b.y1) || al(a.y2, b.y2)) && !occupied(i, j, a.x2, Math.max(a.y1, b.y1), b.x1, Math.min(a.y2, b.y2))) {
+      const e1 = Math.max(a.y1, b.y1), e2 = Math.min(a.y2, b.y2);
+      return { i, j, axis: "x", lo: a.x2, hi: b.x1, e1, e2, to: ruleEnd(strokedV, "v", a.x2, b.x1, e1, e2) };
+    }
+    return void 0;
+  };
+  const ruled = (g) => (g.axis === "y" ? strokedH : strokedV).some((l) => {
+    const pos = g.axis === "y" ? l.y1 : l.x1;
+    return (Math.abs(pos - g.lo) <= 0.5 || Math.abs(pos - g.hi) <= 0.5) && (g.axis === "y" ? overlap(l.x1, l.x2, g.e1, g.e2) : overlap(l.y1, l.y2, g.e1, g.e2)) >= (g.e2 - g.e1) * STROKE_COVER;
+  });
+  const root = cells.map((_, i) => i);
+  const find = (i) => {
+    while (root[i] !== i) {
+      root[i] = root[root[i]];
+      i = root[i];
+    }
+    return i;
+  };
+  const found = [];
+  const widths = /* @__PURE__ */ new Map();
+  const link = (g) => {
+    found.push(g);
+    const ri = find(g.i), rj = find(g.j);
+    const w = [...widths.get(rj) ?? [], ...ri !== rj ? widths.get(ri) ?? [] : [], { axis: g.axis, w: g.hi - g.lo }];
+    root[ri] = rj;
+    widths.set(rj, w);
+  };
+  const cand = [];
+  for (let i = 0; i < cells.length; i++) {
+    for (let j = 0; j < cells.length; j++) {
+      if (i === j || parent[i] !== parent[j]) continue;
+      const g = gapBetween(i, j);
+      if (!g) continue;
+      const a = cells[i], b = cells[j];
+      const both = g.axis === "y" ? al(a.x1, b.x1) && al(a.x2, b.x2) : al(a.y1, b.y1) && al(a.y2, b.y2);
+      const isRuled = ruled(g);
+      if (both && isRuled) link(g);
+      else if (both || isRuled) cand.push([g, both]);
+    }
+  }
+  if (!found.length) return [];
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (let k = cand.length - 1; k >= 0; k--) {
+      const [g, both] = cand[k], w = g.hi - g.lo;
+      if (![find(g.i), find(g.j)].some((r) => (widths.get(r) ?? []).some((s) => (both || s.axis === g.axis) && Math.abs(s.w - w) <= CLIP_COORD_TOL))) continue;
+      link(g);
+      cand.splice(k, 1);
+      grew = true;
+    }
+  }
+  return found;
+}
+function ruleEnd(lines, dir, lo, hi, e1, e2) {
+  const at = (p) => lines.some((l) => Math.abs((dir === "h" ? l.y1 : l.x1) - p) <= 0.5 && (dir === "h" ? overlap(l.x1, l.x2, e1, e2) : overlap(l.y1, l.y2, e1, e2)) >= (e2 - e1) * STROKE_COVER);
+  const atLo = at(lo), atHi = at(hi);
+  return atLo && !atHi ? lo : atHi && !atLo ? hi : (lo + hi) / 2;
+}
+function closeGaps(members, gaps) {
+  const al = (u, v) => Math.abs(u - v) <= CLIP_COORD_TOL;
+  const lines = [];
+  for (const g of gaps) {
+    const l = lines.find((k) => k.axis === g.axis && al(k.lo, g.lo) && al(k.hi, g.hi));
+    if (l) {
+      l.e1 = Math.min(l.e1, g.e1);
+      l.e2 = Math.max(l.e2, g.e2);
+    } else lines.push({ ...g });
+  }
+  const out = members.map((r) => ({ ...r }));
+  for (const l of lines) {
+    const shared = (p) => members.some((u) => members.some((v) => u !== v && (l.axis === "y" ? Math.abs(u.y1 - v.y2) <= CLIP_ADJ_GAP && al(u.y1, p) && overlap(u.x1, u.x2, v.x1, v.x2) > CLIP_EDGE_TOL : Math.abs(u.x2 - v.x1) <= CLIP_ADJ_GAP && al(u.x2, p) && overlap(u.y1, u.y2, v.y1, v.y2) > CLIP_EDGE_TOL)));
+    const atLo = shared(l.lo), atHi = shared(l.hi);
+    const to = atLo && !atHi ? l.lo : atHi && !atLo ? l.hi : l.to;
+    const onEdge = (r) => l.axis === "y" ? al(r.y2, l.lo) || al(r.y1, l.hi) : al(r.x2, l.lo) || al(r.x1, l.hi);
+    const span = (r) => l.axis === "y" ? [r.x1, r.x2] : [r.y1, r.y2];
+    const take = /* @__PURE__ */ new Set();
+    for (let grew = true; grew; ) {
+      grew = false;
+      for (let n = 0; n < members.length; n++) {
+        if (take.has(n) || !onEdge(members[n])) continue;
+        const [a1, a2] = span(members[n]);
+        if (overlap(a1, a2, l.e1, l.e2) <= -(CLIP_SPACING_MAX + CLIP_COORD_TOL)) continue;
+        take.add(n);
+        l.e1 = Math.min(l.e1, a1);
+        l.e2 = Math.max(l.e2, a2);
+        grew = true;
+      }
+    }
+    for (const n of take) {
+      const r = members[n], s = out[n];
+      if (l.axis === "y") {
+        if (al(r.y2, l.lo)) s.y2 = to;
+        if (al(r.y1, l.hi)) s.y1 = to;
+      } else {
+        if (al(r.x2, l.lo)) s.x2 = to;
+        if (al(r.x1, l.hi)) s.x1 = to;
+      }
+    }
+  }
+  return out;
+}
+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;
@@ -1241,6 +1552,165 @@ function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
   return false;
 }
 
+// src/pdf/line-wrap.ts
+var MARKUP = /<\/?u>|~~/g;
+var bump = (m, k) => {
+  m.set(k, (m.get(k) ?? 0) + 1);
+};
+var pairKey = (a, b) => a * 65536 + b;
+var bump2 = (m, k1, k2) => {
+  let inner = m.get(k1);
+  if (!inner) m.set(k1, inner = /* @__PURE__ */ new Map());
+  bump(inner, k2);
+};
+var WrapLexicon = class {
+  joined1 = /* @__PURE__ */ new Map();
+  joined2 = /* @__PURE__ */ new Map();
+  spaced1 = /* @__PURE__ */ new Map();
+  spaced2 = /* @__PURE__ */ new Map();
+  /** 줄 안(줄 첫·끝 어절 제외 — 꺾인 조각일 수 있다) 홀로 선 어절 수 — 한 음절 조각이 낱말("등"·"및"·"그")인지 가른다 */
+  words = /* @__PURE__ */ new Map();
+  /** 줄 글 한 줄을 증거로 더한다 — 탭(큰 갭)으로 나뉜 조각은 다른 칸·단이라 조각 사이는 어절 경계 증거로 쓰지 않는다 */
+  addLine(text) {
+    for (const seg of text.replace(MARKUP, "").split("	")) {
+      const toks = seg.split(" ").filter((t) => t && !t.includes("]("));
+      for (let i = 0; i < toks.length; i++) {
+        const t = toks[i], n = t.length;
+        if (i > 0 && i < toks.length - 1) bump(this.words, t);
+        for (let a = 0; a + 1 < n; a++) {
+          const c1 = t.charCodeAt(a), c2 = t.charCodeAt(a + 1);
+          bump(this.joined1, pairKey(c1, c2));
+          if (a >= 1 && a + 2 < n) bump2(this.joined2, pairKey(t.charCodeAt(a - 1), c1), pairKey(c2, t.charCodeAt(a + 2)));
+        }
+        if (i + 1 < toks.length) {
+          const u = toks[i + 1];
+          bump(this.spaced1, pairKey(t.charCodeAt(n - 1), u.charCodeAt(0)));
+          if (n >= 2 && u.length >= 2) bump2(this.spaced2, pairKey(t.charCodeAt(n - 2), t.charCodeAt(n - 1)), pairKey(u.charCodeAt(0), u.charCodeAt(1)));
+        }
+      }
+    }
+  }
+  /** 문서 줄 안에서 홀로 선 어절로 나온 적 있나 */
+  isWord(word) {
+    return (this.words.get(word) ?? 0) > 0;
+  }
+  /** 꺾인 자리 증거: "" 붙음 · " " 띄움 · null 모름 (두 글자 증거가 갈리거나 없으면 한 글자) */
+  evidence(left, right) {
+    const n = left.length;
+    if (n >= 2 && right.length >= 2) {
+      const k1 = pairKey(left.charCodeAt(n - 2), left.charCodeAt(n - 1)), k2 = pairKey(right.charCodeAt(0), right.charCodeAt(1));
+      const v = decideCounts(this.joined2.get(k1)?.get(k2) ?? 0, this.spaced2.get(k1)?.get(k2) ?? 0);
+      if (v !== null) return v;
+    }
+    if (n && right.length) {
+      const k = pairKey(left.charCodeAt(n - 1), right.charCodeAt(0));
+      return decideCounts(this.joined1.get(k) ?? 0, this.spaced1.get(k) ?? 0);
+    }
+    return null;
+  }
+};
+var decideCounts = (joined, spaced) => joined && !spaced ? "" : spaced && !joined ? " " : null;
+var hasBatchim = (c) => {
+  const k = c.charCodeAt(0) - 44032;
+  return k >= 0 && k < 11172 && k % 28 !== 0;
+};
+var CLOSE_TAIL = /[’”」』)\]〉》>]+$/;
+var TAIL = "[.,)\u300D\u300F\u2019\u201D]*";
+var PARTICLE = new RegExp(`^(?:\uB2E4\\.|\uC758|\uC5D0|\uC5D0\uC11C|\uC5D0\uB294|\uC5D0\uAC8C|\uC5D0\uB3C4|\uC5D0\uC11C\uB294|\uAE4C\uC9C0|\uBD80\uD130|\uCC98\uB7FC|\uB9C8\uB2E4|\uB9CC|\uB3C4|\uB4E4|\uB4E4\uC774|\uB4E4\uC758|\uB4E4\uC740|\uB4E4\uC744|\uB4E4\uC5D0\uAC8C|\uC11C\uB294|\uC11C\uB3C4|\uB77C\uACE0|\uB77C\uBA70|\uC740|\uB294|\uC744|\uB97C|\uC73C\uB85C|\uB85C|\uC73C\uB85C\uC11C|\uB85C\uC11C|\uC73C\uB85C\uC368|\uB85C\uC368)${TAIL}$`);
+var PARTICLE_AFTER_CONS = new RegExp(`^(?:\uC774|\uACFC|\uC774\uB2E4|\uC774\uBA70|\uC774\uACE0|\uC774\uB098|\uC774\uB77C\uB294|\uC774\uB77C\uACE0|\uC774\uB77C\uBA70)${TAIL}$`);
+var PARTICLE_AFTER_VOWEL = new RegExp(`^(?:\uAC00|\uC640|\uB77C\uB294)${TAIL}$`);
+var VERB_FORM = new RegExp(`^(?:\uD558\uB294|\uD558\uC5EC|\uD558\uACE0|\uD558\uBA70|\uD558\uC600\uB2E4|\uD558\uC600\uC73C\uBA70|\uD558\uC600\uACE0|\uD558\uC600\uB2E4\uACE0|\uD588\uB2E4|\uD588\uC73C\uBA70|\uD588\uACE0|\uD588\uB2E4\uACE0|\uD588\uB2E4\uBA70|\uD55C\uB2E4|\uD55C\uB2E4\uACE0|\uD55C\uB2E4\uBA70|\uD55C\uB2E4\uB294|\uD560|\uD568|\uD558\uACA0\uB2E4|\uD558\uACA0\uB2E4\uACE0|\uD558\uACA0\uC2B5\uB2C8\uB2E4|\uD558\uAE30\uB85C|\uD558\uBA74|\uD558\uBA74\uC11C|\uD558\uB3C4\uB85D|\uD574\uC57C|\uB418\uB294|\uB418\uC5B4|\uB41C|\uB41C\uB2E4|\uB41C\uB2E4\uACE0|\uB41C\uB2E4\uB294|\uB418\uC5C8\uB2E4|\uB418\uC5C8\uC73C\uBA70|\uB418\uC5C8\uACE0|\uB410\uB2E4|\uB410\uC73C\uBA70|\uB418\uBA70|\uB418\uACE0|\uB418\uBA74|\uB428|\uB3FC)${TAIL}$`);
+var AUX_BEFORE = /(?:야|록|로|게|도|히|자|를|을|면|서|고|며|지|라)$/;
+var BECOME = /^[되된됐됨돼]/;
+var STANDALONE_SYLLABLE = /^(?:및|등|수|것|그|이|저|더|또|각|약|총|중|간|때|뿐|듯|채|전|후|내|외|한|두|세|네|몇|새|첫|온|본|곧|꼭|잘|못|안|좀|늘|다|왜|뭐|시|할|데|뒤|된)$/;
+var DATE_DAY_END = /(?:^|\s)\d*월\s+\d*일$/;
+var COUNTER = /^(?:명|일|월|년|개|원|건|회|차|호|조|항|층|톤|대|곳|시|분|초|배|위|점|주|종|억|만|천|%|퍼센트)/;
+function endsAsWord(word) {
+  const h = word.replace(CLOSE_TAIL, "");
+  if (!/^[가-힣]{2,}$/.test(h)) return false;
+  if (/(?:을|를|는|은|히|른|할|야|게|의)$/.test(h)) return true;
+  const prev = h[h.length - 2];
+  if (/(?:이|과)$/.test(h)) return hasBatchim(prev);
+  if (/(?:가|와)$/.test(h)) return !hasBatchim(prev);
+  return false;
+}
+function particleContinues(left, right) {
+  const h = left.replace(CLOSE_TAIL, "");
+  const last = h[h.length - 1];
+  if (!last || !/[가-힣A-Za-z0-9]/.test(last)) return false;
+  if (PARTICLE.test(right)) return true;
+  if (!/[가-힣]/.test(last)) return false;
+  if (PARTICLE_AFTER_CONS.test(right)) return hasBatchim(last);
+  if (PARTICLE_AFTER_VOWEL.test(right)) return !hasBatchim(last);
+  return VERB_FORM.test(right) && !AUX_BEFORE.test(h) && !(last === "\uC774" && BECOME.test(right));
+}
+var ITEM_HEAD = /^(?:[□■◆◇○●◎◦▪▫•※▶▷►❍❏❑✓✔➢➤☞]|[①-⑳]|[-–·∙ㆍ*](?=\s)|\(?\d{1,2}[.)](?!\d)|\(?[가-하][.)]|\([가-하\d]{1,2}\)|[ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩ]|제\d+[조항호장절])/;
+function startsNewItem(prevText, nextText) {
+  const t = nextText.replace(MARKUP, "").trimStart();
+  return ITEM_HEAD.test(t) && !(/^다\./.test(t) && /[가-힣]$/.test(prevText.replace(MARKUP, "").trimEnd()));
+}
+function wrapJoiner(prevText, nextText, lex) {
+  const prev = prevText.replace(MARKUP, "").trimEnd(), next = nextText.replace(MARKUP, "").trimStart();
+  const a = prev[prev.length - 1], b = next[0];
+  if (!a || !b || /[,;:!?]/.test(a) || DATE_DAY_END.test(prev) && b !== "(") return " ";
+  let s = prev.length;
+  while (s > 0 && !/\s/.test(prev[s - 1])) s--;
+  const left = prev.slice(s), right = next.match(/^\S+/)[0];
+  if (particleContinues(left, right)) return "";
+  if (endsAsWord(left)) return " ";
+  if (/[·ㆍ‧-]/.test(a) && /[가-힣A-Za-z0-9]/.test(b)) return "";
+  if (/[A-Za-z]/.test(a) && /[A-Za-z]/.test(b) || /\d/.test(a) && /\d/.test(b)) return " ";
+  const ev = lex?.evidence(left, right);
+  if (ev != null) return ev;
+  if (/\d$/.test(left) && COUNTER.test(right)) return "";
+  if (lex && /^[가-힣]$/.test(left) && /^[가-힣]/.test(right) && !STANDALONE_SYLLABLE.test(left) && ([...right].length === 1 || !lex.isWord(left))) return "";
+  const r1 = right.replace(/[.,)」』’”]+$/, "");
+  if (lex && /[가-힣]$/.test(left) && /^[가-힣]$/.test(r1) && !STANDALONE_SYLLABLE.test(r1) && !lex.isWord(r1) && !lex.isWord(right)) return "";
+  return " ";
+}
+var PARA_LAST_LINE = /* @__PURE__ */ new WeakMap();
+function joinPageBreakWraps(blocks, lex) {
+  const pageRight = /* @__PURE__ */ new Map();
+  for (const b of blocks) {
+    if (b.type !== "paragraph" || !b.bbox || !b.pageNumber) continue;
+    pageRight.set(b.pageNumber, Math.max(pageRight.get(b.pageNumber) ?? -Infinity, b.bbox.x + b.bbox.width));
+  }
+  for (let i = blocks.length - 1; i > 0; i--) {
+    const a = blocks[i - 1], b = blocks[i];
+    if (!a.pageNumber || b.pageNumber !== a.pageNumber + 1 || !a.text || !b.text) continue;
+    if (a.type !== "paragraph" && a.type !== "list" || b.type !== "paragraph") continue;
+    const last = a.bbox && PARA_LAST_LINE.get(a.bbox), fs = last ? last.fontSize : 0;
+    if (!last || fs <= 0 || (pageRight.get(a.pageNumber) ?? Infinity) - last.right >= BODY_FULL_TOL * fs) continue;
+    if (last.width < BODY_MIN_WIDTH_EM * fs || Math.abs((b.style?.fontSize ?? 0) - fs) > 0.15 * fs) continue;
+    if (startsNewItem(a.text, b.text)) continue;
+    a.text += wrapJoiner(a.text, b.text, lex) + b.text;
+    const bl = b.bbox && PARA_LAST_LINE.get(b.bbox);
+    if (bl) PARA_LAST_LINE.set(a.bbox, bl);
+    else PARA_LAST_LINE.delete(a.bbox);
+    blocks.splice(i, 1);
+  }
+}
+var BODY_FULL_TOL = 0.25;
+var BODY_MIN_WIDTH_EM = 12;
+var BODY_MAX_PITCH_EM = 2;
+function bodyLineJoins(lines, lex) {
+  let right = -Infinity;
+  for (const l of lines) if (l.right > right) right = l.right;
+  const out = [];
+  for (let i = 0; i + 1 < lines.length; i++) {
+    const a = lines[i], b = lines[i + 1];
+    const fs = a.fontSize;
+    const wraps = fs > 0 && right - a.right < BODY_FULL_TOL * fs && a.right - a.left >= BODY_MIN_WIDTH_EM * fs && a.y - b.y > 0 && a.y - b.y < BODY_MAX_PITCH_EM * fs && Math.abs(b.fontSize - fs) <= 0.15 * fs && !startsNewItem(a.text, b.text);
+    out.push(wraps ? wrapJoiner(a.text, b.text, lex) : "\n");
+  }
+  return out;
+}
+var CELL_PAD_MAX = 6;
+function cellLineWraps(box, contentLeft, prevRight, fontSize, nextFirstCharW) {
+  const pad = Math.min(CELL_PAD_MAX, Math.max(0, contentLeft - box.x1));
+  return fontSize > 0 && prevRight + nextFirstCharW - (box.x2 - pad) > 0.5 * fontSize;
+}
+
 // src/pdf/cell-text.ts
 var CELL_PADDING = 2;
 var SPACE_GAP_RATIO = 0.17;
@@ -1274,9 +1744,47 @@ function mapTextToCells(items, cells) {
       result.get(bestCell).push(item);
     }
   }
+  keepWordsInOneCell(result);
   return result;
 }
-function cellTextToString(items) {
+function keepWordsInOneCell(result) {
+  const owner = /* @__PURE__ */ new Map();
+  for (const [cell, arr] of result) for (const it of arr) owner.set(it, cell);
+  if (result.size < 2 || owner.size < 2) return;
+  const all = [...owner.keys()].sort((a, b) => b.y - a.y || a.x - b.x);
+  for (let i = 0; i < all.length; ) {
+    let j = i + 1;
+    while (j < all.length && Math.abs(all[j].y - all[i].y) <= 1) j++;
+    const line = all.slice(i, j).sort((a, b) => a.x - b.x);
+    for (let k = 0; k < line.length; ) {
+      let e = k + 1;
+      while (e < line.length && !line[e].hasSpaceBefore && line[e].x - (line[e - 1].x + line[e - 1].w) <= spaceGapThreshold((line[e].fontSize + line[e - 1].fontSize) / 2)) e++;
+      const word = line.slice(k, e);
+      const width = /* @__PURE__ */ new Map();
+      for (const it of word) {
+        const c = owner.get(it);
+        width.set(c, (width.get(c) ?? 0) + it.w);
+      }
+      const crosses = word.some((it) => {
+        const b = owner.get(it).bbox;
+        return it.x < b.x1 - 1 || it.x + it.w > b.x2 + 1;
+      });
+      if (width.size > 1 && crosses) {
+        const target = [...width].sort((a, b) => b[1] - a[1])[0][0];
+        for (const it of word) {
+          const c = owner.get(it);
+          if (c === target) continue;
+          result.set(c, result.get(c).filter((x) => x !== it));
+          result.get(target).push(it);
+          owner.set(it, target);
+        }
+      }
+      k = e;
+    }
+    i = j;
+  }
+}
+function cellTextToString(items, wrap) {
   if (items.length === 0) return "";
   if (items.length === 1) return items[0].text;
   const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
@@ -1296,7 +1804,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;
@@ -1317,7 +1825,18 @@ function cellTextToString(items) {
     }
     return result;
   });
-  return mergeCellTextLines(textLines);
+  if (!wrap) return mergeCellTextLines(textLines);
+  let contentLeft = Infinity;
+  for (const it of items) if (it.x < contentLeft) contentLeft = it.x;
+  const lineEnds = merged.map((line) => {
+    const s = sortLineByX(line);
+    let right = -Infinity;
+    for (const it of s) if (it.x + it.w > right) right = it.x + it.w;
+    const first = s[0];
+    return { right, fontSize: first.fontSize, firstCharW: first.w / Math.max(1, [...first.text].length) };
+  });
+  const wraps = lineEnds.slice(0, -1).map((a, i) => cellLineWraps(wrap.box, contentLeft, a.right, a.fontSize, lineEnds[i + 1].firstCharW));
+  return mergeCellTextLines(textLines, { wraps, lex: wrap.lex });
 }
 function mergeSuperscriptRows(lines) {
   if (lines.length <= 1) return lines;
@@ -1406,19 +1925,19 @@ function markEvenRun(items, result, start, end) {
     }
   }
 }
-function mergeCellTextLines(textLines) {
+function mergeCellTextLines(textLines, wrap) {
   if (textLines.length <= 1) return textLines[0] || "";
   const merged = [textLines[0]];
   for (let i = 1; i < textLines.length; i++) {
     const prev = merged[merged.length - 1];
     const curr = textLines[i];
-    if (/[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 8 && !curr.includes(" ")) {
+    if (wrap ? wrap.wraps[i - 1] && !startsNewItem(prev, curr) && wrapJoiner(prev, curr, wrap.lex) === "" : /[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 8 && !curr.includes(" ")) {
       merged[merged.length - 1] = prev + curr;
     } else if (curr.trim().length <= 3 && /^[)\]%}]/.test(curr.trim())) {
       merged[merged.length - 1] = prev + curr.trim();
-    } else if (/[,(]$/.test(prev.trim()) && curr.trim().length <= 15) {
+    } else if (!wrap && /[,(]$/.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,\d{3}$/.test(prev) && /^\d/.test(curr.trim())) && !(/(?:^|[^\d,])\d{1,3}$/.test(prev) && /^(\d{1,3}(,\d{3})+|\d{1,3})$/.test(curr.trim()))) {
       merged[merged.length - 1] = prev + curr.trim();
     } else {
       merged.push(curr);
@@ -1538,11 +2057,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 +2137,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 +2159,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);
@@ -1647,6 +2181,7 @@ function normalizeItems(rawItems) {
     }
     if (!isDup) deduped.push(sorted[i]);
   }
+  splitOverlaidRuns(deduped);
   if (spacePositions.length > 0) {
     for (const sp of spacePositions) {
       let nearest = null;
@@ -1662,6 +2197,98 @@ function normalizeItems(rawItems) {
   }
   return deduped;
 }
+var WORD_SPACE_EM = 0.3;
+var OVERLAY_DUP_EM = 0.5;
+var OVERLAY_FIT_EM = 0.6;
+function glyphUnits(s) {
+  let u = 0;
+  for (const ch of s) u += (ch.codePointAt(0) ?? 0) >= 8592 ? 1 : 0.5;
+  return u;
+}
+function splitOverlaidRuns(items) {
+  let replaced = null;
+  for (let ci = 0; ci < items.length; ci++) {
+    const c = items[ci];
+    if (c.w <= 0 || !/\S\s+\S/.test(c.text)) continue;
+    const overlays = [];
+    for (let j = ci - 1; j >= 0 && items[j].y - c.y <= 1; j--) if (isInside(items[j], c)) overlays.push(items[j]);
+    for (let j = ci + 1; j < items.length && c.y - items[j].y <= 1; j++) if (isInside(items[j], c)) overlays.push(items[j]);
+    if (overlays.length === 0) continue;
+    const pieces = splitAroundOverlays(c, overlays);
+    if (pieces) (replaced ??= /* @__PURE__ */ new Map()).set(c, pieces);
+  }
+  if (!replaced) return;
+  const out = [];
+  for (const it of items) {
+    const p = replaced.get(it);
+    if (p) out.push(...p);
+    else out.push(it);
+  }
+  items.length = 0;
+  items.push(...out.sort((a, b) => b.y - a.y || a.x - b.x));
+}
+function isInside(o, c) {
+  return o.x >= c.x + 1 && o.x + o.w <= c.x + c.w + 1 && o.w < c.w;
+}
+function splitAroundOverlays(c, overlays) {
+  const words = c.text.split(/\s+/);
+  const fs = c.fontSize > 0 ? c.fontSize : c.h > 0 ? c.h : 10;
+  const ws = WORD_SPACE_EM * fs;
+  const totalU = words.reduce((s, w) => s + glyphUnits(w), 0);
+  if (totalU <= 0) return null;
+  const a0 = (c.w - (words.length - 1) * ws) / totalU;
+  const ov = overlays.filter((o) => {
+    for (let at = c.text.indexOf(o.text); at >= 0; at = c.text.indexOf(o.text, at + 1)) {
+      const prefix = c.text.slice(0, at);
+      const est = c.x + glyphUnits(prefix.replace(/\s+/g, "")) * a0 + (prefix.match(/\s+/g)?.length ?? 0) * ws;
+      if (Math.abs(est - o.x) <= OVERLAY_DUP_EM * fs) return false;
+    }
+    return true;
+  }).sort((p2, q) => p2.x - q.x);
+  if (ov.length === 0) return null;
+  const holes = Math.min(ov.length, words.length - 1);
+  let ovW = 0;
+  for (const o of ov) ovW += o.w;
+  const a = (c.w - ovW - (words.length - 1 - holes) * ws) / totalU;
+  if (!(a > 0)) return null;
+  const starts = [], ends = [], holeAfter = [];
+  let p = c.x;
+  let k = 0;
+  let assigned = 0;
+  for (let i = 0; i < words.length; i++) {
+    starts.push(p);
+    p += glyphUnits(words[i]) * a;
+    ends.push(p);
+    if (i === words.length - 1) break;
+    while (k < ov.length && ov[k].x < p - a * 0.6) k++;
+    const half = glyphUnits(words[i + 1]) * a / 2;
+    let hole = false;
+    while (k < ov.length && ov[k].x < p + half) {
+      hole = true;
+      p = Math.max(p, ov[k].x + ov[k].w);
+      k++;
+    }
+    holeAfter.push(hole);
+    if (hole) assigned++;
+    else p += ws;
+  }
+  if (assigned === 0 || Math.abs(p - (c.x + c.w)) > Math.max(3, OVERLAY_FIT_EM * fs)) return null;
+  const pieces = [];
+  for (let s = 0; s < words.length; ) {
+    let e = s;
+    while (e < words.length - 1 && !holeAfter[e]) e++;
+    pieces.push({
+      ...c,
+      text: words.slice(s, e + 1).join(" "),
+      x: Math.round(starts[s]),
+      w: Math.max(1, Math.round(ends[e] - starts[s])),
+      hasSpaceBefore: s === 0 ? c.hasSpaceBefore : false,
+      seq: c.seq === void 0 ? void 0 : c.seq + pieces.length / 1e4
+    });
+    s = e + 1;
+  }
+  return pieces;
+}
 function splitEvenSpacedItem(text, itemX, itemW, fontSize) {
   if (!/^[가-힣\d](?: [가-힣\d]){2,}$/.test(text)) return null;
   const chars = text.split(" ");
@@ -1727,7 +2354,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 +2772,53 @@ 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 CONT_PARTS = /* @__PURE__ */ new WeakMap();
+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 +2915,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;
@@ -2662,7 +3334,7 @@ function buildClusterTable(rows, columns, pageNum) {
     }
     const assignments = assignRowItems(row.items, columns, numCols);
     for (const { col, items } of assignments) {
-      const text = items.map((i) => i.text).join(" ");
+      const text = joinCellItems(items);
       const existing = cells[r][col].text;
       cells[r][col].text = existing ? existing + " " + text : text;
       for (const item of items) usedItems.add(item);
@@ -2685,6 +3357,7 @@ function buildClusterTable(rows, columns, pageNum) {
     if (/^[○●▶\-·]/.test(contentText)) continue;
     for (let pr = r - 1; pr >= 0; pr--) {
       if (cells[pr].some((c) => c.text.trim())) {
+        if (cells[pr][0].colSpan > 1) break;
         for (let c = 0; c < numCols; c++) {
           const prev = cells[pr][c].text.trim();
           const curr = cells[r][c].text.trim();
@@ -2735,6 +3408,29 @@ function buildClusterTable(rows, columns, pageNum) {
     usedItems
   };
 }
+function joinCellItems(items) {
+  const hOf = (i) => i.h > 0 ? i.h : i.fontSize;
+  const lines = [];
+  for (const it of [...items].sort((a, b) => b.y - a.y || a.x - b.x)) {
+    const bottom = it.y, top = it.y + hOf(it);
+    const line = lines.find((l) => Math.min(l.top, top) - Math.max(l.bottom, bottom) >= Math.min(l.top - l.bottom, top - bottom) * 0.5);
+    if (line) {
+      line.items.push(it);
+      line.bottom = Math.min(line.bottom, bottom);
+      line.top = Math.max(line.top, top);
+    } else lines.push({ bottom, top, items: [it] });
+  }
+  return lines.sort((a, b) => b.top - a.top).map(({ items: line }) => {
+    line.sort((a, b) => a.x - b.x);
+    let s = line[0].text;
+    for (let i = 1; i < line.length; i++) {
+      const gap = line[i].x - (line[i - 1].x + line[i - 1].w);
+      const fs = (line[i].fontSize + line[i - 1].fontSize) / 2;
+      s += (line[i].hasSpaceBefore && gap >= fs * 0.05 || gap > spaceGapThreshold(fs) ? " " : "") + line[i].text;
+    }
+    return s;
+  }).join(" ");
+}
 
 // src/pdf/xy-cut.ts
 var MAX_XYCUT_DEPTH = 50;
@@ -3067,7 +3763,10 @@ function detectColumns(yLines) {
   const xClusters = [];
   for (const line of tableYLines) {
     if (isProseSpread(line)) continue;
-    for (const item of line) {
+    const byX = [...line].sort((a, b) => a.x - b.x);
+    for (let k = 0; k < byX.length; k++) {
+      const item = byX[k];
+      if (k > 0 && item.x - (byX[k - 1].x + byX[k - 1].w) < Math.max(item.fontSize, byX[k - 1].fontSize)) continue;
       let found = false;
       for (const c of xClusters) {
         if (Math.abs(item.x - c.center) <= CLUSTER_TOL) {
@@ -3372,12 +4071,26 @@ function wrapUnderlineRuns(items) {
 }
 
 // src/pdf/page-blocks.ts
-function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight, extraLines, detectTables = true) {
-  if (items.length === 0) return [];
+function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight, extraLines, detectTables = true, carry, lexicon) {
+  if (items.length === 0) {
+    if (carry) carry.clip = void 0;
+    return [];
+  }
+  const lex = lexicon ?? new WrapLexicon();
+  for (const line of streamLines(items)) lex.addLine(mergeLineSimple(line));
   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 prevPage = carry?.page === pageNum - 1 ? carry.clip : void 0;
+  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, prevPage) : { grids: [], containers: [], page: void 0 };
+  if (carry) {
+    carry.page = pageNum;
+    carry.clip = clipResult.page;
+  }
   const clipGrids = clipResult.grids;
+  if (clipGrids.length === 0) {
+    horizontals = chainShortSegments(horizontals, extracted.shortH, "h");
+    verticals = chainShortSegments(verticals, extracted.shortV, "v");
+  }
   if (extraLines) {
     horizontals = horizontals.concat(extraLines.horizontals);
     verticals = verticals.concat(extraLines.verticals);
@@ -3392,11 +4105,13 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   markUnderlineItems(items, horizontals, verticals);
   wrapUnderlineRuns(items);
   const lineGrids = detectTables ? buildTableGrids(horizontals, verticals) : [];
-  const grids = [...clipGrids, ...dropGridsInside(lineGrids, clipGrids, clipResult.containers)];
+  const tableClipGrids = dropShadingClipGrids(clipGrids, lineGrids, extracted.fillRects, verticals);
+  const grids = [...tableClipGrids, ...dropGridsInside(lineGrids, tableClipGrids, 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, lex);
   }
-  return extractPageBlocksFallback(items, pageNum, true, detectTables);
+  return extractPageBlocksFallback(items, pageNum, true, detectTables, lex);
 }
 var STRIKE_MAX_THICKNESS = 2;
 var STRIKE_MAX_THICKNESS_RATIO = 0.25;
@@ -3505,13 +4220,13 @@ function takePendingNested(pending, cellBox) {
   }
   return out;
 }
-function buildFrameCellBlocks(cellItems, nested, pageNum) {
+function buildFrameCellBlocks(cellItems, nested, pageNum, wrap) {
   const tables = [...nested].sort((a, b) => b.bbox.y + b.bbox.height - (a.bbox.y + a.bbox.height));
   const blocks = [];
   let rest = [...cellItems];
   const pushParagraphs = (items) => {
     if (items.length === 0) return;
-    for (const line of cleanCellText(cellTextToString(items)).split("\n")) {
+    for (const line of cleanCellText(cellTextToString(items, wrap)).split("\n")) {
       const t = line.trim();
       if (t) blocks.push({ type: "paragraph", text: t, pageNumber: pageNum });
     }
@@ -3526,7 +4241,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 = [], lex) {
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
   const pendingNested = [];
@@ -3558,7 +4273,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();
@@ -3575,20 +4291,31 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       const nested = grid.cells ? takePendingNested(pendingNested, cell.bbox) : [];
       if (nested.length > 0) {
         nestedAttached = true;
-        const built = buildFrameCellBlocks(cellItems, nested, pageNum);
+        const built = buildFrameCellBlocks(cellItems, nested, pageNum, { box: cell.bbox, lex });
         irGrid[cell.row][cell.col] = { text: built.text, colSpan: cell.colSpan, rowSpan: cell.rowSpan, blocks: built.blocks };
+        if (cellItems.length) recordCellLines(irGrid[cell.row][cell.col], cellItems);
         continue;
       }
       irGrid[cell.row][cell.col] = {
-        text: cleanCellText(cellTextToString(cellItems)),
+        text: cleanCellText(cellTextToString(cellItems, { box: cell.bbox, lex })),
         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 +4334,12 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       cells: finalGrid,
       hasHeader: finalRows > 1
     };
+    TABLE_COLXS.set(irTable, grid.colXs);
+    if (grid.continues) CONT_PARTS.set(irTable, grid.continues);
     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 +4364,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 +4402,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);
   }
@@ -3690,7 +4422,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
         if (side.length === 0) continue;
         for (const group of xyCutOrder(side, gapThreshold)) {
           if (group.length === 0) continue;
-          const groupBlocks = extractPageBlocksFallback(group, pageNum);
+          const groupBlocks = extractPageBlocksFallback(group, pageNum, false, true, lex);
           for (const b of groupBlocks) textBlocks.push(b);
           groupSizes.push(groupBlocks.length);
         }
@@ -3703,7 +4435,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       const textBlocks = [];
       for (const group of groups) {
         if (group.length === 0) continue;
-        const groupBlocks = extractPageBlocksFallback(group, pageNum);
+        const groupBlocks = extractPageBlocksFallback(group, pageNum, false, true, lex);
         for (const b of groupBlocks) textBlocks.push(b);
         groupSizes.push(groupBlocks.length);
       }
@@ -3747,53 +4479,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,
@@ -3853,7 +4545,42 @@ function splitTwoColumnProse(items, cutX) {
   }
   return groups;
 }
-function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTables = true) {
+function streamLines(items) {
+  if (items.some((i) => i.seq === void 0)) return groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x));
+  const lines = [];
+  let cur = [];
+  for (const it of [...items].sort((a, b) => a.seq - b.seq)) {
+    const last = cur[cur.length - 1];
+    if (last && (Math.abs(it.y - last.y) > 3 || it.x < last.x - 1 || it.x - (last.x + last.w) > Math.max(2 * it.fontSize, 30))) {
+      lines.push(cur);
+      cur = [];
+    }
+    cur.push(it);
+  }
+  if (cur.length) lines.push(cur);
+  return lines;
+}
+function pushLineParagraphs(out, yLines, pageNum, lex) {
+  const lines = yLines.map((items) => ({ items, text: mergeLineSimple(items) })).filter((l) => l.text.trim());
+  const geo = lines.map((l) => {
+    const b = computeBBox(l.items, pageNum);
+    return { text: l.text, left: b.x, right: b.x + b.width, y: l.items.reduce((s, i) => s + i.y, 0) / l.items.length, fontSize: dominantStyle(l.items)?.fontSize ?? 0 };
+  });
+  const joins = bodyLineJoins(geo, lex);
+  for (let i = 0; i < lines.length; ) {
+    let text = lines[i].text;
+    const items = [...lines[i].items];
+    for (; i + 1 < lines.length && joins[i] !== "\n"; i++) {
+      text += joins[i] + lines[i + 1].text;
+      items.push(...lines[i + 1].items);
+    }
+    const block = { type: "paragraph", text, pageNumber: pageNum, bbox: computeBBox(items, pageNum), style: dominantStyle(items) };
+    PARA_LAST_LINE.set(block.bbox, { right: geo[i].right, width: geo[i].right - geo[i].left, fontSize: geo[i].fontSize });
+    out.push(block);
+    i++;
+  }
+}
+function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTables = true, lex) {
   if (items.length === 0) return [];
   const blocks = [];
   const clusterItems = items.map((i) => ({
@@ -3879,15 +4606,7 @@ function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTable
       blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
     }
     const remaining = items.filter((_, idx) => !usedIndices.has(idx));
-    if (remaining.length > 0) {
-      const yLines = mergeSuperscriptLines(groupByY(remaining));
-      for (const line of yLines) {
-        const text = mergeLineSimple(line);
-        if (!text.trim()) continue;
-        const bbox = computeBBox(line, pageNum);
-        blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
-      }
-    }
+    if (remaining.length > 0) pushLineParagraphs(blocks, mergeSuperscriptLines(groupByY(remaining)), pageNum, lex);
     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;
@@ -3918,12 +4637,7 @@ function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTable
           const bbox = computeBBox(group, pageNum);
           blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(group) });
         } else {
-          for (const line of yLines) {
-            const text = mergeLineSimple(line);
-            if (!text.trim()) continue;
-            const bbox = computeBBox(line, pageNum);
-            blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
-          }
+          pushLineParagraphs(blocks, yLines, pageNum, lex);
         }
       }
     }
@@ -3936,13 +4650,22 @@ export {
   filterHiddenText,
   collapseEvenSpacing,
   normalizeItems,
+  WrapLexicon,
+  joinPageBreakWraps,
   computeMedianFontSizeFromFreq,
   detectHeadings,
   detectMarkerHeadings,
   detectTableCaptions,
   detectKoreanListBlocks,
   removeHeaderFooterBlocks,
-  extractPageBlocksWithLines,
-  mergeCrossPageTables
+  CLIP_TABLES,
+  TABLE_COLXS,
+  EMPTY_PARTS,
+  IMAGE_CELLS,
+  FILLER_CELLS,
+  CONT_PARTS,
+  CELL_LINES,
+  trimTrailingEmptyTableCols,
+  extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-A7QC2ZVP.js.map
+//# sourceMappingURL=chunk-YT3GC62E.js.map