kordoc 4.12.0 → 4.12.2

package/dist/{chunk-MJPRWCI5.js → chunk-MUYU4JI5.js}

@@ -1,5 +1,5 @@
 // src/utils.ts
-var VERSION = true ? "4.12.0" : "0.0.0-dev";
+var VERSION = true ? "4.12.2" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -121,4 +121,4 @@ export {
   safeMax,
   classifyError
 };
-//# sourceMappingURL=chunk-MJPRWCI5.js.map
+//# sourceMappingURL=chunk-MUYU4JI5.js.map

package/dist/{chunk-SKGYPM6L.js → chunk-OEYECZGV.js}

@@ -7,7 +7,7 @@ import {
 import {
   safeMax,
   safeMin
-} from "./chunk-4PKNWBXJ.js";
+} from "./chunk-FBLMVHDK.js";
 
 // src/pdf/image-regions.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -69,6 +69,8 @@ var MAX_LINE_WIDTH = 5;
 function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
+  const clipRects = [];
+  let pendingClip = false;
   let lineWidth = 1;
   let ctm = [1, 0, 0, 1, 0, 0];
   const ctmStack = [];
@@ -98,9 +100,12 @@ function extractLines(fnArray, argsArray) {
   }
   function flushPath(isStroke, fromFill = false) {
     if (!isStroke) {
+      if (pendingClip) captureClipRect(currentPath, clipRects);
+      pendingClip = false;
       currentPath = [];
       return;
     }
+    pendingClip = false;
     const effWidth = lineWidth * ctmScale();
     for (const seg of currentPath) {
       classifyAndAdd(seg, effWidth, horizontals, verticals, fromFill);
@@ -228,9 +233,29 @@ function extractLines(fnArray, argsArray) {
       case OPS2.endPath:
         flushPath(false);
         break;
+      case OPS2.clip:
+      case OPS2.eoClip:
+        pendingClip = true;
+        break;
     }
   }
-  return { horizontals, verticals };
+  return { horizontals, verticals, clipRects };
+}
+var CLIP_MIN_W = 4;
+var CLIP_MIN_H = 2;
+function captureClipRect(path, out) {
+  if (path.length < 3 || path.length > 5) return;
+  let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+  for (const s of path) {
+    const dx = Math.abs(s.x2 - s.x1), dy = Math.abs(s.y2 - s.y1);
+    if (dx > ORIENTATION_TOL && dy > ORIENTATION_TOL) return;
+    x1 = Math.min(x1, s.x1, s.x2);
+    x2 = Math.max(x2, s.x1, s.x2);
+    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;
+  out.push({ x1, y1, x2, y2 });
 }
 function classifyAndAdd(seg, lineWidth, horizontals, verticals, fromFill = false) {
   const dx = Math.abs(seg.x2 - seg.x1);
@@ -443,9 +468,9 @@ function mergeParallelLines(lines, dir) {
       const prevEnd = dir === "h" ? prev.x2 : prev.y2;
       const currStart = dir === "h" ? curr.x1 : curr.y1;
       const currEnd = dir === "h" ? curr.x2 : curr.y2;
-      const overlap = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
+      const overlap2 = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
       const minLen = Math.min(prevEnd - prevStart, currEnd - currStart);
-      if (overlap > minLen * 0.3) {
+      if (overlap2 > minLen * 0.3) {
         if (dir === "h") {
           prev.x1 = Math.min(prev.x1, curr.x1);
           prev.x2 = Math.max(prev.x2, curr.x2);
@@ -934,6 +959,186 @@ function linesIntersect(a, b) {
   return v.x1 >= h.x1 - tol && v.x1 <= h.x2 + tol && h.y1 >= v.y1 - tol && h.y1 <= v.y2 + tol;
 }
 
+// src/pdf/clip-cells.ts
+var CLIP_EDGE_TOL = 1.5;
+var CLIP_MIN_GROUP = 2;
+var CLIP_MAX_PAGE_FRAC = 0.75;
+var CLIP_MIN_W2 = 4;
+var CLIP_MIN_H2 = 2;
+var STROKE_NEAR = 2;
+var STROKE_COVER = 0.5;
+var CLIP_MIN_INVISIBLE = 0;
+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;
+  return false;
+}
+function contains(a, b) {
+  return b.x1 >= a.x1 - CLIP_EDGE_TOL && b.x2 <= a.x2 + CLIP_EDGE_TOL && b.y1 >= a.y1 - CLIP_EDGE_TOL && b.y2 <= a.y2 + CLIP_EDGE_TOL && (b.x2 - b.x1 < a.x2 - a.x1 - CLIP_EDGE_TOL || b.y2 - b.y1 < a.y2 - a.y1 - CLIP_EDGE_TOL);
+}
+function clusterCoords(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const out = [];
+  let run = [];
+  for (const v of sorted) {
+    if (run.length > 0 && v - run[run.length - 1] > CLIP_EDGE_TOL) {
+      out.push(run.reduce((s, x) => s + x, 0) / run.length);
+      run = [];
+    }
+    run.push(v);
+  }
+  if (run.length > 0) out.push(run.reduce((s, x) => s + x, 0) / run.length);
+  return out;
+}
+var nearestIndex = (coords, v) => {
+  let best = 0;
+  for (let i = 1; i < coords.length; i++) if (Math.abs(coords[i] - v) < Math.abs(coords[best] - v)) best = i;
+  return best;
+};
+function edgeStroked(lines, dir, pos, a1, a2) {
+  const len = a2 - a1;
+  if (len <= 0) return true;
+  for (const l of lines) {
+    if (dir === "h") {
+      if (Math.abs(l.y1 - pos) <= STROKE_NEAR && overlap(l.x1, l.x2, a1, a2) >= len * STROKE_COVER) return true;
+    } else if (Math.abs(l.x1 - pos) <= STROKE_NEAR && overlap(l.y1, l.y2, a1, a2) >= len * STROKE_COVER) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight) {
+  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 = [];
+  for (const r of rects) {
+    if (r.x2 - r.x1 < CLIP_MIN_W2 || r.y2 - r.y1 < CLIP_MIN_H2) continue;
+    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: [] };
+  const parent = new Array(cells.length).fill(-1);
+  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;
+      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 root = cells.map((_, i) => i);
+  const find = (i) => {
+    while (root[i] !== i) {
+      root[i] = root[root[i]];
+      i = root[i];
+    }
+    return i;
+  };
+  for (let i = 0; i < cells.length; i++) {
+    for (let j = i + 1; j < cells.length; j++) {
+      if (parent[i] !== parent[j]) continue;
+      if (adjacent(cells[i], cells[j])) {
+        const ra = find(i), rb = find(j);
+        if (ra !== rb) root[ra] = rb;
+      }
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < cells.length; i++) {
+    const r = find(i);
+    const g = groups.get(r);
+    if (g) g.push(i);
+    else groups.set(r, [i]);
+  }
+  const containers = cells.filter((_, i) => isContainer[i]);
+  const groupSize = (i) => groups.get(find(i))?.length ?? 0;
+  const isGridMember = (i) => groupSize(i) >= CLIP_MIN_GROUP;
+  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 loneFrame = (i) => isContainer[i] && !isGridMember(i) && framed(cells[i]);
+  const parentAttachable = (i) => parent[i] >= 0 && (isGridMember(parent[i]) || loneFrame(parent[i]));
+  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 (idxs.length < CLIP_MIN_GROUP) {
+      if (!loneFrame(first) && !((parentRect || onlyChild(first)) && framed(cells[first]))) continue;
+      const r = cells[first];
+      grids.push({
+        rowYs: [r.y2, r.y1],
+        colXs: [r.x1, r.x2],
+        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 } : {}
+      });
+      continue;
+    }
+    const members = idxs.map((i) => cells[i]);
+    let edges = 0, invisible = 0;
+    for (const r of members) {
+      edges += 4;
+      if (!edgeStroked(strokedH, "h", r.y1, r.x1, r.x2)) invisible++;
+      if (!edgeStroked(strokedH, "h", r.y2, r.x1, r.x2)) invisible++;
+      if (!edgeStroked(strokedV, "v", r.x1, r.y1, r.y2)) invisible++;
+      if (!edgeStroked(strokedV, "v", r.x2, r.y1, r.y2)) invisible++;
+    }
+    if (invisible / edges < CLIP_MIN_INVISIBLE) continue;
+    const colXs = clusterCoords(members.flatMap((r) => [r.x1, r.x2]));
+    const rowYs = clusterCoords(members.flatMap((r) => [r.y1, r.y2])).reverse();
+    const numRows = rowYs.length - 1, numCols = colXs.length - 1;
+    if (numRows < 1 || numCols < 1) continue;
+    const occupied = Array.from({ length: numRows }, () => new Array(numCols).fill(false));
+    const out = [];
+    for (const r of members) {
+      const c0 = nearestIndex(colXs, r.x1), c1 = nearestIndex(colXs, r.x2);
+      const r0 = nearestIndex(rowYs, r.y2), r1 = nearestIndex(rowYs, r.y1);
+      if (c1 <= c0 || r1 <= r0) continue;
+      let clash = false;
+      for (let rr = r0; rr < r1 && !clash; rr++) for (let cc = c0; cc < c1; cc++) if (occupied[rr][cc]) {
+        clash = true;
+        break;
+      }
+      if (clash) continue;
+      for (let rr = r0; rr < r1; rr++) for (let cc = c0; cc < c1; cc++) occupied[rr][cc] = true;
+      out.push({ row: r0, col: c0, rowSpan: r1 - r0, colSpan: c1 - c0, bbox: { x1: r.x1, y1: r.y1, x2: r.x2, y2: r.y2 } });
+    }
+    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] } });
+      }
+    }
+    grids.push({
+      rowYs,
+      colXs,
+      bbox: { x1: colXs[0], y1: rowYs[numRows], x2: colXs[numCols], y2: rowYs[0] },
+      vertexRadius: 1,
+      cells: out,
+      ...parentRect ? { clipParent: parentRect } : {}
+    });
+  }
+  return { grids, containers };
+}
+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);
+  const overlapsHalf = (g, b) => {
+    const ix = Math.min(g.x2, b.x2) - Math.max(g.x1, b.x1);
+    const iy = Math.min(g.y2, b.y2) - Math.max(g.y1, b.y1);
+    if (ix <= 0 || iy <= 0) return false;
+    const ga = area(g);
+    return ga > 0 && ix * iy / ga >= 0.5;
+  };
+  return lineGrids.filter((g) => {
+    if (clipGrids.some((c) => overlapsHalf(g.bbox, c.bbox))) return false;
+    if (containers.some((c) => overlapsHalf(g.bbox, c))) return false;
+    return true;
+  });
+}
+
 // src/pdf/cell-extract.ts
 function extractCells(grid, horizontals, verticals) {
   const { rowYs, colXs } = grid;
@@ -1012,8 +1217,8 @@ function hasVerticalLine(verticals, x, topY, botY, vertexRadius) {
       if (cellH < 0.1) continue;
       const overlapTop = Math.min(v.y2, topY);
       const overlapBot = Math.max(v.y1, botY);
-      const overlap = overlapTop - overlapBot;
-      if (overlap >= cellH * 0.75) return true;
+      const overlap2 = overlapTop - overlapBot;
+      if (overlap2 >= cellH * 0.75) return true;
     }
   }
   return false;
@@ -1026,8 +1231,8 @@ function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
       if (cellW < 0.1) continue;
       const overlapLeft = Math.max(h.x1, leftX);
       const overlapRight = Math.min(h.x2, rightX);
-      const overlap = overlapRight - overlapLeft;
-      if (overlap >= cellW * 0.75) return true;
+      const overlap2 = overlapRight - overlapLeft;
+      if (overlap2 >= cellW * 0.75) return true;
     }
   }
   return false;
@@ -1134,9 +1339,9 @@ function mergeSuperscriptRows(lines) {
     const curr = lines[i];
     const a = band(prev);
     const b = band(curr);
-    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
-    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    const overlap2 = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap2 >= a.height * 0.5;
+    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap2 >= b.height * 0.5;
     if (prevIsFrag || currIsFrag) {
       result[result.length - 1] = [...prev, ...curr];
     } else {
@@ -1355,14 +1560,17 @@ function filterHiddenText(items, pageWidth, pageHeight) {
 function collapseEvenSpacing(text) {
   const tokens = text.split(" ");
   const singleCharCount = tokens.filter((t) => t.length === 1).length;
-  if (tokens.length >= 3 && singleCharCount / tokens.length >= 0.7) {
+  if (tokens.length >= 3 && singleCharCount / tokens.length >= 0.7 && !isDateUnitBlank(tokens)) {
     return tokens.join("");
   }
   return text.replace(
     /(?<![가-힣])[가-힣](?: [가-힣\d]){2,}(?![가-힣])/g,
-    (match) => match.replace(/ /g, "")
+    (match) => isDateUnitBlank(match.split(" ")) ? match : match.replace(/ /g, "")
   );
 }
+function isDateUnitBlank(tokens) {
+  return tokens.every((t) => t.length !== 1 || !/[가-힣]/.test(t) || /[년월일시분초]/.test(t));
+}
 function computeBBox(items, pageNum) {
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const i of items) {
@@ -1503,9 +1711,9 @@ function mergeSuperscriptLines(lines) {
     const curr = lines[i];
     const a = band(prev);
     const b = band(curr);
-    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
-    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    const overlap2 = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFrag(prev) && a.height <= b.height * 0.8 && overlap2 >= a.height * 0.5;
+    const currIsFrag = isFrag(curr) && b.height <= a.height * 0.8 && overlap2 >= b.height * 0.5;
     if (prevIsFrag || currIsFrag) {
       result[result.length - 1] = [...prev, ...curr];
     } else {
@@ -1654,8 +1862,8 @@ function detectTableCaptions(blocks) {
       const tblBottom = table.bbox.y;
       const gap = capBottom >= tblTop ? capBottom - tblTop : tblBottom - capTop;
       if (gap > CAPTION_MAX_GAP) return false;
-      const overlap = Math.min(b.bbox.x + b.bbox.width, table.bbox.x + table.bbox.width) - Math.max(b.bbox.x, table.bbox.x);
-      if (overlap < Math.min(b.bbox.width, table.bbox.width) * 0.3) return false;
+      const overlap2 = Math.min(b.bbox.x + b.bbox.width, table.bbox.x + table.bbox.width) - Math.max(b.bbox.x, table.bbox.x);
+      if (overlap2 < Math.min(b.bbox.width, table.bbox.width) * 0.3) return false;
     }
     return true;
   };
@@ -1919,8 +2127,8 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings) {
         if (!o.bbox || o.bbox.page !== cb.page) continue;
         const oNorm = o.text?.trim().replace(/\d+/g, "#");
         if (oNorm && repeatedPatterns.has(oNorm)) continue;
-        const overlap = Math.min(cb.y + cb.height, o.bbox.y + o.bbox.height) - Math.max(cb.y, o.bbox.y);
-        if (overlap >= cb.height * 0.5) {
+        const overlap2 = Math.min(cb.y + cb.height, o.bbox.y + o.bbox.height) - Math.max(cb.y, o.bbox.y);
+        if (overlap2 >= cb.height * 0.5) {
           sharesLine = true;
           break;
         }
@@ -2192,9 +2400,9 @@ function mergeOverlappingRows(rows) {
     const curr = rows[i];
     const a = rowBand(prev);
     const b = rowBand(curr);
-    const overlap = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-    const prevIsFrag = isFragmentRow(prev) && a.height <= b.height * 0.8 && overlap >= a.height * 0.5;
-    const currIsFrag = isFragmentRow(curr) && b.height <= a.height * 0.8 && overlap >= b.height * 0.5;
+    const overlap2 = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+    const prevIsFrag = isFragmentRow(prev) && a.height <= b.height * 0.8 && overlap2 >= a.height * 0.5;
+    const currIsFrag = isFragmentRow(curr) && b.height <= a.height * 0.8 && overlap2 >= b.height * 0.5;
     if (prevIsFrag || currIsFrag) {
       const baseY = prevIsFrag ? curr.y : prev.y;
       result[result.length - 1] = { y: baseY, items: [...prev.items, ...curr.items] };
@@ -3071,8 +3279,8 @@ function markUnderlineItems(items, horizontals, verticals) {
       if (h <= 0 || item.w <= 0 || !item.text.trim()) continue;
       const below = Math.max(h * UNDER_BELOW_EM, UNDER_BELOW_MIN_PT);
       if (line.y1 < item.y - below || line.y1 > item.y + UNDER_ABOVE_PT) continue;
-      const overlap = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
-      if (overlap / item.w < UNDER_MIN_OVERLAP_RATIO) continue;
+      const overlap2 = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
+      if (overlap2 / item.w < UNDER_MIN_OVERLAP_RATIO) continue;
       matches.push(item);
     }
     if (matches.length === 0) continue;
@@ -3116,8 +3324,8 @@ function hasBoxTopPair(line, maxH, horizontals) {
     if (dy < maxH * UNDER_BOX_PAIR_MIN_EM || dy > maxH * UNDER_BOX_PAIR_MAX_EM) continue;
     const ow = o.x2 - o.x1;
     if (ow <= 0) continue;
-    const overlap = Math.min(line.x2, o.x2) - Math.max(line.x1, o.x1);
-    if (overlap / Math.max(w, ow) >= UNDER_BOX_PAIR_OVERLAP) return true;
+    const overlap2 = Math.min(line.x2, o.x2) - Math.max(line.x1, o.x1);
+    if (overlap2 / Math.max(w, ow) >= UNDER_BOX_PAIR_OVERLAP) return true;
   }
   return false;
 }
@@ -3128,8 +3336,8 @@ function isRepeatedSpanRule(line, horizontals) {
   for (const o of horizontals) {
     const ow = o.x2 - o.x1;
     if (ow <= 0) continue;
-    const overlap = Math.min(line.x2, o.x2) - Math.max(line.x1, o.x1);
-    if (overlap / Math.max(w, ow) < UNDER_SPAN_OVERLAP_RATIO) continue;
+    const overlap2 = Math.min(line.x2, o.x2) - Math.max(line.x1, o.x1);
+    if (overlap2 / Math.max(w, ow) < UNDER_SPAN_OVERLAP_RATIO) continue;
     if (!ys.some((y) => Math.abs(y - o.y1) < 2)) ys.push(o.y1);
   }
   return ys.length >= UNDER_REPEATED_SPAN_LEVELS;
@@ -3163,7 +3371,10 @@ function wrapUnderlineRuns(items) {
 // src/pdf/page-blocks.ts
 function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight, extraLines, detectTables = true) {
   if (items.length === 0) return [];
-  let { horizontals, verticals } = extractLines(opList.fnArray, opList.argsArray);
+  const extracted = extractLines(opList.fnArray, opList.argsArray);
+  let { horizontals, verticals } = extracted;
+  const clipResult = detectTables ? buildClipCellGrids(extracted.clipRects, horizontals, verticals, pageWidth, pageHeight) : { grids: [], containers: [] };
+  const clipGrids = clipResult.grids;
   if (extraLines) {
     horizontals = horizontals.concat(extraLines.horizontals);
     verticals = verticals.concat(extraLines.verticals);
@@ -3177,7 +3388,8 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   wrapStrikethroughRuns(items);
   markUnderlineItems(items, horizontals, verticals);
   wrapUnderlineRuns(items);
-  const grids = detectTables ? buildTableGrids(horizontals, verticals) : [];
+  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);
   }
@@ -3199,8 +3411,8 @@ function markStrikethroughItems(items, horizontals) {
       if (line.lineWidth > h * STRIKE_MAX_THICKNESS_RATIO) continue;
       const centerY = item.y + h * 0.4;
       if (Math.abs(line.y1 - centerY) > h * STRIKE_CENTER_TOLERANCE) continue;
-      const overlap = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
-      if (overlap / item.w < STRIKE_MIN_OVERLAP_RATIO) continue;
+      const overlap2 = Math.min(line.x2, item.x + item.w) - Math.max(line.x1, item.x);
+      if (overlap2 / item.w < STRIKE_MIN_OVERLAP_RATIO) continue;
       matches.push(item);
     }
     if (matches.length === 0) continue;
@@ -3274,15 +3486,54 @@ function isProseBoxGrid(grid, verticals, table) {
   if (longCells < PROSEBOX_LONG_CELL_MIN || longCells < texts.length * PROSEBOX_LONG_CELL_RATIO) return false;
   return true;
 }
+function cleanCellText(text) {
+  const stripped = text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
+  return stripped.split("\n").map((line) => collapseEvenSpacing(line)).join("\n");
+}
+var FRAME_RECT_TOL = 1.5;
+function takePendingNested(pending, cellBox) {
+  const out = [];
+  for (let i = pending.length - 1; i >= 0; i--) {
+    const p = pending[i].parent;
+    if (Math.abs(p.x1 - cellBox.x1) <= FRAME_RECT_TOL && Math.abs(p.x2 - cellBox.x2) <= FRAME_RECT_TOL && Math.abs(p.y1 - cellBox.y1) <= FRAME_RECT_TOL && Math.abs(p.y2 - cellBox.y2) <= FRAME_RECT_TOL) {
+      out.push(pending[i].block);
+      pending.splice(i, 1);
+    }
+  }
+  return out;
+}
+function buildFrameCellBlocks(cellItems, nested, pageNum) {
+  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")) {
+      const t = line.trim();
+      if (t) blocks.push({ type: "paragraph", text: t, pageNumber: pageNum });
+    }
+  };
+  for (const tb of tables) {
+    const bottom = tb.bbox.y;
+    pushParagraphs(rest.filter((it) => it.y >= bottom));
+    rest = rest.filter((it) => it.y < bottom);
+    blocks.push(tb);
+  }
+  pushParagraphs(rest);
+  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) {
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
-  const sortedGrids = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
+  const pendingNested = [];
+  const gridArea = (g) => (g.bbox.x2 - g.bbox.x1) * (g.bbox.y2 - g.bbox.y1);
+  const sortedGrids = [...grids].sort((a, b) => (b.cells ? 1 : 0) - (a.cells ? 1 : 0) || (a.cells && b.cells ? gridArea(a) - gridArea(b) : 0) || b.bbox.y2 - a.bbox.y2);
   for (const grid of sortedGrids) {
     const numGridRows = grid.rowYs.length - 1;
     const numGridCols = grid.colXs.length - 1;
-    if (numGridRows === 1 && numGridCols >= 2) continue;
-    if (numGridCols === 1 && numGridRows >= 2) continue;
+    if (!grid.cells && numGridRows === 1 && numGridCols >= 2) continue;
+    if (!grid.cells && numGridCols === 1 && numGridRows >= 2) continue;
     const tableItems = [];
     const pad = 3;
     const gridW = grid.bbox.x2 - grid.bbox.x1;
@@ -3294,7 +3545,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       tableItems.push(item);
       usedItems.add(item);
     }
-    const cells = extractCells(grid, horizontals, verticals);
+    const cells = grid.cells ?? extractCells(grid, horizontals, verticals);
     if (cells.length === 0) continue;
     const textItems = tableItems.map((i) => ({
       text: i.text,
@@ -3315,13 +3566,18 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       { length: numRows },
       () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
     );
+    let nestedAttached = false;
     for (const cell of cells) {
       const cellItems = cellTextMap.get(cell) || [];
-      let text = cellTextToString(cellItems);
-      text = text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
-      text = text.split("\n").map((line) => collapseEvenSpacing(line)).join("\n");
+      const nested = grid.cells ? takePendingNested(pendingNested, cell.bbox) : [];
+      if (nested.length > 0) {
+        nestedAttached = true;
+        const built = buildFrameCellBlocks(cellItems, nested, pageNum);
+        irGrid[cell.row][cell.col] = { text: built.text, colSpan: cell.colSpan, rowSpan: cell.rowSpan, blocks: built.blocks };
+        continue;
+      }
       irGrid[cell.row][cell.col] = {
-        text,
+        text: cleanCellText(cellTextToString(cellItems)),
         colSpan: cell.colSpan,
         rowSpan: cell.rowSpan
       };
@@ -3329,18 +3585,11 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
     let finalGrid = irGrid;
     let finalRows = numRows;
     let rebuiltUsed = false;
-    if (numRows <= 2 && numCols >= 3) {
+    if (numRows <= 2 && numCols >= 3 && !nestedAttached) {
       const rebuilt = normalizeUndersegmentedTable(irGrid, grid.colXs, textItems);
       if (rebuilt) {
         rebuiltUsed = true;
-        finalGrid = rebuilt.map((row) => row.map((rawText) => {
-          const cleaned = rawText.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
-          return {
-            text: cleaned.split("\n").map((line) => collapseEvenSpacing(line)).join("\n"),
-            colSpan: 1,
-            rowSpan: 1
-          };
-        }));
+        finalGrid = rebuilt.map((row) => row.map((rawText) => ({ text: cleanCellText(rawText), colSpan: 1, rowSpan: 1 })));
         finalRows = finalGrid.length;
       }
     }
@@ -3357,7 +3606,12 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
     };
     const hasContent = finalGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
     if (!hasContent) continue;
-    if (isProseBoxGrid(grid, verticals, 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 } });
+      continue;
+    }
+    if (!grid.cells && isProseBoxGrid(grid, verticals, irTable)) {
       for (const it of tableItems) usedItems.delete(it);
       continue;
     }
@@ -3368,7 +3622,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       width: grid.bbox.x2 - grid.bbox.x1,
       height: grid.bbox.y2 - grid.bbox.y1
     };
-    if (shouldDemoteTable(irTable)) {
+    if (!grid.cells && shouldDemoteTable(irTable)) {
       const demoted = demoteTableToText(irTable);
       if (demoted) {
         const text = numGridRows === 1 ? "\n" + demoted + "\n" : demoted;
@@ -3378,6 +3632,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
     }
     blocks.push({ type: "table", table: irTable, pageNumber: pageNum, bbox: tableBbox });
   }
+  for (const p of pendingNested) blocks.push(p.block);
   let remaining = items.filter((i) => !usedItems.has(i));
   const groupSizes = [];
   let finalTextBlocks = [];
@@ -3687,4 +3942,4 @@ export {
   extractPageBlocksWithLines,
   mergeCrossPageTables
 };
-//# sourceMappingURL=chunk-SKGYPM6L.js.map
+//# sourceMappingURL=chunk-OEYECZGV.js.map