kordoc 4.16.0 → 4.16.2

package/dist/{chunk-XHOZB2WP.js → chunk-UTP2WCHS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extractPageBlocksWithLines
-} from "./chunk-43FKGDDO.js";
+} from "./chunk-SFEQYKYJ.js";
 import {
   OCR_DET_MODEL,
   OCR_REC_DICT,
@@ -9,10 +9,10 @@ import {
   ensureOcrModels,
   getOcrModelsDir,
   parseCharacterDict
-} from "./chunk-N6TPODYL.js";
+} from "./chunk-DES2LGFZ.js";
 import {
   OPTIONAL_DEP_INSTALL_HINT
-} from "./chunk-RC4C7Q33.js";
+} from "./chunk-P6ZDXTV6.js";
 
 // src/ocr/ruling-lines.ts
 var INK_LUMA_MAX = 205;
@@ -188,19 +188,19 @@ function solidRuns(mask, base, step, span, minLenPx) {
 function dottedRuns(mask, base, step, span, minLenPx, maxGap, maxDash, maxPeriod) {
   const runs = [];
   const chain = [];
-  const median = (xs) => xs.sort((a, b) => a - b)[xs.length >> 1];
+  const median2 = (xs) => xs.sort((a, b) => a - b)[xs.length >> 1];
   const flush = () => {
     const cnt = chain.length >> 1;
     if (cnt >= DOT_MIN_COUNT && chain[chain.length - 1] - chain[0] + 1 >= minLenPx) {
-      const periods = [], dashes = [], gaps = [];
+      const periods = [], dashes = [], gaps2 = [];
       for (let k = 0; k < cnt; k++) {
         dashes.push(chain[2 * k + 1] - chain[2 * k] + 1);
         if (k) {
           periods.push(chain[2 * k] - chain[2 * k - 2]);
-          gaps.push(chain[2 * k] - chain[2 * k - 1] - 1);
+          gaps2.push(chain[2 * k] - chain[2 * k - 1] - 1);
         }
       }
-      if (median(periods) <= maxPeriod || median(dashes) >= 1.5 * median(gaps)) runs.push({ lo: chain[0], hi: chain[chain.length - 1] });
+      if (median2(periods) <= maxPeriod || median2(dashes) >= 1.5 * median2(gaps2)) runs.push({ lo: chain[0], hi: chain[chain.length - 1] });
     }
     chain.length = 0;
   };
@@ -573,12 +573,614 @@ function inkBounds(gray, w, h, ink) {
   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 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 && !(nearlyApart && ch >= bh * 0.6)) {
+      if (small) out.push({ x0: c.x0, x1: c.x1, mark: "\xB7
" });
+      continue;
+    }
+    if (!apart) {
+    } 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) {
+      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) mark = "\u300C";
+      else if (c.y1 >= bandB - bh * 0.15 && bottom >= 0.7 && top <= 0.5 && stem(c.y0, c.y1 - band) >= 0.65) mark = "\u300D";
+    } 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 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 span = (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] = span(0.4, 0.6), [t0, t1] = span(0, 0.2), [b0, b1] = span(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 stars2 = comps.filter(star).sort((a, b) => a.x0 - b.x0);
+  const k = stars2.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 && stars2[lo].x0 - stars2[lo - 1].x1 <= stars2[lo].x1 - stars2[lo].x0) lo--;
+  while (hi + 1 < stars2.length && stars2[hi + 1].x0 - stars2[hi].x1 <= stars2[hi].x1 - stars2[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 [near, far] = close ? [f.bottom, f.top] : [f.top, f.bottom];
+  const paren = close ? ")" : "(";
+  if (near >= 0.7 && far <= 0.5) return f.taper < BRACKET_TAPER ? close ? "\u300D" : "\u300C" : paren;
+  if (near >= 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 ring2 = (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 && ring2(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 span = (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, span(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/glyph-restore.ts
+function restoreGlyphs(rgba, pageW, box, text, steps, stepPx, note = {}) {
+  const chars = [...text];
+  if (chars.length !== steps.length) return text;
+  const gray = grayCrop(rgba, pageW, box);
+  const c = { chars, cx: (i) => (steps[i] + 0.5) * stepPx, gray, w: box.w, h: box.h, ink: inkStats(gray) };
+  if (/[[\]]/.test(text)) brackets(c);
+  if (/['"]/.test(text)) quotes(c);
+  if (/(^|\D)[1-9](\D|$)/.test(text)) circled(c);
+  if (text.includes("*")) stars(c);
+  if (/[\u00b7\u2022]/.test(text)) discs(c);
+  gaps(c);
+  note.ringLead = ring(c);
+  if (/[I1Ⅰ-Ⅲ]|^\s*\./.test(text)) roman(c);
+  return chars.join("");
+}
+function brackets({ chars, cx, gray, w, h, ink }) {
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] !== "[" && chars[i] !== "]") continue;
+    const f = bracketFeatures(gray, w, h, ink, cx(i));
+    const shape = f && bracketShape(f, chars[i] === "]");
+    if (shape) chars[i] = shape;
+  }
+}
+function quotes({ chars, cx, gray, w, h, ink }) {
+  const year = (i) => chars[i] === "'" && !/[\p{L}\p{N}]/u.test(chars[i - 1] ?? "") && /^\d{2}(?!\d)/.test(chars.slice(i + 1, i + 4).join(""));
+  const single = { "'": chars.filter((c, i) => c === "'" && !year(i)).length === 1, '"': chars.filter((c) => c === '"').length === 1 };
+  const open = { "'": false, '"': false };
+  for (let i = 0; i < chars.length; i++) {
+    const c = chars[i];
+    const kind = c === "'" || c === "\u2018" || c === "\u2019" ? "'" : c === '"' || c === "\u201C" || c === "\u201D" ? '"' : null;
+    if (!kind) continue;
+    if (c !== kind) {
+      open[kind] = c === "\u2018" || c === "\u201C";
+      continue;
+    }
+    if (open[kind]) {
+      open[kind] = false;
+      continue;
+    }
+    if (!year(i) && !single[kind]) continue;
+    const r = quoteHead(gray, w, h, ink, cx(i));
+    if (r !== null && r >= 0.47) {
+      chars[i] = kind === "'" ? "\u2018" : "\u201C";
+      open[kind] = true;
+    }
+  }
+}
+function circled({ chars, cx, gray, w, h, ink }) {
+  const at = chars.flatMap((c, i) => /^[1-9]$/.test(c) && !/\d/.test(chars[i - 1] ?? "") && !/\d/.test(chars[i + 1] ?? "") ? [i] : []);
+  if (!at.length) return;
+  const hit = circledAt(gray, w, h, ink, at.map(cx));
+  at.forEach((i, k) => {
+    if (hit[k]) chars[i] = String.fromCharCode(9311 + Number(chars[i]));
+  });
+}
+function stars({ chars, cx, gray, w, h, ink }) {
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] !== "*" || chars[i - 1] === "*") continue;
+    let e = i;
+    while (chars[e + 1] === "*") e++;
+    const n = starRun(gray, w, h, ink, cx(i));
+    if (n > e - i + 1 && n <= 4) chars[e] += "*".repeat(n - (e - i + 1));
+    i = e;
+  }
+}
+function discs({ chars, cx, gray, w, h, ink }) {
+  for (let i = 0; i < chars.length; i++) if (/^[\u00b7\u2022]$/.test(chars[i]) && discAt(gray, w, h, ink, cx(i))) chars[i] = "\u25CF";
+}
+function gaps({ chars, cx, gray, w, h, ink }) {
+  const { glyphs, bandH } = gapGlyphs(gray, w, h, ink);
+  if (!glyphs.length) return;
+  const live = chars.map((c, i) => i).filter((i) => chars[i].trim());
+  if (!live.length) return;
+  const d = [];
+  for (let k = 0; k + 1 < live.length; k++) if (/[가-힣]$/.test(chars[live[k]]) && /^[가-힣]/.test(chars[live[k + 1]])) d.push(cx(live[k + 1]) - cx(live[k]));
+  const pitch = d.length >= 2 ? d.sort((a, b) => a - b)[d.length >> 1] : bandH;
+  const nearTo = (g) => (i) => Math.abs(cx(i) - (g.x0 + g.x1) / 2) <= Math.max(pitch * 0.45, (g.x1 - g.x0) / 2 + 1);
+  const loose = glyphs.filter((g) => /^[\u00b7.]/.test(g.mark) && !live.some(nearTo(g)));
+  for (const g of glyphs.sort((a, b) => a.x0 - b.x0)) {
+    const mid = (g.x0 + g.x1) / 2;
+    const near = nearTo(g);
+    const cover = live.filter(near);
+    if (g.mark === "\xB7
") {
+      const sp = chars.findIndex((c, i) => c === " " && near(i));
+      const p = sp >= 0 ? chars.slice(0, sp).reverse().find((c) => c.trim()) : void 0, q = sp >= 0 ? chars.slice(sp + 1).find((c) => c.trim()) : void 0;
+      if (p && q && /[가-힣]$/.test(p) && /^[가-힣]/.test(q) && !loose.some((o) => o !== g && Math.abs((o.x0 + o.x1) / 2 - mid) <= pitch * 1.5)) chars[sp] = "\xB7";
+      continue;
+    }
+    if (cover.length) {
+      if (g.mark.startsWith("\u25A1") && cover.length === 1 && /^[0Oo\u25cb]$/.test(chars[cover[0]])) chars[cover[0]] = "\u25A1";
+      continue;
+    }
+    if (g.mark === "\u25A1\0") continue;
+    const before = live.filter((i) => cx(i) < mid), after = live.filter((i) => cx(i) > mid);
+    if (!before.length) {
+      if (after.length && /^[\u3002\u00b7\u300c\u25b2]$/.test(g.mark) && /^[가-힣]/.test(chars[after[0]])) chars[after[0]] = g.mark + chars[after[0]];
+      else if (g.mark === "-" && /^[\dⅰ-ⅹivx]+\s*-$/.test(chars.join("").trim())) chars[after[0]] = "-" + chars[after[0]];
+      continue;
+    }
+    if (!after.length && g.mark !== ".") continue;
+    if (g.mark === "/" && !(/\d$/.test(chars[before[before.length - 1]]) && /^\d/.test(chars[after[0]]))) continue;
+    const prev = chars[before[before.length - 1]], next = after.length ? chars[after[0]] : "";
+    if (g.mark === "\xB7" || g.mark === ".") {
+      if (loose.some((o) => o !== g && Math.abs((o.x0 + o.x1) / 2 - mid) <= pitch * 1.5)) continue;
+      if (/[\u2026.\u00b7]$/.test(prev) || /^[\u2026.\u00b7]/.test(next)) continue;
+    }
+    if (g.mark === "\xB7") {
+      if (/^\d/.test(next)) continue;
+      const sp = chars.findIndex((c, i) => c === " " && near(i));
+      if (sp >= 0) {
+        chars[sp] = g.mark;
+        continue;
+      }
+    }
+    chars[before[before.length - 1]] += g.mark;
+  }
+}
+function ring({ chars, cx, gray, w, h, ink }) {
+  const k = chars.findIndex((c) => c.trim());
+  if (k < 0 || !/^[\u3147Oo0\u25cb]$/.test(chars[k])) return false;
+  const rest = chars.slice(k + 1).join("").trimStart();
+  if (!/^[(\[「【<]?[가-힣]/.test(rest)) return false;
+  const r = ringBullet(gray, w, h, ink, cx(k));
+  if (r) chars[k] = r;
+  return r !== null;
+}
+function roman({ chars, cx, gray, w, h, ink }) {
+  const ROMAN = /^[IⅠ-Ⅲ]$/, LATIN = /[A-Za-z]$/;
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] !== "1" || /[\dA-Za-z]$/.test(chars[i - 1] ?? "") || /^[\dA-Za-z,]/.test(chars[i + 1] ?? "")) continue;
+    if (serifOne(gray, w, h, ink, cx(i))) chars[i] = "\u2160";
+  }
+  const inRoman = (i) => ROMAN.test(chars[i]) || chars[i] === "1" && (ROMAN.test(chars[i - 1] ?? "") || ROMAN.test(chars[i + 1] ?? ""));
+  const k = chars.findIndex((c) => c.trim());
+  if (chars[k] === "." && chars.slice(k + 1).some((c) => /[가-힣A-Za-z0-9]/.test(c))) {
+    const n = romanStems(gray, w, h, ink, -Infinity, cx(k));
+    if (n) chars[k] = String.fromCharCode(8543 + n) + chars[k];
+  }
+  for (let s = 0; s < chars.length; ) {
+    if (!inRoman(s) || s > 0 && LATIN.test(chars[s - 1])) {
+      s++;
+      continue;
+    }
+    let e = s;
+    while (e < chars.length && inRoman(e)) e++;
+    const tok = chars.slice(s, e).join("");
+    if (e < chars.length && /^[A-Za-z]/.test(chars[e])) {
+      s = e;
+      continue;
+    }
+    let p = s - 1, q = e;
+    while (p >= 0 && !chars[p].trim()) p--;
+    while (q < chars.length && !chars[q].trim()) q++;
+    const n = romanStems(gray, w, h, ink, p >= 0 ? cx(p) : -Infinity, q < chars.length ? cx(q) : Infinity);
+    const canon = n ? [["\u2160", "I"], ["\u2161", "II"], ["\u2162", "III"]][n - 1] : null;
+    if (canon && !canon.includes(tok)) {
+      chars[s] = canon[0];
+      for (let i = s + 1; i < e; i++) chars[i] = "";
+    }
+    s = e;
+  }
+}
 
 // src/ocr/postprocess.ts
 var HANGUL_START = /^[\uac00-\ud7a3]/;
-function restoreSymbols(text) {
+function restoreSymbols(text, ringDecided = false) {
   let s = text;
-  s = s.replace(/^([Oo])(\s?)(?=[\uac00-\ud7a3])/, "\u25CB$2");
+  if (!ringDecided) s = s.replace(/^([Oo])(\s?)(?=[\uac00-\ud7a3])/, "\u25CB$2");
   s = s.replace(/(?<![A-Za-z])O{2,}(?![A-Za-z])/g, (m, i) => /[\uac00-\ud7a3]$/.test(s.slice(Math.max(0, i - 2), i).trimEnd()) || /^\s?[\uac00-\ud7a3]/.test(s.slice(i + m.length)) ? "\u25CB".repeat(m.length) : m);
   s = s.replace(/[\u2206\u0394]/g, "\u25B3");
   s = s.replace(/\(cid:\d*\)/g, "");
@@ -698,7 +1300,7 @@ function bandBoxes(b, bands, pageH) {
   }
   return out;
 }
-function lineCrop(rgba, pageW, box, rot) {
+function lineCrop(rgba, pageW, box, rot, keep) {
   const srcW = rot === 0 ? box.w : box.h;
   const srcH = rot === 0 ? box.h : box.w;
   const rw = Math.min(REC_MAX_WIDTH, Math.max(16, Math.round(srcW * REC_HEIGHT / srcH)));
@@ -733,6 +1335,10 @@ function lineCrop(rgba, pageW, box, rot) {
       const wx = sx - x0;
       const i00 = at(x0, y0), i01 = at(x1, y0), i10 = at(x0, y1), i11 = at(x1, y1);
       const o = (dy * rw + dx) * 3;
+      if (keep && rot === 0 && (sx < keep.x0 || sx >= keep.x1 || sy < keep.y0 || sy >= keep.y1)) {
+        rgb[o] = rgb[o + 1] = rgb[o + 2] = keep.bg;
+        continue;
+      }
       for (let c = 0; c < 3; c++) {
         const top = rgba[i00 + c] * (1 - wx) + rgba[i01 + c] * wx;
         const bottom = rgba[i10 + c] * (1 - wx) + rgba[i11 + c] * wx;
@@ -766,6 +1372,7 @@ var DEFAULT_OCR_TUNING = Object.freeze({
   textScore: 0.5,
   recBatch: 1,
   splitTall: true,
+  trimEdges: true,
   minInkContrast: 35,
   postprocess: true,
   tightBoxes: true,
@@ -777,6 +1384,7 @@ var REC_MIN_WIDTH = 320;
 var REC_BATCH_MAX_PIXELS = 48 * 16e3;
 var TALL_RATIO = 1.5;
 var ROTATE_RATIO = 3;
+var KEEP_MARGIN = 0.06;
 var LEADER_MIN_DOTS = 4;
 var LEADER_CONTEXT = 0.5;
 var MIN_INK_RATIO = 0.01;
@@ -862,6 +1470,8 @@ var OcrEngine = class _OcrEngine {
           continue;
         }
       }
+      const trim = tuning.trimEdges ? edgeTrim(gray, b.w, b.h, ink) : null;
+      const keep = trim ? { ...trim, bg: median(gray) } : void 0;
       const leaders = tuning.splitLeaders ? leaderRuns(gray, b.w, b.h, ink, LEADER_MIN_DOTS) : [];
       if (leaders.length) {
         const join2 = joins.length;
@@ -880,20 +1490,37 @@ var OcrEngine = class _OcrEngine {
         joins[join2].trailDots = dots;
         continue;
       }
+      if (keep) jobs.push({ box: b, rot: 0, group, keep });
       jobs.push({ box: b, rot: 0, group: group++ });
     }
     const results = await this.recognizeJobs(rgba, width, jobs, tuning.recBatch);
     const best = /* @__PURE__ */ new Map();
+    const score = (job, confidence) => confidence - (job.keep ? KEEP_MARGIN : 0);
     jobs.forEach((job, i) => {
       const r = results[i];
       if (!r) return;
       const cur = best.get(job.group);
-      if (!cur || r.confidence > cur.confidence) best.set(job.group, { job, ...r });
+      if (!cur || score(job, r.confidence) > score(cur.job, cur.confidence)) best.set(job.group, { job, ...r });
     });
     let items = [];
-    for (const { job, text: raw, confidence } of best.values()) {
-      let text = tuning.postprocess ? restoreSymbols(raw.trim()) : raw;
+    for (const { job, text: read, confidence, steps, stepPx } of best.values()) {
+      const note = {};
+      const raw = tuning.postprocess && job.rot === 0 ? restoreGlyphs(rgba, width, job.box, read, steps, stepPx, note) : read;
+      let text = tuning.postprocess ? restoreSymbols(raw.trim(), note.ringLead) : raw;
       if (!text.trim()) continue;
+      if (tuning.postprocess && job.rot === 0 && !/^[◎●▪□■○ㅇ]/.test(text)) {
+        const chars = [...read], k = chars.findIndex((c) => c.trim());
+        if (k >= 0 && steps.length === chars.length) {
+          const g = grayCrop(rgba, width, job.box);
+          const b = leadingBullet(g, job.box.w, job.box.h, inkStats(g), (steps[k] + 0.5) * stepPx);
+          const body = (text.match(/[가-힣]/g) ?? []).length >= 4;
+          const miss = /^[Oo0•·ㆍ∙‧○]/.test(text);
+          if (b?.mark === "\u25CE" && b.covers && /^[Oo0○]/.test(text)) text = b.mark + " " + text.slice(1).trimStart();
+          else if (b?.mark === "\u25A1") {
+            if (!b.covers && body) text = b.mark + " " + text;
+          } else if (b && b.mark !== "\u25CE" && body) text = b.covers ? miss ? b.mark + " " + text.slice(1).trimStart() : text : b.mark + " " + text;
+        }
+      }
       if (tuning.postprocess && /^\d/.test(text) && job.rot === 0) {
         const g = grayCrop(rgba, width, job.box);
         const tri = leadingTriangle(g, job.box.w, job.box.h, inkStats(g));
@@ -974,7 +1601,7 @@ var OcrEngine = class _OcrEngine {
   // ─── rec ─────────────────────────────────────────────
   /** 라인 작업들을 폭 비율 순으로 배치 인식 — 결과는 jobs 순서 */
   async recognizeJobs(rgba, pageW, jobs, batchSize) {
-    const crops = jobs.map((j) => lineCrop(rgba, pageW, j.box, j.rot));
+    const crops = jobs.map((j) => lineCrop(rgba, pageW, j.box, j.rot, j.keep));
     const order = crops.map((_, i) => i).sort((a, b) => crops[a].w - crops[b].w);
     const results = new Array(jobs.length).fill(null);
     const plane = REC_HEIGHT;
@@ -1006,18 +1633,39 @@ var OcrEngine = class _OcrEngine {
       const [, T, C] = logits.dims;
       const data = logits.data;
       idx.forEach((ci, k) => {
-        results[ci] = ctcDecode(data.subarray(k * T * C, (k + 1) * T * C), T, C, this.dict);
+        const r = ctcDecode(data.subarray(k * T * C, (k + 1) * T * C), T, C, this.dict);
+        const job = jobs[ci], src = job.rot === 0 ? job.box.w : job.box.h;
+        let kept = r;
+        const last = crops[ci].w * T / bw + 1;
+        const chars = r ? [...r.text] : [];
+        if (r && job.rot === 0 && chars.length === r.steps.length && r.steps.some((t) => t > last) && !r.text.includes("(cid:")) {
+          const tallCh = (c) => !/[\s.,:;\u00b7\u2026'"\u2018-\u201d`\-_~]/.test(c);
+          const g = grayCrop(rgba, pageW, job.box);
+          const inside = chars.filter((c, i) => r.steps[i] <= last && tallCh(c)).length;
+          let budget = inside <= 2 ? tallInkCount(g, job.box.w, job.box.h, inkStats(g)) - inside : Infinity;
+          const keep = chars.map((c, i) => r.steps[i] <= last || !tallCh(c) || budget-- > 0);
+          if (!keep.every(Boolean)) kept = { ...r, text: chars.filter((_, i) => keep[i]).join(""), steps: r.steps.filter((_, i) => keep[i]) };
+        }
+        results[ci] = kept && { ...kept, stepPx: bw / T * (src / crops[ci].w) };
       });
       s = e;
     }
     return results;
   }
 };
+function median(gray) {
+  const hist = new Uint32Array(256);
+  for (let i = 0; i < gray.length; i++) hist[gray[i]]++;
+  for (let v = 0, n = 0; v < 256; v++) if ((n += hist[v]) * 2 >= gray.length) return v;
+  return 255;
+}
 function ctcDecode(data, T, C, dict) {
   let text = "";
   let confSum = 0;
   let confCount = 0;
   let prev = -1;
+  const runs = [];
+  let open = [];
   for (let t = 0; t < T; t++) {
     const off = t * C;
     let best = 0;
@@ -1031,7 +1679,12 @@ function ctcDecode(data, T, C, dict) {
     }
     const repeat = best === prev;
     prev = best;
-    if (best === 0 || repeat) continue;
+    if (repeat && best !== 0) {
+      for (const r of open) r[1] = t;
+      continue;
+    }
+    open = [];
+    if (best === 0) continue;
     let p = bestV;
     if (p > 1.0001 || p < 0) {
       let denom = 0;
@@ -1040,11 +1693,16 @@ function ctcDecode(data, T, C, dict) {
     }
     confSum += p;
     confCount++;
-    if (best >= 1 && best <= dict.length) text += dict[best - 1];
-    else if (best === dict.length + 1) text += " ";
+    const tok = best >= 1 && best <= dict.length ? dict[best - 1] : best === dict.length + 1 ? " " : "";
+    text += tok;
+    for (const _ of tok) {
+      const r = [t, t];
+      runs.push(r);
+      open.push(r);
+    }
   }
   if (!text) return null;
-  return { text, confidence: confCount > 0 ? confSum / confCount : 0 };
+  return { text, confidence: confCount > 0 ? confSum / confCount : 0, steps: runs.map(([a, b]) => (a + b) / 2) };
 }
 function componentBoxes(prob, w, h, thresh = DEFAULT_OCR_TUNING.detThresh, boxThresh = DEFAULT_OCR_TUNING.detBoxThresh) {
   const visited = new Uint8Array(w * h);
@@ -1263,7 +1921,7 @@ async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables, ve
     const upright = vectorOps ? rgba : deskewPage(rgba, rw, rh).rgba;
     const stats = { droppedLowConf: 0 };
     const ruling = vectorOps ? void 0 : detectRulingLines(upright, rw, rh, rh / pdfH);
-    const items = await engine.recognizePage(upright, rw, rh, stats, void 0, ruling?.cellDividers);
+    const items = await engine.recognizePage(upright, rw, rh, stats, regions ? REGION_TUNING : void 0, ruling?.cellDividers);
     if (stats.droppedLowConf > 0) {
       warnings.push({
         page: pageNo,
@@ -1315,6 +1973,7 @@ function halve(src, w, h) {
   }
   return { rgba: out, width: W, height: H };
 }
+var REGION_TUNING = Object.freeze({ ...DEFAULT_OCR_TUNING, trimEdges: false });
 function meanConfidence(items) {
   let n = 0, sum = 0;
   for (const it of items) {
@@ -1335,7 +1994,7 @@ async function closerReads(rgba, rw, rh, pdfH, hi, regions, engine) {
     }
     const crop = new Uint8Array(cw * ch * 4);
     for (let y = 0; y < ch; y++) crop.set(rgba.subarray(((y0 + y) * rw + x0) * 4, ((y0 + y) * rw + x0 + cw) * 4), y * cw * 4);
-    const items = await engine.recognizePage(crop, cw, ch);
+    const items = await engine.recognizePage(crop, cw, ch, void 0, REGION_TUNING);
     out.push(items.map((it) => ({ ...it, x: (it.x + x0) / 2, y: (it.y + y0) / 2, w: it.w / 2, h: it.h / 2 })));
   }
   return out;
@@ -1402,4 +2061,4 @@ export {
   runPdfOcr,
   ocrItemsToBlocks
 };
-//# sourceMappingURL=chunk-XHOZB2WP.js.map
+//# sourceMappingURL=chunk-UTP2WCHS.js.map