kordoc 4.16.2 → 4.17.0

package/dist/{chunk-SFEQYKYJ.js → chunk-WN6OD2CQ.js}

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 import {
+  CELL_EDGES,
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3,
   tidyScriptTags
-} from "./chunk-J3IF6KGW.js";
+} from "./chunk-5CDUL6PH.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-P6ZDXTV6.js";
+} from "./chunk-ZF6KHPB7.js";
 
 // src/pdf/line-extract.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -30,6 +31,9 @@ function extractLines(fnArray, argsArray) {
   const colorStack = [];
   let fillAlpha = 1, strokeAlpha = 1;
   const alphaStack = [];
+  let strokeColor = 0;
+  const strokeColorStack = [];
+  const nonRules = /* @__PURE__ */ new Set();
   const hiddenBoxes = [];
   const paintedFills = /* @__PURE__ */ new Map();
   const thinFill = /* @__PURE__ */ new Set();
@@ -97,6 +101,7 @@ function extractLines(fnArray, argsArray) {
       for (const r of pathRects) painted.push(r);
       paintedFills.set(fillColor, painted);
     }
+    const areaFill = fromFill && (pathRects.length > 0 || thickPath(currentPath));
     pathRects = [];
     pathRectSegs = [];
     if (!isStroke) {
@@ -107,6 +112,9 @@ function extractLines(fnArray, argsArray) {
     }
     pendingClip = false;
     const effWidth = lineWidth * ctmScale();
+    const outs = [horizontals, verticals, shortH, shortV, thinShortH, thinShortV];
+    const white = (fromFill ? fillColor : strokeColor) === 16777215;
+    const from = white || areaFill ? outs.map((o) => o.length) : void 0;
     currentPath.forEach((seg, k) => {
       const role = segRole[k];
       if (role === "hidden") return;
@@ -118,6 +126,9 @@ function extractLines(fnArray, argsArray) {
       }
       classifyAndAdd(seg, effWidth, horizontals, verticals, fromFill, fromFill ? void 0 : { h: shortH, v: shortV });
     });
+    if (from) outs.forEach((o, k) => {
+      for (let n = from[k]; n < o.length; n++) if (white || k < 2 && !thinFill.has(o[n])) nonRules.add(o[n]);
+    });
     currentPath = [];
   }
   for (let i = 0; i < fnArray.length; i++) {
@@ -130,11 +141,13 @@ function extractLines(fnArray, argsArray) {
       case OPS.save:
         ctmStack.push(ctm.slice());
         colorStack.push(fillColor);
+        strokeColorStack.push(strokeColor);
         alphaStack.push([fillAlpha, strokeAlpha]);
         break;
       case OPS.restore:
         ctm = ctmStack.pop() ?? [1, 0, 0, 1, 0, 0];
         fillColor = colorStack.pop() ?? 0;
+        strokeColor = strokeColorStack.pop() ?? 0;
         [fillAlpha, strokeAlpha] = alphaStack.pop() ?? [1, 1];
         break;
       case OPS.setGState: {
@@ -152,12 +165,18 @@ function extractLines(fnArray, argsArray) {
         fillColor = c[0] << 16 | c[1] << 8 | c[2];
         break;
       }
+      case OPS.setStrokeRGBColor: {
+        const c = args;
+        strokeColor = c[0] << 16 | c[1] << 8 | c[2];
+        break;
+      }
       case OPS.transform:
       case OPS.paintFormXObjectBegin: {
         let t = args;
         if (op === OPS.paintFormXObjectBegin) {
           ctmStack.push(ctm.slice());
           colorStack.push(fillColor);
+          strokeColorStack.push(strokeColor);
           alphaStack.push([fillAlpha, strokeAlpha]);
           const m = args[0];
           if (!Array.isArray(m) || m.length < 6) break;
@@ -176,6 +195,7 @@ function extractLines(fnArray, argsArray) {
       case OPS.paintFormXObjectEnd:
         ctm = ctmStack.pop() ?? [1, 0, 0, 1, 0, 0];
         fillColor = colorStack.pop() ?? 0;
+        strokeColor = strokeColorStack.pop() ?? 0;
         [fillAlpha, strokeAlpha] = alphaStack.pop() ?? [1, 1];
         break;
       case OPS.constructPath: {
@@ -287,7 +307,8 @@ function extractLines(fnArray, argsArray) {
     fillRects,
     hiddenBoxes,
     shortH,
-    shortV
+    shortV,
+    nonRules
   };
 }
 var SHORT_CHAIN_POS_TOL = 0.5;
@@ -342,6 +363,17 @@ function chainShortSegments(longs, shorts, dir, chainable = (l) => !l.fromFill)
 }
 var CLIP_MIN_W = 4;
 var CLIP_MIN_H = 2;
+function thickPath(path) {
+  if (!path.length) return false;
+  let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+  for (const s of path) {
+    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);
+  }
+  return Math.min(x2 - x1, y2 - y1) > THIN_FILL_MAX;
+}
 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;
@@ -465,7 +497,7 @@ var CHAIN_GAP = 3;
 function chainCollinearRules(horizontals) {
   if (horizontals.length <= 1) return horizontals;
   const sorted = [...horizontals].sort((a, b) => a.y1 - b.y1 || a.x1 - b.x1);
-  const rules = [];
+  const rules2 = [];
   let bandStart = 0;
   const flushBand = (end) => {
     const band = sorted.slice(bandStart, end).sort((a, b) => a.x1 - b.x1);
@@ -476,11 +508,11 @@ function chainCollinearRules(horizontals) {
         if (seg.x2 > cur.x2) cur.x2 = seg.x2;
         if (seg.lineWidth > cur.lineWidth) cur.lineWidth = seg.lineWidth;
       } else {
-        rules.push(cur);
+        rules2.push(cur);
         cur = { ...seg };
       }
     }
-    rules.push(cur);
+    rules2.push(cur);
   };
   for (let i = 1; i <= sorted.length; i++) {
     if (i === sorted.length || sorted[i].y1 - sorted[bandStart].y1 > CHAIN_Y_TOL) {
@@ -488,7 +520,7 @@ function chainCollinearRules(horizontals) {
       bandStart = i;
     }
   }
-  return rules;
+  return rules2;
 }
 function closeOpenTableEdges(horizontals, verticals) {
   if (horizontals.length < EDGE_MIN_RULES) return verticals;
@@ -754,7 +786,7 @@ function bridgeSkippedRowVerticals(horizontals, verticals, items) {
       if (hi - lo > BRIDGE_MIN_GAP && hi - lo <= 40) gaps.push({ x, lo, hi, spanLo: s[i - 1].y1, spanHi: s[i].y2 });
     }
   }
-  const rules = chainCollinearRules(horizontals);
+  const rules2 = chainCollinearRules(horizontals);
   const added = [];
   const done = /* @__PURE__ */ new Set();
   for (const g of gaps) {
@@ -764,7 +796,7 @@ function bridgeSkippedRowVerticals(horizontals, verticals, items) {
     if (band.length < BRIDGE_MIN_COLUMNS) continue;
     const xs = band.map((o) => o.x);
     const x1 = Math.min(...xs), x2 = Math.max(...xs);
-    const ruled = (y) => rules.some((h) => Math.abs(h.y1 - y) <= BRIDGE_ENDPOINT_TOL && h.x1 <= x1 + BRIDGE_ENDPOINT_TOL && h.x2 >= x2 - BRIDGE_ENDPOINT_TOL);
+    const ruled = (y) => rules2.some((h) => Math.abs(h.y1 - y) <= BRIDGE_ENDPOINT_TOL && h.x1 <= x1 + BRIDGE_ENDPOINT_TOL && h.x2 >= x2 - BRIDGE_ENDPOINT_TOL);
     if (!ruled(g.lo) || !ruled(g.hi)) continue;
     const rowItems = items.filter((it) => {
       const cy = it.y + (it.h || it.fontSize) / 2;
@@ -1093,7 +1125,7 @@ function clusterCoordinates(values, tolerance) {
 function chainVerticals(vs) {
   if (vs.length <= 1) return vs.map((v) => ({ y1: v.y1, y2: v.y2 }));
   const sorted = [...vs].sort((a, b) => a.x1 - b.x1 || a.y1 - b.y1);
-  const rules = [];
+  const rules2 = [];
   let bandStart = 0;
   const flushBand = (end) => {
     const band = sorted.slice(bandStart, end).sort((a, b) => a.y1 - b.y1);
@@ -1103,11 +1135,11 @@ function chainVerticals(vs) {
       if (seg.y1 - cur.y2 <= CUT_VCHAIN_GAP) {
         if (seg.y2 > cur.y2) cur.y2 = seg.y2;
       } else {
-        rules.push(cur);
+        rules2.push(cur);
         cur = { y1: seg.y1, y2: seg.y2 };
       }
     }
-    rules.push(cur);
+    rules2.push(cur);
   };
   for (let i = 1; i <= sorted.length; i++) {
     if (i === sorted.length || sorted[i].x1 - sorted[bandStart].x1 > CUT_VCHAIN_X_TOL) {
@@ -1115,7 +1147,7 @@ function chainVerticals(vs) {
       bandStart = i;
     }
   }
-  return rules;
+  return rules2;
 }
 function splitStackedGroup(group) {
   const hs = group.filter((l) => l.type === "h");
@@ -1465,11 +1497,42 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
       }
     }
   }
+  const stacked = /* @__PURE__ */ new Set();
+  if (ruledGaps.some((g) => g.axis === "y" && g.both && g.hi - g.lo > STACKED_TABLE_GAP)) {
+    for (let i = 0; i < cells.length; i++) {
+      if (tableClip[i]) continue;
+      const k = edgeBin(cells[i].y2);
+      for (let d = -1; d <= 1; d++) {
+        if ((startsY.get(k + d) ?? []).some((j) => j !== i && !tableClip[j] && parent[j] === parent[i] && adjacent(cells[i], cells[j]))) stacked.add(find(i));
+      }
+    }
+  }
+  const comp = cells.map((_, i) => find(i));
   for (const g of ruledGaps) {
     if (tableClip[g.i] || tableClip[g.j]) continue;
+    if (g.axis === "y" && g.both && g.hi - g.lo > STACKED_TABLE_GAP && comp[g.i] !== comp[g.j] && stacked.has(comp[g.i]) && stacked.has(comp[g.j])) continue;
     const ra = find(g.i), rb = find(g.j);
     if (ra !== rb) root[ra] = rb;
   }
+  if (prev.lastCells.length) {
+    const headTop = pageHeight * (1 - HEADER_BAND);
+    let top = -Infinity;
+    for (let i = 0; i < cells.length; i++) if (parent[i] < 0 && !tableClip[i]) top = Math.max(top, cells[i].y2);
+    const band = cells.flatMap((c, i) => parent[i] < 0 && !tableClip[i] && Math.abs(c.y2 - top) <= CLIP_COORD_TOL ? [i] : []);
+    const y1 = band.length ? cells[band[0]].y1 : 0;
+    if (band.length >= 2 && band.every((i) => Math.abs(cells[i].y1 - y1) <= CLIP_COORD_TOL) && !textPoints.some((p) => p.y > top + CLIP_EDGE_TOL && p.y < headTop)) {
+      for (let f = 0; f < cells.length; f++) {
+        const b = cells[f];
+        if (parent[f] >= 0 || tableClip[f] || Math.abs(b.y2 - y1) > CLIP_ADJ_GAP) continue;
+        const on = band.filter((i) => cells[i].x1 >= b.x1 - CLIP_COORD_TOL && cells[i].x2 <= b.x2 + CLIP_COORD_TOL);
+        if (on.length < 2 || !on.some((i) => adjacent(cells[i], b))) continue;
+        for (const i of on) {
+          const ra = find(i), rb = find(f);
+          if (ra !== rb) root[ra] = rb;
+        }
+      }
+    }
+  }
   const groups = /* @__PURE__ */ new Map();
   for (let i = 0; i < cells.length; i++) {
     const r = find(i);
@@ -1529,6 +1592,8 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     if (invisible / edges < CLIP_MIN_INVISIBLE) continue;
     const colXs = dropSliverGaps(clusterCoords(members.flatMap((r) => [r.x1, r.x2])));
     const rowYs = clusterCoords(members.flatMap((r) => [r.y1, r.y2])).reverse();
+    const band = parentRect ? void 0 : carriedBandTop(colXs, rowYs[0], strokedH, strokedV, textPoints, cells, prev.lastCells, headY);
+    if (band !== void 0) rowYs.unshift(band);
     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));
@@ -1575,6 +1640,7 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   return { grids, containers, page: { lastCells, clips: cells } };
 }
 var CLIP_SPACING_MAX = 3;
+var STACKED_TABLE_GAP = 2.6;
 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);
@@ -1704,6 +1770,20 @@ function closeGaps(members, gaps) {
   }
   return out;
 }
+function carriedBandTop(colXs, top, strokedH, strokedV, textPoints, cells, prevLast, headY) {
+  const x1 = colXs[0], x2 = colXs[colXs.length - 1];
+  if (!prevLast.some((b) => overlap(b.x1, b.x2, x1, x2) > CLIP_EDGE_TOL)) return void 0;
+  let y;
+  for (const l of strokedH) {
+    if (l.y1 > top + CLIP_MIN_H2 && l.x1 <= x1 + STROKE_NEAR && l.x2 >= x2 - STROKE_NEAR && (y === void 0 || l.y1 < y)) y = l.y1;
+  }
+  if (y === void 0 || !edgeStroked(strokedV, "v", x1, top, y) || !edgeStroked(strokedV, "v", x2, top, y)) return void 0;
+  const above = Math.max(y, headY);
+  const inX = (x) => x > x1 && x < x2;
+  if (textPoints.some((p) => inX(p.x) && p.y > top && p.y < above)) return void 0;
+  if (cells.some((c) => overlap(c.x1, c.x2, x1, x2) > CLIP_EDGE_TOL && c.y1 >= top - CLIP_EDGE_TOL && c.y1 < above)) return void 0;
+  return y;
+}
 function addNarrowEdgeCols(colXs, rowYs, out, fills) {
   if (!fills.length) return;
   const rowIdx = (y) => {
@@ -3688,6 +3768,9 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
 // src/pdf/table-meta.ts
 var CLIP_TABLES = /* @__PURE__ */ new WeakSet();
 var TABLE_COLXS = /* @__PURE__ */ new WeakMap();
+var TABLE_ROWYS = /* @__PURE__ */ new WeakMap();
+var TABLE_TAIL = /* @__PURE__ */ new WeakMap();
+var PART_COLXS = /* @__PURE__ */ new WeakMap();
 var EMPTY_PARTS = /* @__PURE__ */ new WeakSet();
 var IMAGE_CELLS = /* @__PURE__ */ new WeakSet();
 var FILLER_CELLS = /* @__PURE__ */ new WeakSet();
@@ -3706,6 +3789,34 @@ function recordCellLines(cell, items) {
   }
   CELL_LINES.set(cell, lines);
 }
+var ROW_RULES = /* @__PURE__ */ new WeakMap();
+function ruleCover(hs, y, x1, x2) {
+  const segs = hs.filter((l) => Math.abs(l.y1 - y) <= 1.5 && l.x2 > x1 && l.x1 < x2).map((l) => [Math.max(l.x1, x1), Math.min(l.x2, x2)]).sort((a, b) => a[0] - b[0]);
+  let len = 0, end = x1;
+  for (const [a, b] of segs) if (b > end) {
+    len += b - Math.max(a, end);
+    end = b;
+  }
+  return x2 > x1 ? len / (x2 - x1) : 0;
+}
+function recordRowRules(table, cells, bbox, hs) {
+  const real = cells.filter((c) => !c.filler);
+  const edge = (y, pick) => {
+    let w = 0, covered = 0;
+    for (const c of real) if (Math.abs(pick(c) - y) <= 1) {
+      w += c.bbox.x2 - c.bbox.x1;
+      covered += ruleCover(hs, y, c.bbox.x1, c.bbox.x2) * (c.bbox.x2 - c.bbox.x1);
+    }
+    return w > 0 && covered >= 0.9 * w;
+  };
+  let innerRuled = 0, innerOpen = 0;
+  for (const c of real) {
+    if (Math.abs(c.bbox.y1 - bbox.y1) <= 1) continue;
+    if (ruleCover(hs, c.bbox.y1, c.bbox.x1 + 0.5, c.bbox.x2 - 0.5) >= 0.9) innerRuled++;
+    else innerOpen++;
+  }
+  ROW_RULES.set(table, { top: edge(bbox.y2, (c) => c.bbox.y2), bottom: edge(bbox.y1, (c) => c.bbox.y1), innerRuled, innerOpen });
+}
 
 // src/pdf/table-trim.ts
 function markImageCell(cell) {
@@ -5516,6 +5627,76 @@ function headerLineAbove(free, colXs, top) {
   return cols;
 }
 
+// src/pdf/cell-edges.ts
+var CLIP_CELL_EDGES = /* @__PURE__ */ new WeakMap();
+var NO_EDGES = Object.freeze({ t: false, b: false, l: false, r: false });
+var EDGE_NEAR2 = 1.6;
+var EDGE_COVER = 0.6;
+var EDGE_SLACK = 3;
+var DASH_GAP = 3;
+var TIP_MAX = 1.5;
+function rules(lines, dir) {
+  const sorted = [...lines].sort((a, b) => dir === "h" ? a.y1 - b.y1 : a.x1 - b.x1);
+  return { dir, pos: sorted.map((l) => dir === "h" ? l.y1 : l.x1), lines: sorted };
+}
+function seen(r, at, a1, a2) {
+  const len = a2 - a1;
+  if (len <= 0) return false;
+  const covered = coverage(r, at, a1, a2);
+  return covered >= len * EDGE_COVER && len - covered <= EDGE_SLACK;
+}
+function coverage(r, at, a1, a2) {
+  let i = 0, j = r.pos.length;
+  while (i < j) {
+    const m = i + j >> 1;
+    if (r.pos[m] < at - EDGE_NEAR2) i = m + 1;
+    else j = m;
+  }
+  const spans = [];
+  for (; i < r.pos.length && r.pos[i] <= at + EDGE_NEAR2; i++) {
+    const l = r.lines[i];
+    const l1 = r.dir === "h" ? Math.min(l.x1, l.x2) : Math.min(l.y1, l.y2), l2 = r.dir === "h" ? Math.max(l.x1, l.x2) : Math.max(l.y1, l.y2);
+    const lo = Math.max(a1, l1), hi = Math.min(a2, l2);
+    if (hi <= lo || l1 < a1 !== l2 > a2 && hi - lo < TIP_MAX) continue;
+    spans.push([lo, hi]);
+  }
+  if (!spans.length) return 0;
+  spans.sort((p, q) => p[0] - q[0]);
+  let covered = 0, s = spans[0][0], e = spans[0][1];
+  for (const [lo, hi] of spans.slice(1)) {
+    if (lo <= e + DASH_GAP) e = Math.max(e, hi);
+    else {
+      covered += e - s;
+      s = lo;
+      e = hi;
+    }
+  }
+  return covered + e - s;
+}
+function edgesOf(box, h, v) {
+  return {
+    t: seen(h, box.y2, box.x1, box.x2),
+    b: seen(h, box.y1, box.x1, box.x2),
+    l: seen(v, box.x1, box.y1, box.y2),
+    r: seen(v, box.x2, box.y1, box.y2)
+  };
+}
+function recordClipCellEdges(grids, horizontals, verticals, nonRules) {
+  if (!grids.some((g) => g.cells)) return;
+  const h = rules(nonRules?.size ? horizontals.filter((l) => !nonRules.has(l)) : horizontals, "h");
+  const v = rules(nonRules?.size ? verticals.filter((l) => !nonRules.has(l)) : verticals, "v");
+  for (const g of grids) for (const c of g.cells ?? []) CLIP_CELL_EDGES.set(c, edgesOf(c.bbox, h, v));
+}
+function takeClipCellEdges(from, to) {
+  const e = CLIP_CELL_EDGES.get(from);
+  if (e) CELL_EDGES.set(to, e);
+}
+function joinCellEdges(a, b) {
+  const u = CELL_EDGES.get(a), d = CELL_EDGES.get(b);
+  if (!u || !d) return;
+  CELL_EDGES.set(a, { t: u.t, b: d.b, l: u.l || d.l, r: u.r || d.r });
+}
+
 // src/pdf/page-frame.ts
 function isPageFrameGrid(grid, cells, pageWidth, pageHeight, items = []) {
   const b = grid.bbox;
@@ -5770,8 +5951,8 @@ function detectRuledBandTables(horizontals, verticals, items, pageNum) {
   };
   for (const g of groups) {
     if (g.length < 2) continue;
-    const rules = [...g].sort((a, b) => b.y1 - a.y1);
-    const x1 = Math.min(...rules.map((r) => r.x1)), x2 = Math.max(...rules.map((r) => r.x2));
+    const rules2 = [...g].sort((a, b) => b.y1 - a.y1);
+    const x1 = Math.min(...rules2.map((r) => r.x1)), x2 = Math.max(...rules2.map((r) => r.x2));
     let run = [];
     const flush = () => {
       if (run.length >= 2) emit(run, x1, x2);
@@ -5785,8 +5966,8 @@ function detectRuledBandTables(horizontals, verticals, items, pageNum) {
       run = [];
     };
     let title = null;
-    for (let i = 0; i + 1 < rules.length; i++) {
-      const top = rules[i].y1, bottom = rules[i + 1].y1;
+    for (let i = 0; i + 1 < rules2.length; i++) {
+      const top = rules2[i].y1, bottom = rules2[i + 1].y1;
       const band = lines.filter((l) => l[0].y < top && l[0].y > bottom);
       const inside = !band.some((l) => l.some((it) => it.x < x1 - EDGE_TOL3 || it.x + it.w > x2 + EDGE_TOL3));
       const fs = median(band.flat().map((it) => it.fontSize).filter((s) => s > 0)) || 10;
@@ -6204,6 +6385,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   for (const line of streamLines(items)) lex.addLine(mergeLineSimple(line));
   const extracted = extractLines(opList.fnArray, opList.argsArray);
   let { horizontals, verticals } = extracted;
+  const rawRules = extracted.horizontals.concat(extracted.shortH);
   const filled = fillBlanks(items, horizontals, verticals);
   items = filled.items;
   horizontals = filled.horizontals;
@@ -6214,6 +6396,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
     carry.clip = clipResult.page;
   }
   const clipGrids = clipResult.grids;
+  recordClipCellEdges(clipGrids, horizontals.concat(extracted.shortH), verticals.concat(extracted.shortV), extracted.nonRules);
   if (clipGrids.length === 0) {
     horizontals = chainShortSegments(horizontals, extracted.shortH, "h");
     verticals = chainShortSegments(verticals, extracted.shortV, "v");
@@ -6245,7 +6428,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   if (detectTables && clipGrids.length === 0 && ruled.length === 0 && lineGrids.length === 0) ruled.push(...detectTextBoxTables(extracted.hiddenBoxes, items, pageNum));
   if (ruled.length > 0) {
     const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
-    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, ruled);
+    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, ruled, rawRules);
   }
   if (detectTables && stackedTableBands(items)) {
     return extractPageBlocksFallback(items, pageNum, true, detectTables, lex);
@@ -6256,7 +6439,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   }
   if (grids.length > 0) {
     const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
-    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex);
+    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, [], rawRules);
   }
   const figures = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 40 && r.y2 - r.y1 >= 40).map((r) => ({ x: r.x1, y: r.y1, w: r.x2 - r.x1, h: r.y2 - r.y1 }));
   return extractPageBlocksFallback(items, pageNum, true, detectTables, lex, figures);
@@ -6399,7 +6582,7 @@ function buildFrameCellBlocks(cellItems, nested, pageNum, wrap) {
   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, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions = [], lex, ruled = []) {
+function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions = [], lex, ruled = [], rawRules = horizontals) {
   const ocrPage = items.length > 0 && items.every((i) => i.fontName === "ocr");
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
@@ -6461,6 +6644,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
         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);
+        takeClipCellEdges(cell, irGrid[cell.row][cell.col]);
         continue;
       }
       irGrid[cell.row][cell.col] = {
@@ -6478,6 +6662,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       }
       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);
+      takeClipCellEdges(cell, irGrid[cell.row][cell.col]);
     }
     let finalGrid = irGrid;
     let finalRows = numRows;
@@ -6521,6 +6706,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       const inset = line.length ? grid.bbox.x2 - (line[line.length - 1].x + line[line.length - 1].w) : 0;
       if (line.length && /^\s*\(\s*단위\s*[:：]/.test(text) && inset >= 4.6 && inset <= 5.6) {
         finalGrid.unshift(Array.from({ length: numCols }, (_, c) => ({ text: c === 0 ? cleanCellText(text) : "", colSpan: c === 0 ? numCols : 1, rowSpan: 1 })));
+        if (grid.cells) for (const u of finalGrid[0]) CELL_EDGES.set(u, NO_EDGES);
         finalRows++;
         for (const item of line) usedItems.add(item);
       }
@@ -6574,8 +6760,12 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       hasHeader: finalRows > 1,
       ...semanticOneColumn ? { renderAsTable: true } : {}
     };
-    if (grid.cells) CLIP_TABLES.add(irTable);
+    if (grid.cells) {
+      CLIP_TABLES.add(irTable);
+      recordRowRules(irTable, grid.cells, grid.bbox, rawRules);
+    }
     TABLE_COLXS.set(irTable, grid.colXs);
+    if (grid.cells && finalRows === numRows) TABLE_ROWYS.set(irTable, grid.rowYs);
     if (grid.continues) CONT_PARTS.set(irTable, grid.continues);
     const hasContent = finalGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
     const emptyPart = !hasContent && !!grid.cells && !grid.clipParent && !nestedAttached;
@@ -7071,12 +7261,18 @@ export {
   removeHeaderFooterBlocks,
   CLIP_TABLES,
   TABLE_COLXS,
+  TABLE_ROWYS,
+  TABLE_TAIL,
+  PART_COLXS,
   EMPTY_PARTS,
   IMAGE_CELLS,
   FILLER_CELLS,
   CONT_PARTS,
   CELL_LINES,
+  ROW_RULES,
   trimTrailingEmptyTableCols,
+  NO_EDGES,
+  joinCellEdges,
   extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-SFEQYKYJ.js.map
+//# sourceMappingURL=chunk-WN6OD2CQ.js.map