kordoc 4.14.3 → 4.15.0

package/dist/{chunk-UVVEBI22.js → chunk-23AJ65GX.js}

@@ -2,11 +2,11 @@ import {
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3
-} from "./chunk-2LQGSDZ6.js";
+} from "./chunk-6CUIXJOC.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-L5EH2NVO.js";
+} from "./chunk-6Y6KUOA6.js";
 
 // src/pdf/image-regions.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -68,6 +68,8 @@ var MAX_LINE_WIDTH = 5;
 function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
+  const shortH = [];
+  const shortV = [];
   const clipRects = [];
   const fillRects = [];
   let pathRects = [];
@@ -116,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 = [];
   }
@@ -247,7 +249,56 @@ function extractLines(fnArray, argsArray) {
         break;
     }
   }
-  return { horizontals, verticals, clipRects, fillRects };
+  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;
@@ -265,11 +316,21 @@ function captureClipRect(path, out, minW = CLIP_MIN_W, minH = CLIP_MIN_H) {
   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);
@@ -750,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]];
@@ -972,6 +1050,7 @@ 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;
@@ -1023,7 +1102,8 @@ function edgeStroked(lines, dir, pos, a1, a2) {
   }
   return false;
 }
-function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, textPoints = [], fillRects = []) {
+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 = [];
@@ -1032,16 +1112,24 @@ 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 || area(cells[j]) <= area(cells[i]) || !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);
@@ -1068,7 +1156,7 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   const effParent = (i) => {
     let p = parent[i];
     for (let steps = 0; p >= 0 && steps <= cells.length; steps++) {
-      if (!tableClip[p] && (isGridMember(p) || loneFrame(p))) return p;
+      if (!tableClip[p] && (isGridMember(p) || loneFrame(p) || continues(p))) return p;
       p = parent[p];
     }
     return -1;
@@ -1091,6 +1179,11 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
       }
     }
   }
+  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);
@@ -1104,6 +1197,17 @@ 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 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 = [];
@@ -1112,7 +1216,8 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     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],
@@ -1120,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;
@@ -1169,7 +1276,130 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
       ...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;
@@ -1322,6 +1552,203 @@ 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();
+  /** 줄 안에서 이웃한 두 어절("개인정보 처리") — 이어 붙인 꼴 증거(joinedWord)의 거부권 */
+  pairs = /* @__PURE__ */ new Set();
+  /** 줄 글 한 줄을 증거로 더한다 — 탭(큰 갭)으로 나뉜 조각은 다른 칸·단이라 조각 사이는 어절 경계 증거로 쓰지 않는다 */
+  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);
+        if (i + 1 < toks.length) this.pairs.add(t + " " + toks[i + 1]);
+        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;
+  }
+  /** 꺾인 두 조각을 이어 붙인 꼴이 줄 안 한 어절로 나왔고, 두 조각이 줄 안에서 띄어 쓴 이웃 어절로는 나온 적 없나 */
+  joinedWord(left, right) {
+    return this.isWord(left + right) && !this.pairs.has(left + " " + right);
+  }
+  /** 꺾인 자리 증거: "" 붙음 · " " 띄움 · 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|\uC778|\uC778\uB370|\uC778\uC9C0|\uC784|\uC774\uC5B4\uC57C|\uC774\uBBC0\uB85C|\uC774\uC9C0\uB9CC|\uC774\uBA74\uC11C)${TAIL}$`);
+var PARTICLE_AFTER_VOWEL = new RegExp(`^(?:\uAC00|\uC640|\uB77C\uB294)${TAIL}$`);
+var ENDING = new RegExp(`^(?:\uC5B4\uC57C|\uC544\uC57C|\uC5EC\uC57C|\uBBC0\uB85C|\uC73C\uBBC0\uB85C|\uC9C0\uB9CC|\uBA74\uC11C|\uC73C\uBA74\uC11C|\uC73C\uBA70|\uAC70\uB098|\uB354\uB77C\uB3C4|\uB4E0\uC9C0|\uC5C8\uB2E4|\uC558\uB2E4|\uC600\uB2E4|\uC5C8\uC73C\uBA70|\uC558\uC73C\uBA70|\uC600\uC73C\uBA70|\uC5C8\uACE0|\uC558\uACE0|\uC600\uACE0|\uACA0\uB2E4|\uACA0\uACE0|\uACA0\uC73C\uBA70|\uC2B5\uB2C8\uB2E4|\uB2C8\uB2E4|\uB2C8\uAE4C)${TAIL}$`);
+var ADNOMINAL_HAN = new RegExp(`^\uD55C${TAIL}$`);
+var SUFFIX_JEOK = new RegExp(`^\uC801(?:\uC778|\uC73C\uB85C|\uC774\uB2E4|\uC774\uBA70|\uC774\uACE0|\uC784|\uC778\uB370|\uC774\uB77C|\uC774\uC9C0\uB9CC|\uC73C\uB85C\uC11C)${TAIL}$`);
+var SPLIT_PARTICLE = [["\uC5D0", new RegExp(`^\uC11C(?:\uB294|\uB3C4|\uC758|\uBD80\uD130|\uB9CC)?${TAIL}$`)], ["\uC774", new RegExp(`^\uB098${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|\uD558\uAE30|\uD558\uAC8C|\uD558\uC9C0|\uD558\uAC70\uB098|\uD574\uC11C|\uD558\uB294\uB370|\uD568\uC73C\uB85C\uC368|\uD568\uC5D0|\uD568\uC744|\uD568\uC774|\uD558\uAE30\uC5D0|\uD558\uAE30\uB3C4|\uB418\uC9C0|\uB418\uAE30|\uB418\uB3C4\uB85D|\uB418\uAC70\uB098|\uB418\uBA74\uC11C)${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, rightWord) {
+  const right = rightWord.replace(/[”’"」』].+$/, "");
+  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 (SUFFIX_JEOK.test(right)) return true;
+  if (ENDING.test(right)) return true;
+  if (/^다[.;:!?]/.test(right)) return true;
+  if (SPLIT_PARTICLE.some(([a, b]) => last === a && b.test(right))) return true;
+  if (PARTICLE_AFTER_CONS.test(right)) return hasBatchim(last);
+  if (PARTICLE_AFTER_VOWEL.test(right)) return !hasBatchim(last);
+  if (ADNOMINAL_HAN.test(right)) return h.length >= 2 && !AUX_BEFORE.test(h) && !/(?:는|은|한|다|어|년)$/.test(h);
+  return VERB_FORM.test(right) && !AUX_BEFORE.test(h) && !((last === "\uC774" || last === "\uAC00" && h.length >= 3) && 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) && !/[·ㆍ‧…]{2}$/.test(prev) && /[가-힣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 (lex && /[가-힣A-Za-z0-9]$/.test(left) && /^[가-힣A-Za-z0-9]/.test(right) && lex.joinedWord(left, right.replace(/[.,)」』’”;:]+$/, ""))) return "";
+  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;
+var BODY_PITCH_REL = 1.05;
+var BODY_MAX_PITCH_ABS_EM = 3.5;
+function bodyLineJoins(lines, lex) {
+  let right = -Infinity;
+  for (const l of lines) if (l.right > right) right = l.right;
+  const pitch = (k) => lines[k].y - lines[k + 1].y;
+  const sameSize = (k) => Math.abs(lines[k + 1].fontSize - lines[k].fontSize) <= 0.15 * lines[k].fontSize;
+  let p1 = Infinity, p2 = Infinity, i1 = -1;
+  for (let k = 0; k + 1 < lines.length; k++) {
+    const p = pitch(k);
+    if (p <= 0 || !sameSize(k)) continue;
+    if (p < p1) {
+      p2 = p1;
+      p1 = p;
+      i1 = k;
+    } else if (p < p2) p2 = p;
+  }
+  const out = [];
+  for (let i = 0; i + 1 < lines.length; i++) {
+    const a = lines[i], b = lines[i + 1];
+    const fs = a.fontSize;
+    const others = i === i1 ? p2 : p1;
+    const maxPitch = Number.isFinite(others) ? Math.min(BODY_MAX_PITCH_ABS_EM * fs, Math.max(BODY_MAX_PITCH_EM * fs, others * BODY_PITCH_REL)) : BODY_MAX_PITCH_EM * fs;
+    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 < maxPitch && 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;
+}
+function cellLineFills(box, contentLeft, cellRight, lineRight, fontSize) {
+  const pad = Math.min(CELL_PAD_MAX, Math.max(0, contentLeft - box.x1));
+  return fontSize > 0 && cellRight - lineRight < BODY_FULL_TOL * fontSize && lineRight - contentLeft >= 0.8 * (box.x2 - box.x1 - 2 * pad);
+}
+
 // src/pdf/cell-text.ts
 var CELL_PADDING = 2;
 var SPACE_GAP_RATIO = 0.17;
@@ -1355,9 +1782,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);
@@ -1398,7 +1863,20 @@ 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) };
+  });
+  let cellRight = -Infinity;
+  for (const e of lineEnds) if (e.right > cellRight) cellRight = e.right;
+  const wraps = lineEnds.slice(0, -1).map((a, i) => cellLineWraps(wrap.box, contentLeft, a.right, a.fontSize, lineEnds[i + 1].firstCharW) || lineEnds.length >= 3 && !textLines[i + 1].startsWith("(") && cellLineFills(wrap.box, contentLeft, cellRight, a.right, a.fontSize));
+  return mergeCellTextLines(textLines, { wraps, lex: wrap.lex });
 }
 function mergeSuperscriptRows(lines) {
   if (lines.length <= 1) return lines;
@@ -1469,6 +1947,12 @@ function detectEvenSpacedItems(items) {
   return result;
 }
 function markEvenRun(items, result, start, end) {
+  let dateOnly = true;
+  for (let i = start; i < end; i++) if (!/^[년월일시분초]$/.test(items[i].text)) {
+    dateOnly = false;
+    break;
+  }
+  if (dateOnly) return;
   const gaps = [];
   for (let i = start + 1; i < end; i++) {
     gaps.push(items[i].x - (items[i - 1].x + items[i - 1].w));
@@ -1487,19 +1971,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 && !(/\d{1,3}(,\d{3})+$/.test(prev) && /^\d{1,3}(,\d{3})+$/.test(curr.trim()))) {
+    } 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);
@@ -1654,14 +2138,14 @@ function filterHiddenText(items, pageWidth, pageHeight) {
   }
   return { visible, hiddenCount };
 }
-function collapseEvenSpacing(text) {
+function collapseEvenSpacing(text, whole = true) {
   const tokens = text.split(" ");
   const singleCharCount = tokens.filter((t) => t.length === 1).length;
-  if (tokens.length >= 3 && singleCharCount / tokens.length >= 0.7 && !isDateUnitBlank(tokens)) {
+  if (whole && tokens.length >= 3 && singleCharCount / tokens.length >= 0.7 && !isDateUnitBlank(tokens)) {
     return tokens.join("");
   }
   return text.replace(
-    /(?<![가-힣])[가-힣](?: [가-힣\d]){2,}(?![가-힣])/g,
+    /(?<![^\s>])[가-힣](?: [가-힣\d]){2,}(?![^\s<])/g,
     (match) => isDateUnitBlank(match.split(" ")) ? match : match.replace(/ /g, "")
   );
 }
@@ -1743,6 +2227,7 @@ function normalizeItems(rawItems) {
     }
     if (!isDup) deduped.push(sorted[i]);
   }
+  splitOverlaidRuns(deduped);
   if (spacePositions.length > 0) {
     for (const sp of spacePositions) {
       let nearest = null;
@@ -1758,6 +2243,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(" ");
@@ -1883,7 +2460,7 @@ function detectHeadings(blocks, medianFontSize) {
     if (level > 0) {
       block.type = "heading";
       block.level = level;
-      block.text = collapseEvenSpacing(text);
+      block.text = collapseEvenSpacing(text, false);
     }
   }
 }
@@ -2247,6 +2824,7 @@ 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 = [];
@@ -2802,7 +3380,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);
@@ -2825,6 +3403,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();
@@ -2875,6 +3454,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;
@@ -3207,7 +3809,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) {
@@ -3309,12 +3914,9 @@ function extractWithColumns(yLines, columns) {
 function buildGridTable(lines, columns) {
   const numCols = columns.length;
   const yRows = lines.map((items) => {
-    const row = Array(numCols).fill("");
-    for (const item of items) {
-      const col = findColumn(item.x, columns);
-      row[col] = row[col] ? row[col] + " " + item.text : item.text;
-    }
-    return row;
+    const byCol = Array.from({ length: numCols }, () => []);
+    for (const item of items) byCol[findColumn(item.x, columns)].push(item);
+    return byCol.map((cell) => mergeLineSimple(cell));
   });
   const dataColStart = Math.max(2, Math.floor(numCols / 2));
   const merged = [];
@@ -3512,12 +4114,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 })), extracted.fillRects) : { 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);
@@ -3532,12 +4148,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) {
     const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
-    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, imageRegions);
+    return 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;
@@ -3646,13 +4263,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 });
     }
@@ -3667,7 +4284,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, imageRegions = []) {
+function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, imageRegions = [], lex) {
   const blocks = [];
   const usedItems = /* @__PURE__ */ new Set();
   const pendingNested = [];
@@ -3717,12 +4334,13 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, i
       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
       };
@@ -3760,6 +4378,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, i
       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() !== ""));
     const emptyPart = !hasContent && !!grid.cells && !grid.clipParent && !nestedAttached;
     if (!hasContent && !emptyPart) continue;
@@ -3846,7 +4465,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, i
         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);
         }
@@ -3859,7 +4478,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals, i
       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);
       }
@@ -3969,7 +4588,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) => ({
@@ -3995,15 +4649,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;
@@ -4034,12 +4680,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);
         }
       }
     }
@@ -4052,6 +4693,9 @@ export {
   filterHiddenText,
   collapseEvenSpacing,
   normalizeItems,
+  WrapLexicon,
+  wrapJoiner,
+  joinPageBreakWraps,
   computeMedianFontSizeFromFreq,
   detectHeadings,
   detectMarkerHeadings,
@@ -4063,8 +4707,9 @@ export {
   EMPTY_PARTS,
   IMAGE_CELLS,
   FILLER_CELLS,
+  CONT_PARTS,
   CELL_LINES,
   trimTrailingEmptyTableCols,
   extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-UVVEBI22.js.map
+//# sourceMappingURL=chunk-23AJ65GX.js.map