kordoc 4.24.6 → 4.24.8

package/dist/{chunk-GYX26HZR.js → chunk-DPB6ZVQ5.js}

@@ -5,15 +5,15 @@ import {
   HEADING_RATIO_H3,
   tidyScriptTags,
   toTex
-} from "./chunk-WNOWRBM4.js";
+} from "./chunk-D3EHIHYN.js";
 import {
   ensureModelsIn,
   getModelsDir
-} from "./chunk-XVTGFK2F.js";
+} from "./chunk-NE6G6LCP.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-DFRQD254.js";
+} from "./chunk-F7UWIMUA.js";
 
 // src/ocr/models.ts
 import { join } from "path";
@@ -146,6 +146,773 @@ function ocrModelPath(spec) {
   return join(getOcrModelsDir(), spec.filename);
 }
 
+// src/ocr/line-split.ts
+function grayCrop(rgba, pageW, box) {
+  const out = new Uint8Array(box.w * box.h);
+  for (let y = 0; y < box.h; y++) {
+    let si = ((box.y + y) * pageW + box.x) * 4;
+    let di = y * box.w;
+    for (let x = 0; x < box.w; x++, si += 4, di++) {
+      out[di] = rgba[si] * 77 + rgba[si + 1] * 150 + rgba[si + 2] * 29 >> 8;
+    }
+  }
+  return out;
+}
+function inkStats(gray) {
+  const hist = new Uint32Array(256);
+  for (let i = 0; i < gray.length; i++) hist[gray[i]]++;
+  const total = gray.length;
+  let sumAll = 0;
+  for (let v = 0; v < 256; v++) sumAll += v * hist[v];
+  let wB = 0, sumB = 0, best = -1, thr = 127;
+  for (let t = 0; t < 256; t++) {
+    wB += hist[t];
+    if (wB === 0) continue;
+    const wF = total - wB;
+    if (wF === 0) break;
+    sumB += t * hist[t];
+    const mB = sumB / wB;
+    const mF = (sumAll - sumB) / wF;
+    const between = wB * wF * (mB - mF) * (mB - mF);
+    if (between > best) {
+      best = between;
+      thr = t;
+    }
+  }
+  let nDark = 0, sDark = 0;
+  for (let v = 0; v <= thr; v++) {
+    nDark += hist[v];
+    sDark += v * hist[v];
+  }
+  const nLight = total - nDark;
+  const sLight = sumAll - sDark;
+  if (nDark === 0 || nLight === 0) return { threshold: thr, darkInk: true, contrast: 0, inkRatio: 0 };
+  const darkInk = nDark <= nLight;
+  return {
+    threshold: thr,
+    darkInk,
+    contrast: sLight / nLight - sDark / nDark,
+    inkRatio: (darkInk ? nDark : nLight) / total
+  };
+}
+function splitRowBands(gray, w, h, ink, minBandRatio) {
+  const isInk = (v) => ink.darkInk ? v <= ink.threshold : v > ink.threshold;
+  const colInk = new Uint32Array(w);
+  for (let y = 0; y < h; y++) {
+    const off = y * w;
+    for (let x = 0; x < w; x++) if (isInk(gray[off + x])) colInk[x]++;
+  }
+  const ruleCol = new Uint8Array(w);
+  let liveW = 0;
+  for (let x = 0; x < w; x++) {
+    if (colInk[x] >= h * 0.85) ruleCol[x] = 1;
+    else liveW++;
+  }
+  const rowInk = new Uint32Array(h);
+  for (let y = 0; y < h; y++) {
+    let n = 0;
+    const off = y * w;
+    for (let x = 0; x < w; x++) if (!ruleCol[x] && isInk(gray[off + x])) n++;
+    rowInk[y] = n >= liveW * 0.85 ? 0 : n;
+  }
+  const blank = Math.max(1, Math.floor(w * 0.02));
+  let bands = [];
+  let start = -1;
+  for (let y = 0; y <= h; y++) {
+    const on = y < h && rowInk[y] > blank;
+    if (on && start < 0) start = y;
+    else if (!on && start >= 0) {
+      bands.push([start, y]);
+      start = -1;
+    }
+  }
+  const inkCols = (y0, y1) => {
+    let x0 = w, x1 = -1;
+    for (let y = y0; y < y1; y++) {
+      const off = y * w;
+      for (let x = 0; x < w; x++) if (!ruleCol[x] && isInk(gray[off + x])) {
+        if (x < x0) x0 = x;
+        if (x > x1) x1 = x;
+      }
+    }
+    return x1 >= x0 ? [x0, x1 + 1] : [0, w];
+  };
+  if (bands.length <= 1) return [{ y0: bands[0]?.[0] ?? 0, y1: bands[0]?.[1] ?? h, x0: 0, x1: w }];
+  const widths = bands.map(([y0, y1]) => {
+    const [a, b] = inkCols(y0, y1);
+    return b - a;
+  }).sort((a, b) => a - b);
+  const charSize = widths[widths.length >> 1];
+  const minBand = Math.max(3, minBandRatio * charSize);
+  for (let i = 0; i + 1 < bands.length; ) {
+    const gap = bands[i + 1][0] - bands[i][1];
+    if (gap <= Math.max(2, charSize * 0.15) && bands[i + 1][1] - bands[i][0] <= charSize * 1.3) {
+      bands.splice(i, 2, [bands[i][0], bands[i + 1][1]]);
+    } else i++;
+  }
+  while (bands.length > 1 && bands[0][0] <= 1 && bands[0][1] - bands[0][0] < minBand) bands.shift();
+  while (bands.length > 1 && bands[bands.length - 1][1] >= h - 1 && bands[bands.length - 1][1] - bands[bands.length - 1][0] < minBand) bands.pop();
+  for (; ; ) {
+    let idx = -1, minH = Infinity;
+    for (let i = 0; i < bands.length; i++) {
+      const bh = bands[i][1] - bands[i][0];
+      if (bh < minBand && bh < minH) {
+        minH = bh;
+        idx = i;
+      }
+    }
+    if (idx < 0 || bands.length === 1) break;
+    const gapPrev = idx > 0 ? bands[idx][0] - bands[idx - 1][1] : Infinity;
+    const gapNext = idx < bands.length - 1 ? bands[idx + 1][0] - bands[idx][1] : Infinity;
+    const j = gapPrev <= gapNext ? idx - 1 : idx + 1;
+    const a = Math.min(idx, j), b = Math.max(idx, j);
+    bands = [...bands.slice(0, a), [bands[a][0], bands[b][1]], ...bands.slice(b + 1)];
+  }
+  if (bands.length === 1) return [{ y0: bands[0][0], y1: bands[0][1], x0: 0, x1: w }];
+  return bands.map(([y0, y1]) => {
+    const [x0, x1] = inkCols(y0, y1);
+    return { y0, y1, x0, x1 };
+  });
+}
+function components(gray, w, h, ink) {
+  const isInk = (v) => ink.darkInk ? v <= ink.threshold : v > ink.threshold;
+  const comps = [];
+  const label = new Int32Array(w * h);
+  const stack = [];
+  for (let p0 = 0; p0 < w * h; p0++) {
+    if (label[p0] || !isInk(gray[p0])) continue;
+    const c = { x0: w, x1: 0, y0: h, y1: 0, id: comps.length + 1 };
+    label[p0] = c.id;
+    stack.push(p0);
+    while (stack.length) {
+      const p = stack.pop();
+      const x = p % w, y = p / w | 0;
+      if (x < c.x0) c.x0 = x;
+      if (x + 1 > c.x1) c.x1 = x + 1;
+      if (y < c.y0) c.y0 = y;
+      if (y + 1 > c.y1) c.y1 = y + 1;
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+        const nx = x + dx, ny = y + dy;
+        if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
+        const q = ny * w + nx;
+        if (!label[q] && isInk(gray[q])) {
+          label[q] = c.id;
+          stack.push(q);
+        }
+      }
+    }
+    if (c.y1 - c.y0 < h * 0.85 && c.x1 - c.x0 < w * 0.85) comps.push(c);
+  }
+  return { comps, label };
+}
+function leadingTriangle(gray, w, h, ink) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  const first = comps.filter((c) => c.y1 - c.y0 >= charH * 0.4).sort((a, b) => a.x0 - b.x0)[0];
+  if (!first || charH < 8) return null;
+  const cw = first.x1 - first.x0, ch = first.y1 - first.y0;
+  if (cw < ch * 0.8 || cw > ch * 1.8) return null;
+  const rowSpan = (y) => {
+    let n = 0, lo = -1, hi = -1, runs = 0, prev = false;
+    for (let x = first.x0; x < first.x1; x++) {
+      const on = label[y * w + x] === first.id;
+      if (on) {
+        n++;
+        if (lo < 0) lo = x - first.x0;
+        hi = x - first.x0;
+        if (!prev) runs++;
+      }
+      prev = on;
+    }
+    return { n, lo, hi, runs };
+  };
+  const base = Math.max(rowSpan(first.y1 - 1).n, rowSpan(first.y1 - 2).n);
+  if (base < cw * 0.7) return null;
+  for (let y = first.y0; y < first.y0 + Math.max(1, Math.round(ch * 0.2)); y++) {
+    const r = rowSpan(y);
+    if (r.n === 0) continue;
+    if (r.hi - r.lo + 1 > cw * 0.4 || (r.lo + r.hi) / 2 < cw * 0.25 || (r.lo + r.hi) / 2 > cw * 0.75) return null;
+  }
+  const mid = rowSpan(first.y0 + Math.round(ch * 0.6));
+  if (mid.lo < 0 || mid.lo > cw * 0.3 || mid.hi < cw * 0.7) return null;
+  return mid.runs >= 2 ? "\u25B3" : "\u25B2";
+}
+function leaderRuns(gray, w, h, ink, minDots) {
+  const comps = components(gray, w, h, ink).comps.sort((a, b) => a.x0 - b.x0);
+  const blobs = [];
+  for (const c of comps) {
+    const last = blobs[blobs.length - 1];
+    if (last && c.x0 < last.x1) {
+      last.x1 = Math.max(last.x1, c.x1);
+      last.y0 = Math.min(last.y0, c.y0);
+      last.y1 = Math.max(last.y1, c.y1);
+    } else blobs.push({ x0: c.x0, x1: c.x1, y0: c.y0, y1: c.y1 });
+  }
+  let charH = 0;
+  for (const b of blobs) charH = Math.max(charH, b.y1 - b.y0);
+  if (charH < 8) return [];
+  const small = (c) => c.x1 - c.x0 <= charH * 0.3 && c.y1 - c.y0 <= charH * 0.3;
+  let bandTop = h, bandBot = 0;
+  for (const c of comps) if (!small(c)) {
+    bandTop = Math.min(bandTop, c.y0);
+    bandBot = Math.max(bandBot, c.y1);
+  }
+  const cy = (c) => (c.y0 + c.y1) / 2;
+  const isDot = (b) => small(b) && cy(b) >= bandTop && cy(b) <= bandBot;
+  const runs = [];
+  for (let i = 0; i < blobs.length; ) {
+    if (!isDot(blobs[i])) {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j + 1 < blobs.length && isDot(blobs[j + 1]) && blobs[j + 1].x0 - blobs[j].x1 <= charH && Math.abs(cy(blobs[j + 1]) - cy(blobs[i])) <= charH * 0.2) j++;
+    const x0 = blobs[i].x0, x1 = blobs[j].x1, y = cy(blobs[i]);
+    const onLine = comps.some((c) => !small(c) && c.y0 <= y && c.y1 >= y && (c.x1 <= x0 + 2 && c.x1 >= x0 - 2 * charH || c.x0 >= x1 - 2 && c.x0 <= x1 + 2 * charH));
+    const run = blobs.slice(i, j + 1).filter((b) => b.x0 > 0 && b.x1 < w);
+    const spread = (xs) => {
+      const v = [...xs].sort((a, b) => a - b).slice(xs.length >= 5 ? 1 : 0, xs.length >= 5 ? -1 : void 0);
+      return v[v.length - 1] / Math.max(1, v[0]);
+    };
+    const even = run.length >= 2 && spread(run.map((b) => b.x1 - b.x0)) <= 2.5 && spread(run.map((b) => b.y1 - b.y0)) <= 2.5 && spread(run.slice(1).map((b, k) => b.x0 - run[k].x0)) <= 1.8;
+    if (j - i + 1 >= minDots && onLine && even) runs.push([x0, x1]);
+    i = j + 1;
+  }
+  return runs;
+}
+function inkBounds(gray, w, h, ink) {
+  const isInk = (v) => ink.darkInk ? v <= ink.threshold : v > ink.threshold;
+  const colInk = new Uint32Array(w);
+  const rowInk = new Uint32Array(h);
+  for (let y = 0; y < h; y++) {
+    const off = y * w;
+    for (let x = 0; x < w; x++) if (isInk(gray[off + x])) {
+      colInk[x]++;
+      rowInk[y]++;
+    }
+  }
+  const ruleCol = new Uint8Array(w), ruleRow = new Uint8Array(h);
+  for (let x = 0; x < w; x++) if (colInk[x] >= h * 0.85) ruleCol[x] = 1;
+  for (let y = 0; y < h; y++) if (rowInk[y] >= w * 0.85) ruleRow[y] = 1;
+  let x0 = w, x1 = -1, y0 = h, y1 = -1;
+  for (let y = 0; y < h; y++) {
+    if (ruleRow[y]) continue;
+    const off = y * w;
+    for (let x = 0; x < w; x++) {
+      if (ruleCol[x] || !isInk(gray[off + x])) continue;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+  }
+  if (x1 < x0 || y1 < y0) return { x0: 0, y0: 0, x1: w, y1: h };
+  return { x0, y0, x1: x1 + 1, y1: y1 + 1 };
+}
+function bracketFeatures(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 8) return null;
+  const tol = Math.max(2, charH * 0.3);
+  let best = null, bestD = Infinity;
+  for (const c of comps) {
+    if (c.y1 - c.y0 < charH * 0.3 || c.x1 < cx - tol || c.x0 > cx + tol) continue;
+    const d = Math.abs((c.x0 + c.x1) / 2 - cx);
+    if (d < bestD) {
+      bestD = d;
+      best = c;
+    }
+  }
+  if (!best) return null;
+  const b = best;
+  const cw = b.x1 - b.x0, ch = b.y1 - b.y0;
+  if (cw < 3 || ch < 8) return null;
+  const spans = [];
+  for (let y = b.y0; y < b.y1; y++) {
+    let n = 0;
+    for (let x = b.x0; x < b.x1; x++) if (label[y * w + x] === b.id) n++;
+    spans.push(n);
+  }
+  const band = Math.max(1, Math.round(ch * 0.15));
+  const top = Math.max(...spans.slice(0, band)) / cw, bottom = Math.max(...spans.slice(ch - band)) / cw;
+  const midRows = spans.slice(Math.floor(ch * 0.3), Math.ceil(ch * 0.7)).sort((p, q) => p - q);
+  const stroke = midRows[midRows.length >> 1] ?? 0;
+  const taper = spans.filter((n) => n > stroke && n < cw).length / ch;
+  const fill = spans.reduce((a, n) => a + n, 0) / (cw * ch);
+  return { top, bottom, taper, fill, cw, ch, charH };
+}
+function romanStems(gray, w, h, ink, prevX, nextX) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return null;
+  const x0 = prevX + charH * 0.35, x1 = nextX - charH * 0.35;
+  const sel = comps.filter((c) => c.y1 - c.y0 >= charH * 0.6 && (c.x0 + c.x1) / 2 >= x0 && (c.x0 + c.x1) / 2 < x1);
+  if (!sel.length) return null;
+  const ids = new Set(sel.map((c) => c.id));
+  const ux0 = Math.min(...sel.map((c) => c.x0)), ux1 = Math.max(...sel.map((c) => c.x1));
+  const uy0 = Math.min(...sel.map((c) => c.y0)), uy1 = Math.max(...sel.map((c) => c.y1));
+  const uh = uy1 - uy0;
+  const counts = /* @__PURE__ */ new Map();
+  let rows = 0;
+  for (let y = uy0 + Math.floor(uh * 0.25); y < uy1 - Math.floor(uh * 0.25); y++) {
+    let runs = 0, len = 0, thick = false;
+    for (let x = ux0; x <= ux1; x++) {
+      const on = x < ux1 && ids.has(label[y * w + x]);
+      if (on) len++;
+      else if (len) {
+        runs++;
+        if (len > uh * 0.35) thick = true;
+        len = 0;
+      }
+    }
+    rows++;
+    if (!thick) counts.set(runs, (counts.get(runs) ?? 0) + 1);
+  }
+  const [n, k] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? [0, 0];
+  return n >= 1 && n <= 3 && k >= rows * 0.7 ? n : null;
+}
+function circledAt(gray, w, h, ink, xs) {
+  const { comps } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  const rings = charH < 10 ? [] : comps.filter((r) => {
+    const rw = r.x1 - r.x0, rh = r.y1 - r.y0;
+    return rh >= charH * 0.55 && rw >= rh * 0.8 && rw <= rh * 1.25 && comps.some((d) => d !== r && d.x0 > r.x0 && d.x1 < r.x1 && d.y0 > r.y0 && d.y1 < r.y1 && d.y1 - d.y0 >= rh * 0.35);
+  });
+  return xs.map((x) => rings.some((r) => x >= r.x0 && x <= r.x1));
+}
+function quoteHead(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return null;
+  const tall = comps.filter((c) => c.y1 - c.y0 >= charH * 0.6);
+  if (!tall.length) return null;
+  const mid = (Math.min(...tall.map((c) => c.y0)) + Math.max(...tall.map((c) => c.y1))) / 2;
+  let best = null, bestD = charH * 0.4;
+  for (const c of comps) {
+    const ch = c.y1 - c.y0, d = Math.abs((c.x0 + c.x1) / 2 - cx);
+    if (ch < charH * 0.12 || ch > charH * 0.5 || (c.y0 + c.y1) / 2 > mid || d > bestD) continue;
+    bestD = d;
+    best = c;
+  }
+  if (!best) return null;
+  let n = 0, sy = 0;
+  for (let y = best.y0; y < best.y1; y++) for (let x = best.x0; x < best.x1; x++) if (label[y * w + x] === best.id) {
+    n++;
+    sy += y;
+  }
+  return n ? (sy / n - best.y0) / (best.y1 - best.y0) : null;
+}
+function edgeTrim(gray, w, h, ink) {
+  const isInk = (v) => ink.darkInk ? v <= ink.threshold : v > ink.threshold;
+  const colInk = new Uint32Array(w);
+  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) if (isInk(gray[y * w + x])) colInk[x]++;
+  const ruleCol = new Uint8Array(w);
+  let liveW = 0;
+  for (let x = 0; x < w; x++) {
+    if (colInk[x] >= h * 0.85) ruleCol[x] = 1;
+    else liveW++;
+  }
+  const blank = Math.max(1, Math.floor(w * 0.02));
+  const bands = [];
+  let start = -1;
+  for (let y = 0; y <= h; y++) {
+    let n = 0;
+    if (y < h) {
+      for (let x = 0; x < w; x++) if (!ruleCol[x] && isInk(gray[y * w + x])) n++;
+    }
+    const on = y < h && n > blank && n < liveW * 0.85;
+    if (on && start < 0) start = y;
+    else if (!on && start >= 0) {
+      bands.push([start, y]);
+      start = -1;
+    }
+  }
+  let y0 = 0, y1 = h;
+  if (bands.length >= 2 && h >= 24) {
+    const mh = Math.max(...bands.map(([a, b]) => b - a));
+    const [top, next] = [bands[0], bands[1]], [bot, prev] = [bands[bands.length - 1], bands[bands.length - 2]];
+    if (top[0] <= 1 && top[1] - top[0] < mh * 0.45) y0 = top[1] + next[0] >> 1;
+    if (bot[1] >= h - 1 && bot[1] - bot[0] < mh * 0.45) y1 = bot[0] + prev[1] + 1 >> 1;
+    if (y0 > 0 || y1 < h) {
+      let runs = 0, len = 0;
+      for (let x = 0; x <= w; x++) {
+        let on = false;
+        if (x < w && !ruleCol[x]) for (let y = y0; y < y1 && !on; y++) on = isInk(gray[y * w + x]);
+        if (on) len++;
+        else {
+          if (len >= (y1 - y0) * 0.3) runs++;
+          len = 0;
+        }
+      }
+      if (runs < 2) {
+        y0 = 0;
+        y1 = h;
+      }
+    }
+  }
+  const textCol = (x) => {
+    for (let y = y0; y < y1; y++) if (isInk(gray[y * w + x])) return true;
+    return false;
+  };
+  const border = (x) => colInk[x] >= h * 0.95;
+  const gap = Math.max(2, Math.round(h * 0.1));
+  const clearFrom = (x, dir) => {
+    for (let k = 0; k < gap; k++) {
+      const c = x + dir * k;
+      if (c < 0 || c >= w || textCol(c)) return false;
+    }
+    return true;
+  };
+  let x0 = 0, x1 = w;
+  for (let x = 0; x < w * 0.2; x++) {
+    if (border(x)) {
+      let e = x;
+      while (e + 1 < w && border(e + 1)) e++;
+      if (clearFrom(e + 1, 1)) x0 = e + 1;
+      break;
+    }
+    if (textCol(x)) break;
+  }
+  for (let x = w - 1; x >= w * 0.8; x--) {
+    if (border(x)) {
+      let e = x;
+      while (e - 1 >= 0 && border(e - 1)) e--;
+      if (clearFrom(e - 1, -1)) x1 = e;
+      break;
+    }
+    if (textCol(x)) break;
+  }
+  return y0 > 0 || y1 < h || x0 > 0 || x1 < w ? { x0, x1, y0, y1 } : null;
+}
+function tallInkCount(gray, w, h, ink) {
+  const { comps } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  const tall = comps.filter((c) => c.y1 - c.y0 >= charH * 0.5).sort((a, b) => a.x0 - b.x0);
+  let n = 0, end = -1;
+  for (const c of tall) {
+    if (c.x0 >= end) n++;
+    end = Math.max(end, c.x1);
+  }
+  return n;
+}
+function gapGlyphs(gray, w, h, ink) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return { glyphs: [], bandH: 0 };
+  const tall = comps.filter((c) => c.y1 - c.y0 >= charH * 0.6);
+  const bandT = Math.min(...tall.map((c) => c.y0)), bandB = Math.max(...tall.map((c) => c.y1)), bh = bandB - bandT;
+  const inBand = (c) => c.y1 > bandT && c.y0 < bandB;
+  const out = [];
+  for (const c of comps) {
+    if (!inBand(c)) continue;
+    const cw = c.x1 - c.x0, ch = c.y1 - c.y0;
+    if (ch >= bh * 0.9 && cw <= bh * 0.15) continue;
+    const others = comps.filter((o) => o !== c && inBand(o) && !(o.x0 >= c.x0 && o.x1 <= c.x1 && o.y0 >= c.y0 && o.y1 <= c.y1));
+    const apart = !others.some((o) => o.x0 < c.x1 + 1 && o.x1 > c.x0 - 1);
+    const abut = !apart && ch >= bh * 0.3 && ch <= bh * 0.65 && !others.some((o) => o.x0 < c.x1 && o.x1 > c.x0);
+    const nearlyApart = !others.some((o) => Math.min(o.x1, c.x1) - Math.max(o.x0, c.x0) > 2);
+    const spans = [], runs = [];
+    let n = 0;
+    for (let y = c.y0; y < c.y1; y++) {
+      let s = 0, r = 0, prev = false;
+      for (let x = c.x0; x < c.x1; x++) {
+        const on = label[y * w + x] === c.id;
+        if (on) {
+          s++;
+          if (!prev) r++;
+        }
+        prev = on;
+      }
+      spans.push(s);
+      runs.push(r);
+      n += s;
+    }
+    const fill = n / (cw * ch), cy = ((c.y0 + c.y1) / 2 - bandT) / bh;
+    const band = Math.max(1, Math.round(ch * 0.15));
+    const top = Math.max(...spans.slice(0, band)) / cw, bottom = Math.max(...spans.slice(ch - band)) / cw;
+    let mark = null;
+    const speck = Math.max(3, bh * 0.08);
+    const dot = ch <= bh * 0.25 && cw <= bh * 0.25 && ch >= speck && cw >= speck && cw >= ch * 0.6 && cw <= ch * 1.6;
+    const small = ch <= bh * 0.25 && cw <= bh * 0.25 && ch >= 2 && cw >= 2 && cw >= ch * 0.6 && cw <= ch * 1.6 && fill >= 0.6 && cy >= 0.3 && cy <= 0.7;
+    if (!apart && !abut && !(nearlyApart && ch >= bh * 0.6)) {
+      if (small) out.push({ x0: c.x0, x1: c.x1, mark: "\xB7
" });
+      continue;
+    }
+    const bracket = () => {
+      const stem = (from, to) => {
+        let sx = 0, k = 0;
+        for (let y = from; y < to; y++) for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) {
+          sx += x - c.x0;
+          k++;
+        }
+        return k ? sx / k / cw : 0.5;
+      };
+      if (c.y0 <= bandT + bh * 0.15 && top >= 0.7 && bottom <= 0.5 && stem(c.y0 + band, c.y1) <= 0.35) return "\u300C";
+      if (c.y1 >= bandB - bh * 0.15 && bottom >= 0.7 && top <= 0.5 && stem(c.y0, c.y1 - band) >= 0.65) return "\u300D";
+      return null;
+    };
+    if (!apart && !abut) {
+    } else if (abut) {
+      if (fill < 0.5) mark = bracket();
+    } else if (dot && fill >= 0.6 && cy >= 0.3 && cy <= 0.7) mark = "\xB7";
+    else if (small) mark = "\xB7
";
+    else if (dot && fill >= 0.6 && cy >= 0.75 && cw >= ch * 0.8) mark = ".";
+    else if (ch <= bh * 0.4 && ch >= speck && cw >= ch * 0.75 && cw <= ch * 1.3 && fill < 0.6 && runs[ch >> 1] === 2 && cy >= 0.6) mark = "\u3002";
+    else if (ch <= bh * 0.15 && cw >= ch * 2 && cw <= bh * 0.8 && fill >= 0.7 && cy >= 0.35 && cy <= 0.75) mark = "-";
+    else if (ch >= bh * 0.5 && cw >= ch * 0.9 && cw <= ch * 1.4 && fill >= 0.4 && runs.every((r) => r <= 1) && top <= 0.4 && bottom >= 0.8) mark = "\u25B2";
+    else if (ch >= bh * 0.3 && ch <= bh * 0.65 && fill < 0.5) mark = bracket();
+    else if (ch >= charH * 0.6 && cw >= ch * 0.8 && cw <= ch * 1.25 && fill < 0.5 && top >= 0.8 && bottom >= 0.8 && runs[ch >> 1] === 2) mark = ch <= charH * 0.92 ? "\u25A1" : "\u25A1\0";
+    if (!mark && ch >= bh * 0.6 && cw >= ch * 0.25 && cw <= ch * 0.7 && fill <= 0.4 && runs.every((r) => r <= 1)) {
+      const mx = (y) => {
+        let sx = 0, k = 0;
+        for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) {
+          sx += x;
+          k++;
+        }
+        return k ? sx / k : NaN;
+      };
+      if (mx(c.y0 + band) - mx(c.y1 - 1 - band) >= cw * 0.5) mark = "/";
+    }
+    if (mark) out.push({ x0: c.x0, x1: c.x1, mark });
+  }
+  return { glyphs: out, bandH: bh };
+}
+function ringBullet(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c2 of comps) charH = Math.max(charH, c2.y1 - c2.y0);
+  if (charH < 10) return null;
+  const tall = comps.filter((c2) => c2.y1 - c2.y0 >= charH * 0.6);
+  const bandT = Math.min(...tall.map((c2) => c2.y0)), bh = Math.max(...tall.map((c2) => c2.y1)) - bandT;
+  let best = null, bestD = bh * 0.6;
+  for (const c2 of comps) {
+    const d = Math.abs((c2.x0 + c2.x1) / 2 - cx);
+    if (c2.y1 - c2.y0 >= bh * 0.3 && d < bestD) {
+      bestD = d;
+      best = c2;
+    }
+  }
+  if (!best) return null;
+  const c = best, cw = c.x1 - c.x0, ch = c.y1 - c.y0;
+  if (cw < ch * 0.85 || cw > ch * 1.2) return null;
+  const runs = (xs, at) => {
+    let n2 = 0, len = 0, mx2 = 0, mn = Infinity;
+    for (const k of [...xs, -1]) {
+      if (k >= 0 && at(k)) {
+        if (!len) n2++;
+        len++;
+        mx2 = Math.max(mx2, len);
+      } else {
+        if (len) mn = Math.min(mn, len);
+        len = 0;
+      }
+    }
+    return { n: n2, mx: mx2, mn };
+  };
+  const my = c.y0 + c.y1 >> 1, mx = c.x0 + c.x1 >> 1;
+  const row = runs(Array.from({ length: cw }, (_, k) => c.x0 + k), (x) => label[my * w + x] === c.id);
+  const col = runs(Array.from({ length: ch }, (_, k) => c.y0 + k), (y) => label[y * w + mx] === c.id);
+  if (row.n !== 2 || col.n !== 2) return null;
+  let n = 0;
+  for (let y = c.y0; y < c.y1; y++) for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) n++;
+  const fill = n / (cw * ch), rel = ch / bh;
+  if (rel >= 0.62 && (fill <= 0.23 ? row.mx <= cw * 0.1 : fill <= 0.33 && row.mn <= cw * 0.08)) return "\u25CB";
+  if (rel <= 0.58 && fill >= 0.24) return "\u3147";
+  if (rel >= 0.6 && rel <= 0.8 && fill >= 0.3 && ((c.y0 + c.y1) / 2 - bandT) / bh >= 0.55) return "o";
+  return null;
+}
+function dashRatio(gray, w, h, ink, cx) {
+  const { comps } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return null;
+  const tall = comps.filter((c) => c.y1 - c.y0 >= charH * 0.6);
+  const bh = Math.max(...tall.map((c) => c.y1)) - Math.min(...tall.map((c) => c.y0));
+  const dash = comps.filter((c) => c.y1 - c.y0 <= bh * 0.25 && c.x1 - c.x0 >= (c.y1 - c.y0) * 2 && Math.abs((c.x0 + c.x1) / 2 - cx) <= bh * 0.6).sort((a, b) => Math.abs((a.x0 + a.x1) / 2 - cx) - Math.abs((b.x0 + b.x1) / 2 - cx))[0];
+  return dash ? (dash.x1 - dash.x0) / bh : null;
+}
+function discAt(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c2 of comps) charH = Math.max(charH, c2.y1 - c2.y0);
+  if (charH < 10) return false;
+  const tall = comps.filter((c2) => c2.y1 - c2.y0 >= charH * 0.6);
+  const bh = Math.max(...tall.map((c2) => c2.y1)) - Math.min(...tall.map((c2) => c2.y0));
+  const c = comps.filter((o) => Math.abs((o.x0 + o.x1) / 2 - cx) <= bh * 0.4).sort((a, b) => Math.abs((a.x0 + a.x1) / 2 - cx) - Math.abs((b.x0 + b.x1) / 2 - cx))[0];
+  if (!c) return false;
+  const cw = c.x1 - c.x0, ch = c.y1 - c.y0;
+  if (ch < bh * 0.45 || ch > bh * 1.05 || cw < ch * 0.8 || cw > ch * 1.25) return false;
+  let n = 0;
+  for (let y = c.y0; y < c.y1; y++) for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) n++;
+  const fill = n / (cw * ch);
+  return fill >= 0.65 && fill <= 0.9;
+}
+function serifOne(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c2 of comps) charH = Math.max(charH, c2.y1 - c2.y0);
+  if (charH < 10) return false;
+  const c = comps.filter((o) => o.x0 - 3 <= cx && o.x1 + 3 >= cx && o.y1 - o.y0 >= charH * 0.6).sort((a, b) => b.y1 - b.y0 - (a.y1 - a.y0))[0];
+  if (!c) return false;
+  const ch = c.y1 - c.y0;
+  const span2 = (a, b) => {
+    let mn = Infinity, mx = -1;
+    for (let y = c.y0 + Math.floor(ch * a); y < c.y0 + Math.ceil(ch * b); y++) for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) {
+      mn = Math.min(mn, x);
+      mx = Math.max(mx, x);
+    }
+    return [mn, mx];
+  };
+  const [m0, m1] = span2(0.4, 0.6), [t0, t1] = span2(0, 0.2), [b0, b1] = span2(0.8, 1);
+  const sw = m1 - m0 + 1;
+  const even = (l, r) => l >= sw * 0.4 && r >= sw * 0.4 && Math.abs(l - r) <= Math.max(l, r) * 0.35;
+  return sw >= 2 && sw <= ch * 0.3 && even(m0 - t0, t1 - m1) && even(m0 - b0, b1 - m1);
+}
+function starRun(gray, w, h, ink, cx) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return 0;
+  const tall = comps.filter((c) => c.y1 - c.y0 >= charH * 0.6);
+  const bandT = Math.min(...tall.map((c) => c.y0)), bh = Math.max(...tall.map((c) => c.y1)) - bandT;
+  const star = (c) => {
+    const cw = c.x1 - c.x0, ch = c.y1 - c.y0;
+    if (ch < bh * 0.2 || ch > bh * 0.5 || cw < ch * 0.7 || cw > ch * 1.4 || ((c.y0 + c.y1) / 2 - bandT) / bh > 0.55) return false;
+    let n = 0;
+    for (let y = c.y0; y < c.y1; y++) for (let x = c.x0; x < c.x1; x++) if (label[y * w + x] === c.id) n++;
+    const fill = n / (cw * ch);
+    return fill >= 0.25 && fill <= 0.65;
+  };
+  const stars = comps.filter(star).sort((a, b) => a.x0 - b.x0);
+  const k = stars.findIndex((c) => cx >= c.x0 - (c.x1 - c.x0) && cx <= c.x1 + (c.x1 - c.x0));
+  if (k < 0) return 0;
+  let lo = k, hi = k;
+  while (lo > 0 && stars[lo].x0 - stars[lo - 1].x1 <= stars[lo].x1 - stars[lo].x0) lo--;
+  while (hi + 1 < stars.length && stars[hi + 1].x0 - stars[hi].x1 <= stars[hi].x1 - stars[hi].x0) hi++;
+  return hi - lo + 1;
+}
+var BRACKET_TAPER = 0.16;
+var BRACKET_SOLID = 0.4;
+var BRACKET_WIDE = 0.265;
+var BRACKET_LENS = 0.35;
+function bracketShape(f, close) {
+  const [near2, far] = close ? [f.bottom, f.top] : [f.top, f.bottom];
+  const paren = close ? ")" : "(";
+  if (near2 >= 0.7 && far <= 0.5) return f.taper < BRACKET_TAPER ? close ? "\u300D" : "\u300C" : paren;
+  if (near2 >= 0.7 && far >= 0.7 && f.taper >= BRACKET_TAPER) {
+    return f.fill >= BRACKET_SOLID && (f.cw >= f.ch * BRACKET_WIDE || f.taper >= BRACKET_LENS) ? close ? "\u3011" : "\u3010" : paren;
+  }
+  return null;
+}
+function leadingBullet(gray, w, h, ink, firstX) {
+  const { comps, label } = components(gray, w, h, ink);
+  let charH = 0;
+  for (const c of comps) charH = Math.max(charH, c.y1 - c.y0);
+  if (charH < 10) return null;
+  const cand = comps.filter((c) => c.y1 - c.y0 >= charH * 0.15).sort((a, b) => a.x0 - b.x0);
+  const first = cand[0];
+  if (!first) return null;
+  const cl = cand.filter((c) => c.x0 < first.x1 && c.x1 > first.x0);
+  const x0 = Math.min(...cl.map((c) => c.x0)), x1 = Math.max(...cl.map((c) => c.x1)), y0 = Math.min(...cl.map((c) => c.y0)), y1 = Math.max(...cl.map((c) => c.y1));
+  const cw = x1 - x0, ch = y1 - y0;
+  if (cw < ch * 0.8 || cw > ch * 1.25) return null;
+  const next = cand.find((c) => c.x0 >= x1);
+  if (next && next.x0 - x1 < ch * 0.3) return null;
+  let inkN = 0;
+  for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) if (cl.some((c) => label[y * w + x] === c.id)) inkN++;
+  const fill = inkN / (cw * ch);
+  const rel = ch / charH;
+  const ring = (c) => {
+    const a = c.x1 - c.x0, b = c.y1 - c.y0;
+    return a >= b * 0.75 && a <= b * 1.33;
+  };
+  const nested = cl.length >= 2 && cl.some((a) => cl.some((b) => a !== b && b.x0 > a.x0 && b.x1 < a.x1 && b.y0 > a.y0 && b.y1 < a.y1 && ring(b) && Math.abs(b.x0 + b.x1 - (a.x0 + a.x1)) <= (a.x1 - a.x0) * 0.2 && Math.abs(b.y0 + b.y1 - (a.y0 + a.y1)) <= (a.y1 - a.y0) * 0.2));
+  const span2 = (y) => {
+    let n = 0;
+    for (let x = x0; x < x1; x++) if (cl.some((c) => label[y * w + x] === c.id)) n++;
+    return n;
+  };
+  const band = Math.max(1, Math.round(ch * 0.15));
+  const edgeFull = (from, dir) => {
+    let m = 0;
+    for (let k = 0; k < band; k++) m = Math.max(m, span2(from + dir * k));
+    return m >= cw * 0.8;
+  };
+  let midRuns = 0;
+  {
+    let prev = false;
+    const my = y0 + (ch >> 1);
+    for (let x = x0; x < x1; x++) {
+      const on = cl.some((c) => label[my * w + x] === c.id);
+      if (on && !prev) midRuns++;
+      prev = on;
+    }
+  }
+  const hollowSquare = cl.length === 1 && fill < 0.5 && midRuns === 2 && edgeFull(y0, 1) && edgeFull(y1 - 1, -1);
+  let mark = null;
+  if (hollowSquare && rel >= 0.6 && rel <= 0.92) mark = "\u25A1";
+  else if (nested && fill < 0.45 && rel >= 0.6) mark = "\u25CE";
+  else if (cl.length === 1 && fill >= 0.9 && rel >= 0.28 && rel <= 0.6) mark = "\u25AA";
+  else if (cl.length === 1 && fill >= 0.65 && fill <= 0.88 && rel >= 0.5 && rel <= 0.8) mark = "\u25CF";
+  if (!mark) return null;
+  return { mark, covers: firstX <= x1 + ch * 0.3 };
+}
+
+// src/ocr/text-gaps.ts
+var evidence = /* @__PURE__ */ new WeakMap();
+var NO_GAPS = [];
+function rememberOcrTextGaps(item, gaps) {
+  if (gaps.length) evidence.set(item, { text: item.text, gaps });
+}
+function ocrTextGaps(item) {
+  const saved = evidence.get(item);
+  return saved?.text === item.text ? saved.gaps : NO_GAPS;
+}
+function copyOcrTextGaps(source, target, scale = 1, offsetX = 0) {
+  const gaps = ocrTextGaps(source);
+  if (!gaps.length || source.text !== target.text) return;
+  rememberOcrTextGaps(target, scale === 1 && offsetX === 0 ? gaps : gaps.map((g) => ({ ...g, left: g.left * scale + offsetX, right: g.right * scale + offsetX })));
+}
+function findOcrTextGaps(rgba, pageW, box, read, text, steps, stepPx) {
+  if (read.replace(/\s/g, "") !== text.replace(/\s/g, "") || [...read].length !== steps.length) return [];
+  const visible = [...read].flatMap((c, i) => /\s/.test(c) ? [] : [(steps[i] + 0.5) * stepPx]);
+  if (visible.length < 2) return [];
+  const gray = grayCrop(rgba, pageW, box), ink = inkStats(gray);
+  if (!ink.darkInk || ink.contrast < 35) return [];
+  const counts = new Uint32Array(box.w);
+  for (let y = 0; y < box.h; y++) for (let x = 0; x < box.w; x++) if (gray[y * box.w + x] <= ink.threshold) counts[x]++;
+  const out = [];
+  let offset = 0, index = 0;
+  for (const c of text) {
+    if (!/\s/.test(c)) {
+      if (index > 0) {
+        const from = Math.max(0, Math.floor(visible[index - 1]) + 1), end = Math.min(box.w, Math.ceil(visible[index]));
+        let start = from, left = from, right = from;
+        for (let x = from; x <= end; x++) {
+          if (x === end || counts[x] > Math.max(1, Math.floor(box.h * 0.03))) {
+            if (x - start > right - left) {
+              left = start;
+              right = x;
+            }
+            start = x + 1;
+          }
+        }
+        if (right - left >= Math.max(3, box.h * 0.25)) out.push({ at: offset, left: box.x + left, right: box.x + right });
+      }
+      index++;
+    }
+    offset += c.length;
+  }
+  return out;
+}
+
 // src/pdf/line-extract.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
 var ORIENTATION_TOL = 2;
@@ -1246,7 +2013,17 @@ function dropHeadBandClipGrids(clipGrids, lineGrids) {
   if (clipGrids.length === 0 || lineGrids.length === 0) return clipGrids;
   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) => 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))));
+  const kept = 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))));
+  return kept.filter((c) => !lineGrids.some((l) => headBandTiles(kept, l, near2, overlaps).includes(c)));
+}
+function headBandTiles(clips, l, near2, overlaps) {
+  const onRow = (y) => l.rowYs.some((r) => near2(r, y));
+  const band = clips.filter((c) => !c.clipParent && c.cells?.length && near2(c.bbox.y2, l.bbox.y2) && c.bbox.y1 > l.bbox.y1 + SHADE_CLIP_TOL && c.bbox.x1 >= l.bbox.x1 - SHADE_CLIP_TOL && c.bbox.x2 <= l.bbox.x2 + SHADE_CLIP_TOL && c.rowYs.every(onRow)).sort((a, b) => a.bbox.x1 - b.bbox.x1);
+  if (band.length < 2 || !near2(band[0].bbox.x1, l.bbox.x1) || !near2(band[band.length - 1].bbox.x2, l.bbox.x2)) return [];
+  if (band.some((c, k) => k > 0 && c.bbox.x1 > band[k - 1].bbox.x2 + SHADE_CLIP_TOL)) return [];
+  const bottom = Math.min(...band.map((c) => c.bbox.y1));
+  const body = { ...l.bbox, y2: bottom };
+  return clips.some((o) => !band.includes(o) && overlaps(o.bbox, body)) ? [] : band;
 }
 function enforceMinWidth(colXs, minWidth, narrowRuns = true) {
   if (colXs.length <= 2) return colXs;
@@ -3698,6 +4475,59 @@ function joinClusterCellLines(lines, box, lex) {
   return out;
 }
 
+// src/pdf/ocr-column-cuts.ts
+var OCR_NUMERIC_CELL = /^[+-]?\d+(?:[,.]\d+)*%?$/;
+var OCR_GROUPED_NUMBER = /^[+-]?\d{1,3}(?:\s+\d{3})+(?:[.,]\d+)?%?$/;
+function supportedOcrColumnCuts(rows) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (const head of rows[0] ?? []) {
+    if (head.items.length !== 1 || head.items[0].fontName !== "ocr") continue;
+    const candidates = [];
+    for (const gap of ocrTextGaps(head.items[0])) {
+      const text = head.items[0].text;
+      if (!/\p{L}/u.test(text.slice(0, gap.at)) || !/\p{L}/u.test(text.slice(gap.at))) continue;
+      const intervals = [];
+      for (const row of rows.slice(1)) {
+        const cell = row.find((c) => c.col === head.col);
+        if (!cell || cell.items.some((it) => it.fontName !== "ocr")) continue;
+        let interval;
+        if (cell.items.length === 1) {
+          const it = cell.items[0];
+          interval = ocrTextGaps(it).find((g) => isOcrNumericSplit(it.text, g.at));
+        } else if (isOcrNumericPair(cell.items)) {
+          const [a, b] = [...cell.items].sort((a2, b2) => a2.x - b2.x);
+          interval = { left: a.x + a.w / 2, right: b.x + b.w / 2 };
+        }
+        if (interval) {
+          const left = Math.max(gap.left, interval.left), right = Math.min(gap.right, interval.right);
+          if (right > left) intervals.push({ left, right });
+        }
+      }
+      const events = intervals.flatMap((i) => [{ x: i.left, delta: 1 }, { x: i.right, delta: -1 }]).sort((a, b) => a.x - b.x);
+      let active = 0, bestCount = 1, bestWidth = 0, cut;
+      for (let i = 0; i < events.length; ) {
+        const x = events[i].x;
+        while (i < events.length && events[i].x === x) active += events[i++].delta;
+        const width = i < events.length ? events[i].x - x : 0;
+        if (active >= 2 && width > 0 && (active > bestCount || active === bestCount && width > bestWidth)) {
+          bestCount = active;
+          bestWidth = width;
+          cut = x + width / 2;
+        }
+      }
+      if (cut !== void 0) candidates.push(cut);
+    }
+    if (candidates.length === 1) cuts.set(head.col, candidates[0]);
+  }
+  return cuts;
+}
+function isOcrNumericPair(items) {
+  return items.length === 2 && items.every((it) => it.fontName === "ocr" && OCR_NUMERIC_CELL.test(it.text.trim())) && !OCR_GROUPED_NUMBER.test([...items].sort((a, b) => a.x - b.x).map((it) => it.text.trim()).join(" "));
+}
+function isOcrNumericSplit(text, at) {
+  return !OCR_GROUPED_NUMBER.test(text.trim()) && /\s/.test((text[at - 1] ?? "") + (text[at] ?? "")) && OCR_NUMERIC_CELL.test(text.slice(0, at).trim()) && OCR_NUMERIC_CELL.test(text.slice(at).trim());
+}
+
 // src/pdf/cluster-detector.ts
 var Y_TOL = 3;
 var COL_CLUSTER_TOL = 15;
@@ -4462,17 +5292,21 @@ function assignRowItems(items, columns, numCols, headerFace) {
   return result;
 }
 function buildClusterTable(rows, columns, pageNum, lex) {
-  const numCols = columns.length;
   const numRows = rows.length;
-  if (numRows < MIN_ROWS || numCols < MIN_COLS) return null;
+  if (numRows < MIN_ROWS || columns.length < MIN_COLS) return null;
+  const headFaces = new Set(rows[0]?.items.map((i) => i.fontName));
+  const headerFace = headFaces.size === 1 && rows.slice(1).every((row) => row.items.every((i) => !headFaces.has(i.fontName))) ? [...headFaces][0] : void 0;
+  const assigned = rows.map((row, r) => assignRowItems(row.items, columns, columns.length, r === 0 ? headerFace : void 0));
+  const cuts = supportedOcrColumnCuts(assigned);
+  const starts = columns.map((_, c) => c + [...cuts.keys()].filter((k) => k < c).length);
+  const numCols = columns.length + cuts.size;
   const cells = Array.from(
     { length: numRows },
     () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
   );
   const usedItems = /* @__PURE__ */ new Set();
   const lines = cells.map((row) => row.map(() => []));
-  const headFaces = new Set(rows[0]?.items.map((i) => i.fontName));
-  const headerFace = headFaces.size === 1 && rows.slice(1).every((row) => row.items.every((i) => !headFaces.has(i.fontName))) ? [...headFaces][0] : void 0;
+  const origins = /* @__PURE__ */ new Map();
   for (let r = 0; r < numRows; r++) {
     const row = rows[r];
     if (row.items.length === 1 && numCols > 1) {
@@ -4480,15 +5314,39 @@ function buildClusterTable(rows, columns, pageNum, lex) {
       usedItems.add(row.items[0]);
       continue;
     }
-    const assignments = assignRowItems(row.items, columns, numCols, r === 0 ? headerFace : void 0);
-    for (const { col, items } of assignments) {
+    const assignments = assigned[r].flatMap(({ col, items }) => {
+      const target = starts[col], cut = cuts.get(col);
+      if (cut === void 0) return [{ col: target, items, span: 1 }];
+      const gapAt = (it) => ocrTextGaps(it).find((g) => g.left < cut && g.right > cut && (r === 0 || isOcrNumericSplit(it.text, g.at)));
+      const groupedNumber = OCR_GROUPED_NUMBER.test([...items].sort((a, b) => a.x - b.x).map((it) => it.text.trim()).join(" "));
+      if (groupedNumber || !isOcrNumericPair(items) && items.some((it) => it.x < cut && it.x + it.w > cut && !gapAt(it))) return [{ col: target, items, span: 2 }];
+      const parts = [[], []];
+      for (const it of items) {
+        const g = gapAt(it);
+        if (!g) {
+          parts[it.x + it.w / 2 < cut ? 0 : 1].push(it);
+          continue;
+        }
+        const fragments = [
+          { ...it, text: it.text.slice(0, g.at).trimEnd(), w: g.left - it.x },
+          { ...it, text: it.text.slice(g.at).trimStart(), x: g.right, w: it.x + it.w - g.right }
+        ];
+        fragments.forEach((fragment, side) => {
+          origins.set(fragment, it);
+          parts[side].push(fragment);
+        });
+      }
+      return parts.flatMap((part, side) => part.length ? [{ col: target + side, items: part, span: 1 }] : []);
+    });
+    for (const { col, items, span: span2 } of assignments) {
+      cells[r][col].colSpan = span2;
       const cell = lines[r][col];
       if (cell.length) cell[cell.length - 1].spaceAfter = true;
       cell.push(...clusterCellLines(items));
-      for (const item of items) usedItems.add(item);
+      for (const item of items) usedItems.add(origins.get(item) ?? item);
     }
   }
-  const boxes = columns.map((_, c) => {
+  const boxes = Array.from({ length: numCols }, (_, c) => {
     const col = lines.flatMap((row) => row[c]);
     return { x1: Math.min(...col.map((l) => l.left)), x2: Math.max(...col.map((l) => l.right)) };
   });
@@ -4511,7 +5369,7 @@ function buildClusterTable(rows, columns, pageNum, lex) {
     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;
+        if (cells[pr].some((c) => c.colSpan > 1)) break;
         for (let c = 0; c < numCols; c++) {
           if (!cells[r][c].text.trim()) continue;
           lines[pr][c].push(...lines[r][c]);
@@ -8705,18 +9563,22 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
   let panels = null;
   if (remaining.length > 0) {
     remaining.sort((a, b) => b.y - a.y || a.x - b.x);
-    const clusterItems = remaining.map((i) => ({
-      text: i.text,
-      x: i.x,
-      y: i.y,
-      w: i.w,
-      h: i.h,
-      fontSize: i.fontSize,
-      fontName: i.fontName,
-      hasSpaceBefore: i.hasSpaceBefore,
-      syntheticSpace: i.syntheticSpace,
-      spaceAfter: i.spaceAfter
-    }));
+    const clusterItems = remaining.map((i) => {
+      const item = {
+        text: i.text,
+        x: i.x,
+        y: i.y,
+        w: i.w,
+        h: i.h,
+        fontSize: i.fontSize,
+        fontName: i.fontName,
+        hasSpaceBefore: i.hasSpaceBefore,
+        syntheticSpace: i.syntheticSpace,
+        spaceAfter: i.spaceAfter
+      };
+      copyOcrTextGaps(i, item);
+      return item;
+    });
     const proseColumns = findTwoColumnProseCutX(clusterItems) !== null || detectPersistentColumnGutter(remaining.map((i) => ({ x: i.x, y: i.y, w: i.w, h: i.h > 0 ? i.h : i.fontSize }))) !== null;
     const clusterResults = (proseColumns ? [] : detectClusterTables(clusterItems, pageNum, void 0, lex)).filter((cr) => {
       const b = cr.bbox;
@@ -9032,18 +9894,22 @@ function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTable
     if (cards) return cards.flatMap((group) => extractPageBlocksFallback(group, pageNum, false, detectTables, lex));
   }
   const blocks = [];
-  const clusterItems = items.map((i) => ({
-    text: i.text,
-    x: i.x,
-    y: i.y,
-    w: i.w,
-    h: i.h,
-    fontSize: i.fontSize,
-    fontName: i.fontName,
-    hasSpaceBefore: i.hasSpaceBefore,
-    syntheticSpace: i.syntheticSpace,
-    spaceAfter: i.spaceAfter
-  }));
+  const clusterItems = items.map((i) => {
+    const item = {
+      text: i.text,
+      x: i.x,
+      y: i.y,
+      w: i.w,
+      h: i.h,
+      fontSize: i.fontSize,
+      fontName: i.fontName,
+      hasSpaceBefore: i.hasSpaceBefore,
+      syntheticSpace: i.syntheticSpace,
+      spaceAfter: i.spaceAfter
+    };
+    copyOcrTextGaps(i, item);
+    return item;
+  });
   const textRects = items.map((i) => ({ x: i.x, y: i.y, w: i.w, h: i.h > 0 ? i.h : i.fontSize }));
   const imagePanels = fullPage ? splitImagePanels(items, figures) : null;
   if (imagePanels) return imagePanels.flatMap((group) => extractPageBlocksFallback(group, pageNum, false, detectTables, lex));
@@ -9264,6 +10130,29 @@ export {
   ensureOcrModelsFor,
   ocrModelsCached,
   parseCharacterDict,
+  grayCrop,
+  inkStats,
+  splitRowBands,
+  leadingTriangle,
+  leaderRuns,
+  inkBounds,
+  bracketFeatures,
+  romanStems,
+  circledAt,
+  quoteHead,
+  edgeTrim,
+  tallInkCount,
+  gapGlyphs,
+  ringBullet,
+  dashRatio,
+  discAt,
+  serifOne,
+  starRun,
+  bracketShape,
+  leadingBullet,
+  rememberOcrTextGaps,
+  copyOcrTextGaps,
+  findOcrTextGaps,
   extractLines,
   extractImageRegions,
   NO_EDGES,
@@ -9318,4 +10207,4 @@ export {
   UNRULED_REGION_TABLES,
   mergeOcrImageRegions
 };
-//# sourceMappingURL=chunk-GYX26HZR.js.map
+//# sourceMappingURL=chunk-DPB6ZVQ5.js.map