kordoc 4.21.11 → 4.21.13

package/dist/{chunk-PUAKSOZD.js → chunk-3YD3SAQW.js}

@@ -1,88 +1,15 @@
+#!/usr/bin/env node
 import {
   CELL_EDGES,
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
   HEADING_RATIO_H3,
   tidyScriptTags
-} from "./chunk-FUXOABQZ.js";
-import {
-  ensureModelsIn,
-  getModelsDir
-} from "./chunk-N2GL4NZH.js";
+} from "./chunk-YM4AEOS4.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-LZGPS3FH.js";
-
-// src/ocr/models.ts
-import { join } from "path";
-import { stat } from "fs/promises";
-var OCR_DET_MODEL = {
-  name: "PP-OCRv5 mobile det",
-  filename: "det.onnx",
-  url: "https://huggingface.co/PaddlePaddle/PP-OCRv5_mobile_det_onnx/resolve/main/inference.onnx",
-  sha256: "a431985659dc921974177a95adcfbb90fd9e51989a5e04d70d0b75f597b6e61d",
-  sizeMb: 5
-};
-var OCR_REC_MODEL = {
-  name: "PP-OCRv5 korean rec",
-  filename: "rec_korean.onnx",
-  url: "https://huggingface.co/PaddlePaddle/korean_PP-OCRv5_mobile_rec_onnx/resolve/main/inference.onnx",
-  sha256: "92f0b7785e64fc9090106a241cf4c1eb97472824558272751b88a2a4476d3a08",
-  sizeMb: 13
-};
-var OCR_REC_DICT = {
-  name: "PP-OCRv5 korean dict",
-  filename: "rec_korean.yml",
-  url: "https://huggingface.co/PaddlePaddle/korean_PP-OCRv5_mobile_rec_onnx/resolve/main/inference.yml",
-  sha256: "f757fa1c40e99edcf27e9cce879b93eb2a51fa46f5ef39095689b8c37dd75998",
-  sizeMb: 1
-};
-var ALL_OCR_MODELS = [OCR_DET_MODEL, OCR_REC_MODEL, OCR_REC_DICT];
-function getOcrModelsDir() {
-  return getModelsDir("ppocr");
-}
-async function ensureOcrModels(onProgress) {
-  return ensureModelsIn(getOcrModelsDir(), ALL_OCR_MODELS, onProgress);
-}
-async function ocrModelsCached() {
-  const dir = getOcrModelsDir();
-  for (const spec of ALL_OCR_MODELS) {
-    try {
-      if (!(await stat(join(dir, spec.filename))).size) return false;
-    } catch {
-      return false;
-    }
-  }
-  return true;
-}
-function parseCharacterDict(yml) {
-  const lines = yml.split("\n");
-  const chars = [];
-  let inDict = false;
-  let dictIndent = -1;
-  for (const line of lines) {
-    if (!inDict) {
-      const m2 = /^(\s*)character_dict:\s*$/.exec(line);
-      if (m2) {
-        inDict = true;
-        dictIndent = m2[1].length;
-      }
-      continue;
-    }
-    const m = /^(\s*)- (.*)$/.exec(line);
-    if (m && m[1].length >= dictIndent) {
-      let v = m[2];
-      if (v.length >= 2 && (v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"'))) {
-        v = v.slice(1, -1).replace(/''/g, "'");
-      }
-      chars.push(v);
-      continue;
-    }
-    if (line.trim() !== "") break;
-  }
-  return chars;
-}
+} from "./chunk-LXYM2EST.js";
 
 // src/pdf/line-extract.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -1128,21 +1055,21 @@ 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 near2 = (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 sourceCells = c.cells.filter((cell) => !cell.filler);
     if (sourceCells.length === 0) return true;
-    const shaded = sourceCells.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)));
+    const shaded = sourceCells.every((cell) => fillRects.some((f) => near2(f.x1, cell.bbox.x1) && near2(f.x2, cell.bbox.x2) && near2(f.y1, cell.bbox.y1) && near2(f.y2, cell.bbox.y2)));
     if (!shaded) return true;
     const ruled = sourceCells.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) => (
       // Inferred filler cells carry no boundary evidence. Replace their frame only
       // with a finer ruled grid of the same extent, never a larger surrounding form.
-      (!c.cells.some((cell) => cell.filler) || near(c.bbox.x1, l.bbox.x1) && near(c.bbox.x2, l.bbox.x2) && near(c.bbox.y1, l.bbox.y1) && near(c.bbox.y2, l.bbox.y2) && l.rowYs.length > c.rowYs.length && sourceCells.every((cell) => [cell.bbox.y1, cell.bbox.y2].every((y) => l.rowYs.some((ly) => near(y, ly))))) && 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 + (o.cells?.some((cell) => cell.filler) ? o.cells.filter((cell) => !cell.filler).reduce((a, cell) => a + inter(cell.bbox, l.bbox), 0) : inter(o.bbox, l.bbox)), 0) <= area(l.bbox) * SHADE_CLIP_MAX_AREA || l.rowYs.length === c.rowYs.length + 1 && c.rowYs.every((y, i) => near(y, l.rowYs[i])) && l.colXs.length === c.colXs.length && c.colXs.every((x, i) => near(x, l.colXs[i])) && !clipGrids.some((o) => o !== c && inter(o.bbox, l.bbox) > 0))
+      (!c.cells.some((cell) => cell.filler) || near2(c.bbox.x1, l.bbox.x1) && near2(c.bbox.x2, l.bbox.x2) && near2(c.bbox.y1, l.bbox.y1) && near2(c.bbox.y2, l.bbox.y2) && l.rowYs.length > c.rowYs.length && sourceCells.every((cell) => [cell.bbox.y1, cell.bbox.y2].every((y) => l.rowYs.some((ly) => near2(y, ly))))) && 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) => near2(lx, x))) && (clipGrids.reduce((s, o) => s + (o.cells?.some((cell) => cell.filler) ? o.cells.filter((cell) => !cell.filler).reduce((a, cell) => a + inter(cell.bbox, l.bbox), 0) : inter(o.bbox, l.bbox)), 0) <= area(l.bbox) * SHADE_CLIP_MAX_AREA || l.rowYs.length === c.rowYs.length + 1 && c.rowYs.every((y, i) => near2(y, l.rowYs[i])) && l.colXs.length === c.colXs.length && c.colXs.every((x, i) => near2(x, l.colXs[i])) && !clipGrids.some((o) => o !== c && inter(o.bbox, l.bbox) > 0))
     ));
     return !host;
   });
@@ -1150,14 +1077,14 @@ function dropShadingClipGrids(clipGrids, lineGrids, fillRects, verticals = []) {
 var INSET_CLIP_MIN = 2;
 function dropInsetClipGrids(clipGrids, lineGrids) {
   if (clipGrids.length === 0 || lineGrids.length === 0) return clipGrids;
-  const near = (a, b) => Math.abs(a - b) <= SHADE_CLIP_TOL;
-  return clipGrids.filter((c) => c.clipParent || c.rowYs.length !== 2 || !lineGrids.some((l) => l.rowYs.length >= 3 && near(c.bbox.x1, l.bbox.x1) && near(c.bbox.x2, l.bbox.x2) && l.rowYs.some((top, r) => r + 1 < l.rowYs.length && top - c.bbox.y2 >= INSET_CLIP_MIN && c.bbox.y1 - l.rowYs[r + 1] >= INSET_CLIP_MIN)));
+  const near2 = (a, b) => Math.abs(a - b) <= SHADE_CLIP_TOL;
+  return clipGrids.filter((c) => c.clipParent || c.rowYs.length !== 2 || !lineGrids.some((l) => l.rowYs.length >= 3 && near2(c.bbox.x1, l.bbox.x1) && near2(c.bbox.x2, l.bbox.x2) && l.rowYs.some((top, r) => r + 1 < l.rowYs.length && top - c.bbox.y2 >= INSET_CLIP_MIN && c.bbox.y1 - l.rowYs[r + 1] >= INSET_CLIP_MIN)));
 }
 function dropHeadBandClipGrids(clipGrids, lineGrids) {
   if (clipGrids.length === 0 || lineGrids.length === 0) return clipGrids;
-  const near = (a, b) => Math.abs(a - b) <= SHADE_CLIP_TOL;
+  const near2 = (a, b) => Math.abs(a - b) <= SHADE_CLIP_TOL;
   const overlaps = (a, b) => Math.min(a.x2, b.x2) > Math.max(a.x1, b.x1) && Math.min(a.y2, b.y2) > Math.max(a.y1, b.y1);
-  return clipGrids.filter((c) => c.clipParent || !c.cells?.length || !lineGrids.some((l) => l.rowYs.length > c.rowYs.length && l.colXs.length === c.colXs.length && c.colXs.every((x, k) => near(x, l.colXs[k])) && c.rowYs.every((y, k) => near(y, l.rowYs[k])) && !clipGrids.some((o) => o !== c && overlaps(o.bbox, l.bbox))));
+  return clipGrids.filter((c) => c.clipParent || !c.cells?.length || !lineGrids.some((l) => l.rowYs.length > c.rowYs.length && l.colXs.length === c.colXs.length && c.colXs.every((x, k) => near2(x, l.colXs[k])) && c.rowYs.every((y, k) => near2(y, l.rowYs[k])) && !clipGrids.some((o) => o !== c && overlaps(o.bbox, l.bbox))));
 }
 function enforceMinWidth(colXs, minWidth, narrowRuns = true) {
   if (colXs.length <= 2) return colXs;
@@ -1372,17 +1299,17 @@ function groupConnectedLines(lines, tol = CONNECT_TOL) {
     const ra = find(a), rb = find(b);
     if (ra !== rb) parent[ra] = rb;
   }
-  const span = lines.map((l) => [
+  const span2 = lines.map((l) => [
     Math.floor((Math.min(l.x1, l.x2) - CONNECT_TOL) / GROUP_BUCKET_CELL),
     Math.floor((Math.max(l.x1, l.x2) + CONNECT_TOL) / GROUP_BUCKET_CELL),
     Math.floor((Math.min(l.y1, l.y2) - CONNECT_TOL) / GROUP_BUCKET_CELL),
     Math.floor((Math.max(l.y1, l.y2) + CONNECT_TOL) / GROUP_BUCKET_CELL)
   ]);
-  const startXs = [...new Set(span.map((s) => s[0]))].filter(Number.isFinite).sort((a, b) => a - b);
-  const startYs = [...new Set(span.map((s) => s[2]))].filter(Number.isFinite).sort((a, b) => a - b);
+  const startXs = [...new Set(span2.map((s) => s[0]))].filter(Number.isFinite).sort((a, b) => a - b);
+  const startYs = [...new Set(span2.map((s) => s[2]))].filter(Number.isFinite).sort((a, b) => a - b);
   const cellMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
-    const [cx1, cx2, cy1, cy2] = span[i];
+    const [cx1, cx2, cy1, cy2] = span2[i];
     for (let a = lowerBound(startXs, cx1); a < startXs.length && startXs[a] <= cx2; a++) {
       for (let b = lowerBound(startYs, cy1); b < startYs.length && startYs[b] <= cy2; b++) {
         const key = startXs[a] + "," + startYs[b];
@@ -1596,14 +1523,14 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
   for (let i = 0; i < cells.length; i++) {
     if (tableClip[i]) continue;
     const candidates = /* @__PURE__ */ new Set();
-    const near = (map, v) => {
+    const near2 = (map, v) => {
       const k = edgeBin(v);
       for (let d = -1; d <= 1; d++) for (const j of map.get(k + d) ?? []) if (j > i) candidates.add(j);
     };
-    near(startsX, cells[i].x2);
-    near(endsX, cells[i].x1);
-    near(startsY, cells[i].y2);
-    near(endsY, cells[i].y1);
+    near2(startsX, cells[i].x2);
+    near2(endsX, cells[i].x1);
+    near2(startsY, cells[i].y2);
+    near2(endsY, cells[i].y1);
     for (const j of [...candidates].sort((a, b) => a - b)) {
       if (tableClip[j] || parent[i] !== parent[j]) continue;
       if (adjacent(cells[i], cells[j])) {
@@ -1858,13 +1785,13 @@ function closeGaps(members, gaps) {
     if (repeatedBlankColumn(l) && !atLo && !atHi) continue;
     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 span2 = (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]);
+        const [a1, a2] = span2(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);
@@ -2730,8 +2657,10 @@ function mergeCellTextLines(textLines, wrap) {
       merged[merged.length - 1] = prev + curr.trim();
     } 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,\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()) && !numberWrapped(i - 1)) && !(/(?:^|\s)\d{1,7}$/.test(prev) && /^\d{1,7}$/.test(curr.trim()) && !numberWrapped(i - 1))) {
+    } else if (/[\d,]$/.test(prev) && /^[\d,]+[)\]]?$/.test(curr.trim()) && curr.trim().length <= 10 && !(/\d,\d{3}$/.test(prev) && /^\d/.test(curr.trim())) && !(wrap && !numberWrapped(i - 1)) && !(/(?:^|[^\d,])\d{1,3}$/.test(prev) && /^(\d{1,3}(,\d{3})+|\d{1,3})$/.test(curr.trim()) && !numberWrapped(i - 1)) && !(/(?:^|\s)\d{1,7}$/.test(prev) && /^\d{1,7}$/.test(curr.trim()) && !numberWrapped(i - 1))) {
       merged[merged.length - 1] = prev + curr.trim();
+    } else if (wrap && /[A-Za-z가-힣]/.test(prev) && /,$/.test(prev.trim()) && /^[\d,]+[)\]]?$/.test(curr.trim()) && curr.trim().length <= 10) {
+      merged[merged.length - 1] = prev.trimEnd() + " " + curr.trim();
     } else {
       merged.push(curr);
     }
@@ -3178,7 +3107,7 @@ function isAttachedScripts(line, host) {
     if (n > 8 || !n) return false;
     return host.some((h) => {
       const after = i.x - (h.x + h.w), before = h.x - (i.x + i.w);
-      return n <= 3 && after <= h.fontSize * 0.35 && after >= -h.fontSize * 0.1 || PREFIX_SCRIPT.test(t) && before <= h.fontSize * 0.6 && before >= -h.fontSize * 0.1;
+      return n <= 3 && after <= h.fontSize * 0.35 && after >= -h.fontSize * 0.25 || PREFIX_SCRIPT.test(t) && before <= h.fontSize * 0.6 && before >= -h.fontSize * 0.25;
     });
   });
 }
@@ -4505,12 +4434,12 @@ function figureColumnBands(items, figures) {
   const lines = groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x));
   if (lines.length < 10) return null;
   const minX = Math.min(...items.map((i) => i.x)), maxX = Math.max(...items.map((i) => i.x + i.w));
-  const span = maxX - minX;
-  if (span < 200) return null;
+  const span2 = maxX - minX;
+  if (span2 < 200) return null;
   const full = (line) => {
     const s = [...line].sort((a, b) => a.x - b.x);
     const fs = Math.max(...s.map((i) => i.fontSize));
-    if (s[s.length - 1].x + s[s.length - 1].w - s[0].x < span * 0.75) return false;
+    if (s[s.length - 1].x + s[s.length - 1].w - s[0].x < span2 * 0.75) return false;
     const sizeOf = (part) => {
       const by = /* @__PURE__ */ new Map();
       for (const it of part) by.set(it.fontSize, (by.get(it.fontSize) ?? 0) + it.text.length);
@@ -4539,11 +4468,11 @@ function figureColumnBands(items, figures) {
       ...figures.filter((f) => f.y < top && f.y + f.h > bottom)
     ];
     let best = null, run = null;
-    const step = Math.max(2, span * 0.4 / 400);
-    for (let x = minX + span * 0.3; x <= minX + span * 0.7; x += step) {
+    const step = Math.max(2, span2 * 0.4 / 400);
+    for (let x = minX + span2 * 0.3; x <= minX + span2 * 0.7; x += step) {
       const empty = !rects.some((r) => r.x < x && r.x + r.w > x);
       if (empty && run === null) run = x;
-      if ((!empty || x + step > minX + span * 0.7) && run !== null) {
+      if ((!empty || x + step > minX + span2 * 0.7) && run !== null) {
         if (x - run >= 8 && (!best || x - run > best.w)) best = { x: (run + x) / 2, w: x - run };
         run = null;
       }
@@ -5005,8 +4934,8 @@ function isProseGutter(items, x) {
     return full >= lines.length * 0.6;
   };
   if (!prose(left) || !prose(right)) return false;
-  const span = (lines) => [Math.min(...lines.map((l) => l.y)), Math.max(...lines.map((l) => l.y))];
-  const [l0, l1] = span(left), [r0, r1] = span(right);
+  const span2 = (lines) => [Math.min(...lines.map((l) => l.y)), Math.max(...lines.map((l) => l.y))];
+  const [l0, l1] = span2(left), [r0, r1] = span2(right);
   return Math.min(l1, r1) - Math.max(l0, r0) >= Math.min(l1 - l0, r1 - r0) * 0.5;
 }
 function splitEdgeSpannedColumns(items, gapThreshold, depth) {
@@ -5718,9 +5647,9 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
     const repeatedPatterns = /* @__PURE__ */ new Set();
     for (const [p, count] of patternCount) {
       const pages = [...patternPages.get(p) ?? []];
-      const span = pages.length ? Math.max(...pages) - Math.min(...pages) + 1 : 0;
+      const span2 = pages.length ? Math.max(...pages) - Math.min(...pages) + 1 : 0;
       const pageNumbered = !tables && (patternNumbers.get(p)?.size ?? 0) > 1;
-      if (count >= MIN_REPEAT2 && pages.length >= MIN_REPEAT2 && (pages.length >= span * 0.4 || pageNumbered)) {
+      if (count >= MIN_REPEAT2 && pages.length >= MIN_REPEAT2 && (pages.length >= span2 * 0.4 || pageNumbered)) {
         repeatedPatterns.add(p);
       }
     }
@@ -6099,12 +6028,12 @@ function arrowDirection(image) {
     const points = ink.map((p) => ({ x: mirror ? x0 + x1 - p.x : p.x, y: p.y }));
     const tail = points.filter((p) => p.x <= x0 + w * 0.25), tip = points.filter((p) => p.x >= x1 - w * 0.1);
     if (!tail.length || !tip.length) return false;
-    const span = (points2) => Math.max(...points2.map((p) => p.y)) - Math.min(...points2.map((p) => p.y)) + 1;
-    if (span(tail) > h * 0.4 || span(tip) > h * 0.45 || Math.abs((Math.max(...tail.map((p) => p.y)) + Math.min(...tail.map((p) => p.y))) / 2 - centerY) > h * 0.1 || Math.abs((Math.max(...tip.map((p) => p.y)) + Math.min(...tip.map((p) => p.y))) / 2 - centerY) > h * 0.1) return false;
+    const span2 = (points2) => Math.max(...points2.map((p) => p.y)) - Math.min(...points2.map((p) => p.y)) + 1;
+    if (span2(tail) > h * 0.4 || span2(tip) > h * 0.45 || Math.abs((Math.max(...tail.map((p) => p.y)) + Math.min(...tail.map((p) => p.y))) / 2 - centerY) > h * 0.1 || Math.abs((Math.max(...tip.map((p) => p.y)) + Math.min(...tip.map((p) => p.y))) / 2 - centerY) > h * 0.1) return false;
     let head = 0;
     for (let x = Math.ceil(x0 + w * 0.45); x <= x0 + w * 0.75; x++) {
       const column = points.filter((p) => p.x === x);
-      if (column.length) head = Math.max(head, span(column));
+      if (column.length) head = Math.max(head, span2(column));
     }
     const middle = new Set(points.filter((p) => Math.abs(p.y - centerY) <= 1).map((p) => p.x));
     return head >= h * 0.8 && middle.size >= w * 0.9;
@@ -6245,15 +6174,15 @@ function detectColumnGutter(rects) {
     if (r.x < minX) minX = r.x;
     if (r.x + r.w > maxX) maxX = r.x + r.w;
   }
-  const span = maxX - minX;
-  if (!Number.isFinite(span) || span < MIN_CONTENT_SPAN) return null;
-  const narrow = rects.filter((r) => r.w < span * WIDE_RECT_RATIO && r.w > 0 && r.h > 0);
+  const span2 = maxX - minX;
+  if (!Number.isFinite(span2) || span2 < MIN_CONTENT_SPAN) return null;
+  const narrow = rects.filter((r) => r.w < span2 * WIDE_RECT_RATIO && r.w > 0 && r.h > 0);
   if (narrow.length < SIDE_MIN_COUNT * 2) return null;
   let totalH = 0;
   for (const r of narrow) totalH += r.h;
   if (totalH <= 0) return null;
-  const lo = minX + span * GUTTER_SCAN_LO;
-  const hi = minX + span * GUTTER_SCAN_HI;
+  const lo = minX + span2 * GUTTER_SCAN_LO;
+  const hi = minX + span2 * GUTTER_SCAN_HI;
   const step = Math.max(2, (hi - lo) / GUTTER_MAX_SAMPLES);
   let gutterX = 0;
   let bestCover = Infinity;
@@ -6336,14 +6265,14 @@ function detectPersistentColumnGutter(rects) {
     if (r.y < minY) minY = r.y;
     if (r.y > maxY) maxY = r.y;
   }
-  const span = maxY - minY;
-  if (!Number.isFinite(span) || span < 200) return null;
-  const upper80 = detectColumnGutter(rects.filter((r) => r.y >= minY + span * 0.2));
-  const upper60 = upper80 === null ? null : detectColumnGutter(rects.filter((r) => r.y >= minY + span * 0.4));
+  const span2 = maxY - minY;
+  if (!Number.isFinite(span2) || span2 < 200) return null;
+  const upper80 = detectColumnGutter(rects.filter((r) => r.y >= minY + span2 * 0.2));
+  const upper60 = upper80 === null ? null : detectColumnGutter(rects.filter((r) => r.y >= minY + span2 * 0.4));
   if (upper80 !== null && upper60 !== null && Math.abs(upper80 - upper60) <= 10) return (upper80 + upper60) / 2;
-  const lower80 = detectColumnGutter(rects.filter((r) => r.y <= maxY - span * 0.2));
+  const lower80 = detectColumnGutter(rects.filter((r) => r.y <= maxY - span2 * 0.2));
   if (lower80 === null) return null;
-  const lower60 = detectColumnGutter(rects.filter((r) => r.y <= maxY - span * 0.4));
+  const lower60 = detectColumnGutter(rects.filter((r) => r.y <= maxY - span2 * 0.4));
   return lower60 !== null && Math.abs(lower80 - lower60) <= 10 ? (lower80 + lower60) / 2 : null;
 }
 function orderByGutter(units, rectOf, gutterX) {
@@ -6385,8 +6314,8 @@ function detectPanelGutters(rects) {
     if (r.x < minX) minX = r.x;
     if (r.x + r.w > maxX) maxX = r.x + r.w;
   }
-  const span = maxX - minX;
-  if (!Number.isFinite(span) || span < MIN_CONTENT_SPAN) return null;
+  const span2 = maxX - minX;
+  if (!Number.isFinite(span2) || span2 < MIN_CONTENT_SPAN) return null;
   const wideLine = (r) => {
     const same = rects.filter((o) => Math.abs(o.y - r.y) <= 3).sort((a, b) => a.x - b.x);
     let start = same[0].x, end = same[0].x + same[0].w;
@@ -6397,17 +6326,17 @@ function detectPanelGutters(rects) {
       }
       end = Math.max(end, o.x + o.w);
     }
-    return r.x >= start && r.x + r.w <= end + 1 && end - start >= span * 0.5;
+    return r.x >= start && r.x + r.w <= end + 1 && end - start >= span2 * 0.5;
   };
-  const narrow = rects.filter((r) => r.w < span * WIDE_RECT_RATIO && r.w > 0 && r.h > 0 && !wideLine(r));
+  const narrow = rects.filter((r) => r.w < span2 * WIDE_RECT_RATIO && r.w > 0 && r.h > 0 && !wideLine(r));
   for (const r of narrow) {
     if (r.y < minY) minY = r.y;
     if (r.y + r.h > maxY) maxY = r.y + r.h;
   }
   const gutters = [];
   let runStart = null;
-  const step = Math.max(2, span * 0.7 / 400);
-  for (let x = minX + span * 0.15; x <= maxX - span * 0.15; x += step) {
+  const step = Math.max(2, span2 * 0.7 / 400);
+  for (let x = minX + span2 * 0.15; x <= maxX - span2 * 0.15; x += step) {
     const empty = !narrow.some((r) => r.x < x && r.x + r.w > x);
     if (empty && runStart === null) runStart = x;
     if (!empty && runStart !== null) {
@@ -6924,6 +6853,80 @@ function headerLineAbove(free, colXs, top) {
   return cols;
 }
 
+// src/pdf/crossing-frames.ts
+var TOL = 2;
+var near = (a, b) => Math.abs(a - b) <= TOL;
+var span = (a, b) => a <= b ? [a, b] : [b, a];
+function closedRects(hs, vs) {
+  const covers = (v, x, y1, y2) => {
+    const [lo, hi] = span(v.y1, v.y2);
+    return near(v.x1, x) && lo <= y1 + TOL && hi >= y2 - TOL;
+  };
+  const out = [];
+  for (let i = 0; i < hs.length; i++) {
+    const [ax1, ax2] = span(hs[i].x1, hs[i].x2);
+    for (let j = i + 1; j < hs.length; j++) {
+      const [bx1, bx2] = span(hs[j].x1, hs[j].x2);
+      if (!near(ax1, bx1) || !near(ax2, bx2) || near(hs[i].y1, hs[j].y1)) continue;
+      const y1 = Math.min(hs[i].y1, hs[j].y1), y2 = Math.max(hs[i].y1, hs[j].y1);
+      if (!vs.some((v) => covers(v, ax1, y1, y2)) || !vs.some((v) => covers(v, ax2, y1, y2))) continue;
+      if (!out.some((o) => near(o.x1, ax1) && near(o.x2, ax2) && near(o.y1, y1) && near(o.y2, y2))) out.push({ x1: ax1, x2: ax2, y1, y2 });
+    }
+  }
+  return out;
+}
+function freeCorner(x, y, dx, dy, hs, vs) {
+  const beyondX = x + dx * 3 * TOL, beyondY = y + dy * 3 * TOL;
+  const h = hs.some((l) => {
+    const [lo, hi] = span(l.x1, l.x2);
+    return near(l.y1, y) && lo <= beyondX && hi >= beyondX;
+  });
+  const v = vs.some((l) => {
+    const [lo, hi] = span(l.y1, l.y2);
+    return near(l.x1, x) && lo <= beyondY && hi >= beyondY;
+  });
+  return !h && !v;
+}
+var strictlyInside = (x, y, r) => x > r.x1 + TOL && x < r.x2 - TOL && y > r.y1 + TOL && y < r.y2 - TOL;
+var contains3 = (a, b) => a.x1 <= b.x1 + TOL && a.x2 >= b.x2 - TOL && a.y1 <= b.y1 + TOL && a.y2 >= b.y2 - TOL;
+function cornerIn(a, b, hs, vs) {
+  for (const [x, dx] of [[a.x1, -1], [a.x2, 1]]) for (const [y, dy] of [[a.y1, -1], [a.y2, 1]]) {
+    if (strictlyInside(x, y, b) && freeCorner(x, y, dx, dy, hs, vs)) return true;
+  }
+  return false;
+}
+function hasCrossingFrames(grid, horizontals, verticals) {
+  const b = grid.bbox;
+  const inside = (l) => Math.min(l.x1, l.x2) >= b.x1 - TOL && Math.max(l.x1, l.x2) <= b.x2 + TOL && Math.min(l.y1, l.y2) >= b.y1 - TOL && Math.max(l.y1, l.y2) <= b.y2 + TOL;
+  const hs = horizontals.filter(inside), vs = verticals.filter(inside);
+  const rects = closedRects(hs, vs);
+  for (let i = 0; i < rects.length; i++) for (let j = i + 1; j < rects.length; j++) {
+    const a = rects[i], c = rects[j];
+    if (contains3(a, c) || contains3(c, a)) continue;
+    if (cornerIn(a, c, hs, vs) || cornerIn(c, a, hs, vs)) return true;
+  }
+  return false;
+}
+
+// src/pdf/spread-labels.ts
+var NUMBER = /^[-+△▲▽]?\d[\d,]*(?:\.\d+)?%?$/;
+var SPREAD = /^([가-힣]) ([가-힣])$/;
+function joinSpreadRowLabels(grid, lex, regions, boxOf, spaced) {
+  for (const row of grid) {
+    if (row.filter((c) => NUMBER.test(c.text.trim())).length < 2) continue;
+    for (const cell of row) {
+      const m = SPREAD.exec(cell.text.trim());
+      if (!m) continue;
+      const lines = CELL_LINES.get(cell), box = boxOf(cell);
+      if (!lines || lines.length !== 1 || !box || spaced(cell)) continue;
+      const { l, r, h } = lines[0];
+      if (r - l < 3 * h || r - l < box.x2 - box.x1 - 2 * h) continue;
+      const word = m[1] + m[2];
+      if (lex.startsWord(word) || lex.isWord(word) || regions.has(word)) cell.text = word;
+    }
+  }
+}
+
 // 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 });
@@ -6936,21 +6939,21 @@ 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, near = EDGE_NEAR2) {
+function seen(r, at, a1, a2, near2 = EDGE_NEAR2) {
   const len = a2 - a1;
   if (len <= 0) return false;
-  const covered = coverage(r, at, a1, a2, near);
+  const covered = coverage(r, at, a1, a2, near2);
   return covered >= len * EDGE_COVER && len - covered <= EDGE_SLACK;
 }
-function coverage(r, at, a1, a2, near) {
+function coverage(r, at, a1, a2, near2) {
   let i = 0, j = r.pos.length;
   while (i < j) {
     const m = i + j >> 1;
-    if (r.pos[m] < at - near) i = m + 1;
+    if (r.pos[m] < at - near2) i = m + 1;
     else j = m;
   }
   const spans = [];
-  for (; i < r.pos.length && r.pos[i] <= at + near; i++) {
+  for (; i < r.pos.length && r.pos[i] <= at + 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);
@@ -6983,8 +6986,8 @@ function recordClipCellEdges(grids, horizontals, verticals, nonRules) {
   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 ?? []) {
-    const near = c.filler ? Math.min(EDGE_NEAR2, (c.bbox.y2 - c.bbox.y1) / 3) : EDGE_NEAR2;
-    CLIP_CELL_EDGES.set(c, edgesOf(c.bbox, h, v, near));
+    const near2 = c.filler ? Math.min(EDGE_NEAR2, (c.bbox.y2 - c.bbox.y1) / 3) : EDGE_NEAR2;
+    CLIP_CELL_EDGES.set(c, edgesOf(c.bbox, h, v, near2));
   }
 }
 function takeClipCellEdges(from, to) {
@@ -7046,38 +7049,38 @@ function isPageFrameGrid(grid, cells, pageWidth, pageHeight, items = []) {
 
 // src/pdf/shaded-open-table.ts
 function closeShadedTableEdges(clipGrids, horizontals, verticals, fillRects) {
-  const near = (a, b) => Math.abs(a - b) <= 1.5;
+  const near2 = (a, b) => Math.abs(a - b) <= 1.5;
   let hs = horizontals, vs = verticals;
   const restored = [];
   for (const grid of clipGrids) {
     if (grid.clipParent || grid.rowYs.length !== 2 || grid.colXs.length < 3 || !grid.cells?.length || grid.cells.some((c) => c.filler || c.rowSpan !== 1 || c.colSpan !== 1)) continue;
     const { x1, x2, y1: mid, y2: top } = grid.bbox;
-    if (!grid.cells.every((c) => fillRects.some((f) => near(f.x1, c.bbox.x1) && near(f.x2, c.bbox.x2) && near(f.y1, c.bbox.y1) && near(f.y2, c.bbox.y2)))) continue;
-    const topRule = hs.find((h) => near(h.y1, top) && near(h.x1, x1) && near(h.x2, x2));
+    if (!grid.cells.every((c) => fillRects.some((f) => near2(f.x1, c.bbox.x1) && near2(f.x2, c.bbox.x2) && near2(f.y1, c.bbox.y1) && near2(f.y2, c.bbox.y2)))) continue;
+    const topRule = hs.find((h) => near2(h.y1, top) && near2(h.x1, x1) && near2(h.x2, x2));
     if (!topRule) continue;
-    const dividers = grid.colXs.slice(1, -1).map((x) => vs.find((v) => near(v.x1, x) && near(v.y2, top) && v.y1 <= mid - 6));
+    const dividers = grid.colXs.slice(1, -1).map((x) => vs.find((v) => near2(v.x1, x) && near2(v.y2, top) && v.y1 <= mid - 6));
     if (dividers.some((v) => !v)) continue;
     const bottom = dividers[0].y1;
-    if (!dividers.every((v) => near(v.y1, bottom))) continue;
-    const bottomRule = hs.find((h) => near(h.y1, bottom) && near(h.x1, x1) && near(h.x2, x2));
+    if (!dividers.every((v) => near2(v.y1, bottom))) continue;
+    const bottomRule = hs.find((h) => near2(h.y1, bottom) && near2(h.x1, x1) && near2(h.x2, x2));
     if (!bottomRule) continue;
-    const missing = [x1, x2].filter((x) => !vs.some((v) => near(v.x1, x) && v.y1 <= bottom + 1.5 && v.y2 >= top - 1.5));
+    const missing = [x1, x2].filter((x) => !vs.some((v) => near2(v.x1, x) && v.y1 <= bottom + 1.5 && v.y2 >= top - 1.5));
     if (!missing.length) continue;
     restored.push({ x1, x2, y1: bottom, y2: top });
     vs = vs.concat(missing.map((x) => ({ x1: x, x2: x, y1: bottom, y2: top, lineWidth: topRule.lineWidth })));
-    if (!hs.some((h) => near(h.y1, mid) && near(h.x1, x1) && near(h.x2, x2))) {
+    if (!hs.some((h) => near2(h.y1, mid) && near2(h.x1, x1) && near2(h.x2, x2))) {
       hs = hs.concat({ x1, x2, y1: mid, y2: mid, lineWidth: topRule.lineWidth });
     }
   }
   return { horizontals: hs, verticals: vs, restored };
 }
 function nestRestoredShadedGrids(grids, restored, horizontals, verticals) {
-  const near = (a, b) => Math.abs(a - b) <= 1.5;
+  const near2 = (a, b) => Math.abs(a - b) <= 1.5;
   if (restored.length === 0) return;
   const nested = /* @__PURE__ */ new Set();
   for (const grid of grids) {
     const b = grid.bbox;
-    if (!restored.some((r) => near(r.x1, b.x1) && near(r.x2, b.x2) && near(r.y1, b.y1) && near(r.y2, b.y2))) continue;
+    if (!restored.some((r) => near2(r.x1, b.x1) && near2(r.x2, b.x2) && near2(r.y1, b.y1) && near2(r.y2, b.y2))) continue;
     if (grids.some((g) => g !== grid && b.x1 - g.bbox.x1 >= 0.8 && g.bbox.x2 - b.x2 >= 0.8 && b.y1 - g.bbox.y1 >= 0.8 && g.bbox.y2 - b.y2 >= 0.8)) {
       grid.lineNested = true;
       nested.add(grid);
@@ -7086,10 +7089,10 @@ function nestRestoredShadedGrids(grids, restored, horizontals, verticals) {
   for (const frame of grids) {
     const b = frame.bbox;
     if (frame.lineNested || ![...nested].some((g) => g.bbox.x1 > b.x1 && g.bbox.x2 < b.x2 && g.bbox.y1 > b.y1 && g.bbox.y2 < b.y2)) continue;
-    const fullH = horizontals.filter((h) => near(h.x1, b.x1) && near(h.x2, b.x2) && h.y1 >= b.y1 - 1.5 && h.y1 <= b.y2 + 1.5);
-    if (!fullH.some((h) => near(h.y1, b.y1)) || !fullH.some((h) => near(h.y1, b.y2)) || fullH.some((h) => h.y1 > b.y1 + 1.5 && h.y1 < b.y2 - 1.5)) continue;
+    const fullH = horizontals.filter((h) => near2(h.x1, b.x1) && near2(h.x2, b.x2) && h.y1 >= b.y1 - 1.5 && h.y1 <= b.y2 + 1.5);
+    if (!fullH.some((h) => near2(h.y1, b.y1)) || !fullH.some((h) => near2(h.y1, b.y2)) || fullH.some((h) => h.y1 > b.y1 + 1.5 && h.y1 < b.y2 - 1.5)) continue;
     const fullV = verticals.filter((v) => v.y1 <= b.y1 + 1.5 && v.y2 >= b.y2 - 1.5 && v.x1 >= b.x1 - 1.5 && v.x1 <= b.x2 + 1.5);
-    if (!fullV.some((v) => near(v.x1, b.x1)) || !fullV.some((v) => near(v.x1, b.x2)) || fullV.some((v) => v.x1 > b.x1 + 1.5 && v.x1 < b.x2 - 1.5)) continue;
+    if (!fullV.some((v) => near2(v.x1, b.x1)) || !fullV.some((v) => near2(v.x1, b.x2)) || fullV.some((v) => v.x1 > b.x1 + 1.5 && v.x1 < b.x2 - 1.5)) continue;
     frame.colXs = [b.x1, b.x2];
     frame.rowYs = [b.y2, b.y1];
   }
@@ -7265,7 +7268,7 @@ function buildRow(rowItems, bounds, colSpans) {
   const cols = bounds.length + 1;
   const colOf = (x) => bounds.filter((b) => x > b).length;
   const cells = Array.from({ length: cols }, () => []);
-  const span = new Array(cols).fill(1);
+  const span2 = new Array(cols).fill(1);
   for (const it of rowItems) {
     let first = colOf(it.x + EDGE_TOL3), last = colOf(it.x + it.w - EDGE_TOL3);
     if (last > first && colSpans) {
@@ -7279,11 +7282,11 @@ function buildRow(rowItems, bounds, colSpans) {
       }
     }
     cells[first].push(it);
-    if (last > first) span[first] = Math.max(span[first], last - first + 1);
+    if (last > first) span2[first] = Math.max(span2[first], last - first + 1);
   }
   const row = [];
   for (let c = 0; c < cols; ) {
-    const n = Math.min(span[c], cols - c);
+    const n = Math.min(span2[c], cols - c);
     const items = cells.slice(c, c + n).flat();
     row.push({ text: cellTextToString(items.map((it) => ({ ...it }))), colSpan: n, rowSpan: 1 });
     for (let k = 1; k < n; k++) row.push({ text: "", colSpan: 1, rowSpan: 1 });
@@ -7458,7 +7461,7 @@ function takeFrameSpanningText(items, cutX, pageNum, lex) {
     minX = Math.min(minX, item.x);
     maxR = Math.max(maxR, item.x + item.w);
   }
-  const span = maxR - minX;
+  const span2 = maxR - minX;
   const rows = groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x)).map((line) => {
     const runs = [];
     for (const item of [...line].sort((a, b) => a.x - b.x)) {
@@ -7473,7 +7476,7 @@ function takeFrameSpanningText(items, cutX, pageNum, lex) {
     if (taken.has(run[0]) || run[0].x >= cutX || Math.max(...run.map((i) => i.x + i.w)) <= cutX) continue;
     const lines = [run], fs = Math.max(...run.map((i) => i.fontSize));
     const left = run[0].x, right = Math.max(...run.map((i) => i.x + i.w));
-    if (right - left < span * 0.75) continue;
+    if (right - left < span2 * 0.75) continue;
     let prevY = run[0].y;
     for (let next = r + 1; next < rows.length && rows[next].length === 1; next++) {
       const tail = rows[next][0], y = tail[0].y;
@@ -7596,15 +7599,15 @@ function buildFrameCellBlocks(cellItems, nested, pageNum, lex) {
 
 // src/pdf/nested-shaded-headers.ts
 function extendNestedShadedHeaders(clipGrids, lineGrids, horizontals, verticals, fills) {
-  const near = (a, b) => Math.abs(a - b) <= 1.5;
-  const contains3 = (a, b) => b.x1 >= a.x1 - 1.5 && b.x2 <= a.x2 + 1.5 && b.y1 >= a.y1 - 1.5 && b.y2 <= a.y2 + 1.5;
+  const near2 = (a, b) => Math.abs(a - b) <= 1.5;
+  const contains4 = (a, b) => b.x1 >= a.x1 - 1.5 && b.x2 <= a.x2 + 1.5 && b.y1 >= a.y1 - 1.5 && b.y2 <= a.y2 + 1.5;
   const extended = [];
   for (let i = 0; i < clipGrids.length; i++) {
     const c = clipGrids[i], parent = c.clipParent;
     if (!parent || c.rowYs.length !== 2 || c.colXs.length < 3 || !c.cells?.length || c.cells.some((cell) => cell.filler || cell.rowSpan !== 1 || cell.colSpan !== 1)) continue;
-    if (!clipGrids.some((g) => g.rowYs.length === 2 && g.colXs.length === 2 && near(g.bbox.x1, parent.x1) && near(g.bbox.x2, parent.x2) && near(g.bbox.y1, parent.y1) && near(g.bbox.y2, parent.y2))) continue;
-    if (!c.cells.every((cell) => fills.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)))) continue;
-    const host = lineGrids.find((l) => l.rowYs.length > 2 && l.colXs.length === c.colXs.length && c.colXs.every((x, k) => near(x, l.colXs[k])) && c.rowYs.every((y, k) => near(y, l.rowYs[k])) && contains3(parent, l.bbox) && l.rowYs.every((y) => horizontals.some((h) => near(h.y1, y) && near(h.x1, l.bbox.x1) && near(h.x2, l.bbox.x2))) && l.colXs.every((x) => verticals.some((v) => near(v.x1, x) && v.y1 <= l.bbox.y1 + 1.5 && v.y2 >= l.bbox.y2 - 1.5)) && !clipGrids.some((o) => o !== c && !contains3(o.bbox, l.bbox) && Math.min(o.bbox.x2, l.bbox.x2) > Math.max(o.bbox.x1, l.bbox.x1) && Math.min(o.bbox.y2, l.bbox.y2) > Math.max(o.bbox.y1, l.bbox.y1)));
+    if (!clipGrids.some((g) => g.rowYs.length === 2 && g.colXs.length === 2 && near2(g.bbox.x1, parent.x1) && near2(g.bbox.x2, parent.x2) && near2(g.bbox.y1, parent.y1) && near2(g.bbox.y2, parent.y2))) continue;
+    if (!c.cells.every((cell) => fills.some((f) => near2(f.x1, cell.bbox.x1) && near2(f.x2, cell.bbox.x2) && near2(f.y1, cell.bbox.y1) && near2(f.y2, cell.bbox.y2)))) continue;
+    const host = lineGrids.find((l) => l.rowYs.length > 2 && l.colXs.length === c.colXs.length && c.colXs.every((x, k) => near2(x, l.colXs[k])) && c.rowYs.every((y, k) => near2(y, l.rowYs[k])) && contains4(parent, l.bbox) && l.rowYs.every((y) => horizontals.some((h) => near2(h.y1, y) && near2(h.x1, l.bbox.x1) && near2(h.x2, l.bbox.x2))) && l.colXs.every((x) => verticals.some((v) => near2(v.x1, x) && v.y1 <= l.bbox.y1 + 1.5 && v.y2 >= l.bbox.y2 - 1.5)) && !clipGrids.some((o) => o !== c && !contains4(o.bbox, l.bbox) && Math.min(o.bbox.x2, l.bbox.x2) > Math.max(o.bbox.x1, l.bbox.x1) && Math.min(o.bbox.y2, l.bbox.y2) > Math.max(o.bbox.y1, l.bbox.y1)));
     if (!host) continue;
     const grid = { ...host, clipParent: parent, cells: extractCells(host, horizontals, verticals) };
     clipGrids[i] = grid;
@@ -7829,8 +7832,8 @@ function isProseBoxGrid(grid, verticals, table, items) {
   const numCols = grid.colXs.length - 1;
   if (numCols < 2 || grid.rowYs.length < 3) return false;
   const gyMax = grid.rowYs[0], gyMin = grid.rowYs[grid.rowYs.length - 1];
-  const span = gyMax - gyMin;
-  if (span <= 0) return false;
+  const span2 = gyMax - gyMin;
+  if (span2 <= 0) return false;
   const interior = grid.colXs.slice(1, -1);
   let fullWidthHeight = 0;
   const divided = [];
@@ -7841,19 +7844,19 @@ function isProseBoxGrid(grid, verticals, table, items) {
     divided.push(hasDivider);
     if (h > 0 && !hasDivider) fullWidthHeight += h;
   }
-  if (fullWidthHeight < span * PROSEBOX_FULLWIDTH_MIN) return false;
-  if (isLabelTabBox(grid, divided, items, span)) return true;
+  if (fullWidthHeight < span2 * PROSEBOX_FULLWIDTH_MIN) return false;
+  if (isLabelTabBox(grid, divided, items, span2)) return true;
   const texts = table.cells.flat().map((c) => c.text.trim()).filter(Boolean);
   const longCells = texts.filter((s) => s.length > PROSEBOX_LONG_CELL_CHARS).length;
   if (longCells < PROSEBOX_LONG_CELL_MIN || longCells < texts.length * PROSEBOX_LONG_CELL_RATIO) return false;
   return true;
 }
-function isLabelTabBox(grid, divided, items, span) {
+function isLabelTabBox(grid, divided, items, span2) {
   let k = divided.length;
   while (k > 0 && !divided[k - 1]) k--;
   if (k === 0 || k === divided.length) return false;
   const bodyTop = grid.rowYs[k], b = grid.bbox;
-  if (bodyTop - grid.rowYs[grid.rowYs.length - 1] < 0.8 * span) return false;
+  if (bodyTop - grid.rowYs[grid.rowYs.length - 1] < 0.8 * span2) return false;
   const label = items.filter((it) => {
     const cx = it.x + it.w / 2, cy = it.y + it.h / 2;
     return cy > bodyTop && cy < b.y2 && cx > b.x1 && cx < b.x2 && it.text.trim();
@@ -7970,6 +7973,14 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       if (cellItems.length) recordCellLines(irGrid[cell.row][cell.col], cellItems);
       takeClipCellEdges(cell, irGrid[cell.row][cell.col]);
     }
+    if (lex) {
+      const boxes = new Map(cells.map((c) => [irGrid[c.row][c.col], c.bbox]));
+      const spaced = new Set(cells.filter((c) => {
+        const its = [...cellTextMap.get(c) ?? []].sort((a, b) => a.x - b.x);
+        return its.length === 2 && !!its[1].hasSpaceBefore && !its[1].syntheticSpace;
+      }).map((c) => irGrid[c.row][c.col]));
+      joinSpreadRowLabels(irGrid, lex, REGION_LABELS, (cell) => boxes.get(cell), (cell) => spaced.has(cell));
+    }
     let finalGrid = irGrid;
     let finalRows = numRows;
     let rebuiltUsed = false;
@@ -8077,6 +8088,10 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       blocks.push(chartBlock([...tableItems, ...axis].sort((a, b) => b.y - a.y || a.x - b.x), pageNum, { page: pageNum, x: x1, y: grid.bbox.y1, width: x2 - x1, height: grid.bbox.y2 - grid.bbox.y1 }));
       continue;
     }
+    if (!grid.cells && !nestedAttached && hasCrossingFrames(grid, horizontals, verticals)) {
+      for (const it of tableItems) usedItems.delete(it);
+      continue;
+    }
     const tableBbox = {
       page: pageNum,
       x: grid.bbox.x1,
@@ -8680,13 +8695,6 @@ function rowParagraphs(block) {
 }
 
 export {
-  OCR_DET_MODEL,
-  OCR_REC_MODEL,
-  OCR_REC_DICT,
-  getOcrModelsDir,
-  ensureOcrModels,
-  ocrModelsCached,
-  parseCharacterDict,
   extractLines,
   extractImageRegions,
   filterHiddenText,
@@ -8738,4 +8746,4 @@ export {
   UNRULED_REGION_TABLES,
   mergeOcrImageRegions
 };
-//# sourceMappingURL=chunk-PUAKSOZD.js.map
+//# sourceMappingURL=chunk-3YD3SAQW.js.map