kordoc 4.24.6 → 4.24.8

package/dist/{chunk-JIU7E7Z6.cjs → chunk-73MRAQXA.cjs}

@@ -5,15 +5,15 @@
 
 
 
-var _chunkAM5ALISVcjs = require('./chunk-AM5ALISV.cjs');
+var _chunkNW2CKOFLcjs = require('./chunk-NW2CKOFL.cjs');
 
 
 
-var _chunk435ECXNGcjs = require('./chunk-435ECXNG.cjs');
+var _chunkJM7PZM6Ecjs = require('./chunk-JM7PZM6E.cjs');
 
 
 
-var _chunk2JDVPQ33cjs = require('./chunk-2JDVPQ33.cjs');
+var _chunkC3BOYTY5cjs = require('./chunk-C3BOYTY5.cjs');
 
 // src/ocr/models.ts
 var _path = require('path');
@@ -57,7 +57,7 @@ var OCR_REC_DICT = {
   sizeMb: 1
 };
 function getOcrModelsDir() {
-  return _chunk435ECXNGcjs.getModelsDir.call(void 0, "ppocr");
+  return _chunkJM7PZM6Ecjs.getModelsDir.call(void 0, "ppocr");
 }
 var DEFAULT_OCR_MODELS = Object.freeze({
   det: { spec: OCR_DET_MODEL },
@@ -99,7 +99,7 @@ async function ensureOcrModelsFor(sel, onProgress) {
     if (!stamp || verifiedInProcess.get(path) !== stamp) todo.push(s.spec);
   }
   if (!todo.length) return;
-  await _chunk435ECXNGcjs.ensureModelsIn.call(void 0, dir, todo, onProgress);
+  await _chunkJM7PZM6Ecjs.ensureModelsIn.call(void 0, dir, todo, onProgress);
   for (const spec of todo) {
     const path = _path.join.call(void 0, dir, spec.filename), stamp = await fileStamp(path);
     if (stamp) verifiedInProcess.set(path, stamp);
@@ -146,6 +146,773 @@ function ocrModelPath(spec) {
   return _path.join.call(void 0, 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: _nullishCoalesce(_optionalChain([bands, 'access', _7 => _7[0], 'optionalAccess', _8 => _8[0]]), () => ( 0)), y1: _nullishCoalesce(_optionalChain([bands, 'access', _9 => _9[0], 'optionalAccess', _10 => _10[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 = _nullishCoalesce(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, (_nullishCoalesce(counts.get(runs), () => ( 0))) + 1);
+  }
+  const [n, k] = _nullishCoalesce([...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 _optionalChain([saved, 'optionalAccess', _11 => _11.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
 var _pdfmjs = require('pdfjs-dist/legacy/build/pdf.mjs');
 var ORIENTATION_TOL = 2;
@@ -369,7 +1136,7 @@ function extractLines(fnArray, argsArray) {
         } else {
           const afterOp = arg0;
           const dataArr = args[1];
-          const pathData = _optionalChain([dataArr, 'optionalAccess', _7 => _7[0]]);
+          const pathData = _optionalChain([dataArr, 'optionalAccess', _12 => _12[0]]);
           if (pathData && typeof pathData === "object") {
             const len = Object.keys(pathData).length;
             let di = 0;
@@ -747,7 +1514,7 @@ function mergeParallelLines(lines, dir, nonRules) {
       const overlap2 = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
       const minLen = Math.min(prevEnd - prevStart, currEnd - currStart);
       if (overlap2 > minLen * 0.3) {
-        if (_optionalChain([nonRules, 'optionalAccess', _8 => _8.has, 'call', _9 => _9(prev)]) && !nonRules.has(curr)) nonRules.delete(prev);
+        if (_optionalChain([nonRules, 'optionalAccess', _13 => _13.has, 'call', _14 => _14(prev)]) && !nonRules.has(curr)) nonRules.delete(prev);
         if (dir === "h") {
           prev.x1 = Math.min(prev.x1, curr.x1);
           prev.x2 = Math.max(prev.x2, curr.x2);
@@ -815,8 +1582,8 @@ function extractImageRegions(fnArray, argsArray, respectClip = false) {
         break;
       case _pdfmjs.OPS.restore: {
         const state = stack.pop();
-        ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _10 => _10.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
-        clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _11 => _11.clip]), () => ( null));
+        ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _15 => _15.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
+        clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _16 => _16.clip]), () => ( null));
         break;
       }
       case _pdfmjs.OPS.transform: {
@@ -827,19 +1594,19 @@ function extractImageRegions(fnArray, argsArray, respectClip = false) {
       // Form XObject 는 /Matrix 공간에서 그린다 — pdfjs 인자 [matrix, bbox], End 에서 복원 (line-extract.ts 와 같음)
       case _pdfmjs.OPS.paintFormXObjectBegin: {
         stack.push({ ctm, clip });
-        const m = _optionalChain([argsArray, 'access', _12 => _12[i], 'optionalAccess', _13 => _13[0]]);
+        const m = _optionalChain([argsArray, 'access', _17 => _17[i], 'optionalAccess', _18 => _18[0]]);
         if (Array.isArray(m) && m.length >= 6) ctm = multiplyTransform(ctm, m);
         break;
       }
       case _pdfmjs.OPS.paintFormXObjectEnd: {
         const state = stack.pop();
-        ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _14 => _14.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
-        clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _15 => _15.clip]), () => ( null));
+        ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _19 => _19.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
+        clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _20 => _20.clip]), () => ( null));
         break;
       }
       case _pdfmjs.OPS.constructPath: {
         const [ops, coords] = argsArray[i];
-        pathRect = pathRect === void 0 && _optionalChain([ops, 'optionalAccess', _16 => _16.length]) === 1 && ops[0] === _pdfmjs.OPS.rectangle && _optionalChain([coords, 'optionalAccess', _17 => _17.length]) >= 4 ? transformedRect(ctm, coords[0], coords[1], coords[2], coords[3]) : null;
+        pathRect = pathRect === void 0 && _optionalChain([ops, 'optionalAccess', _21 => _21.length]) === 1 && ops[0] === _pdfmjs.OPS.rectangle && _optionalChain([coords, 'optionalAccess', _22 => _22.length]) >= 4 ? transformedRect(ctm, coords[0], coords[1], coords[2], coords[3]) : null;
         break;
       }
       case _pdfmjs.OPS.clip:
@@ -992,7 +1759,7 @@ function hasShadedRowBands(host, clips, fills, verticals, horizontals) {
   if (!host.colXs.slice(1, -1).every((x) => verticals.some((v) => !v.fromFill && near2(v.x1, x) && v.y1 <= host.bbox.y1 + tol && v.y2 >= host.bbox.y2 - tol))) return false;
   const covered = /* @__PURE__ */ new Set();
   for (const band of bands) {
-    if (band.clipParent || !_optionalChain([band, 'access', _18 => _18.cells, 'optionalAccess', _19 => _19.length]) || band.colXs.length !== host.colXs.length || !band.colXs.every((x, i) => near2(x, host.colXs[i]))) return false;
+    if (band.clipParent || !_optionalChain([band, 'access', _23 => _23.cells, 'optionalAccess', _24 => _24.length]) || band.colXs.length !== host.colXs.length || !band.colXs.every((x, i) => near2(x, host.colXs[i]))) return false;
     const start = host.rowYs.findIndex((y) => near2(y, band.rowYs[0]));
     if (start < 0 || !band.rowYs.every((y, i) => near2(y, host.rowYs[start + i]))) return false;
     if (!band.rowYs.every((y) => horizontals.some((h) => !h.fromFill && near2(h.y1, y) && h.x1 <= host.bbox.x1 + tol && h.x2 >= host.bbox.x2 - tol))) return false;
@@ -1094,7 +1861,7 @@ function mergeVertices(vertices) {
     const candidates = [];
     for (let dx = -1; dx <= 1; dx++) {
       for (let dy = -1; dy <= 1; dy++) {
-        const arr = _optionalChain([buckets, 'access', _20 => _20.get, 'call', _21 => _21(cx + dx), 'optionalAccess', _22 => _22.get, 'call', _23 => _23(cy + dy)]);
+        const arr = _optionalChain([buckets, 'access', _25 => _25.get, 'call', _26 => _26(cx + dx), 'optionalAccess', _27 => _27.get, 'call', _28 => _28(cy + dy)]);
         if (!arr) continue;
         for (const j of arr) {
           if (j > i && !used[j]) candidates.push(j);
@@ -1221,7 +1988,7 @@ function dropShadingClipGrids(clipGrids, lineGrids, fillRects, verticals = [], h
   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 (!_optionalChain([c, 'access', _24 => _24.cells, 'optionalAccess', _25 => _25.length]) || c.clipParent) return true;
+    if (!_optionalChain([c, 'access', _29 => _29.cells, 'optionalAccess', _30 => _30.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) => near2(f.x1, cell.bbox.x1) && near2(f.x2, cell.bbox.x2) && near2(f.y1, cell.bbox.y1) && near2(f.y2, cell.bbox.y2)));
@@ -1231,7 +1998,7 @@ function dropShadingClipGrids(clipGrids, lineGrids, fillRects, verticals = [], h
     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) || 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 + (_optionalChain([o, 'access', _26 => _26.cells, 'optionalAccess', _27 => _27.some, 'call', _28 => _28((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) || hasShadedRowBands(l, clipGrids, fillRects, verticals, horizontals))
+      (!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 + (_optionalChain([o, 'access', _31 => _31.cells, 'optionalAccess', _32 => _32.some, 'call', _33 => _33((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) || hasShadedRowBands(l, clipGrids, fillRects, verticals, horizontals))
     ));
     return !host;
   });
@@ -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 || !_optionalChain([c, 'access', _29 => _29.cells, 'optionalAccess', _30 => _30.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 || !_optionalChain([c, 'access', _34 => _34.cells, 'optionalAccess', _35 => _35.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 && _optionalChain([c, 'access', _36 => _36.cells, 'optionalAccess', _37 => _37.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;
@@ -1597,7 +2374,7 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     for (let dx = -1; dx <= 1 && !duplicate; dx++) {
       const ys2 = buckets.get(bx + dx);
       for (let dy = -1; dy <= 1 && !duplicate; dy++) {
-        duplicate = _nullishCoalesce(_optionalChain([ys2, 'optionalAccess', _31 => _31.get, 'call', _32 => _32(by + dy), 'optionalAccess', _33 => _33.some, 'call', _34 => _34((c) => sameRect(c, r))]), () => ( false));
+        duplicate = _nullishCoalesce(_optionalChain([ys2, 'optionalAccess', _38 => _38.get, 'call', _39 => _39(by + dy), 'optionalAccess', _40 => _40.some, 'call', _41 => _41((c) => sameRect(c, r))]), () => ( false));
       }
     }
     if (duplicate) continue;
@@ -1745,7 +2522,7 @@ function buildClipCellGrids(rects, strokedH, strokedV, pageWidth, pageHeight, te
     else groups.set(r, [i]);
   }
   const containers = cells.filter((_, i) => isContainer[i]);
-  const groupSize = (i) => _nullishCoalesce(_optionalChain([groups, 'access', _35 => _35.get, 'call', _36 => _36(find(i)), 'optionalAccess', _37 => _37.length]), () => ( 0));
+  const groupSize = (i) => _nullishCoalesce(_optionalChain([groups, 'access', _42 => _42.get, 'call', _43 => _43(find(i)), 'optionalAccess', _44 => _44.length]), () => ( 0));
   const isGridMember = (i) => groupSize(i) >= CLIP_MIN_GROUP;
   const framed = (r) => edgeStroked(strokedH, "h", r.y1, r.x1, r.x2) && edgeStroked(strokedH, "h", r.y2, r.x1, r.x2) && edgeStroked(strokedV, "v", r.x1, r.y1, r.y2) && edgeStroked(strokedV, "v", r.x2, r.y1, r.y2);
   const titledFrame = (r) => r.y1 >= pageHeight * TITLED_FRAME_MIN_TOP && r.x2 - r.x1 >= pageWidth * TITLED_FRAME_MIN_WIDTH && textPoints.some((p) => p.y < r.y1 && p.y > pageHeight * HEADER_BAND && p.x >= r.x1 - CLIP_EDGE_TOL && p.x <= r.x2 + CLIP_EDGE_TOL) && textPoints.some((p) => p.x > r.x1 && p.x < r.x2 && p.y > r.y1 && p.y < r.y2);
@@ -2126,8 +2903,8 @@ function childRules(r, grid) {
 }
 function recordClipCellEdges(grids, horizontals, verticals, nonRules) {
   if (!grids.some((g) => g.cells)) return;
-  const h = rules(_optionalChain([nonRules, 'optionalAccess', _38 => _38.size]) ? horizontals.filter((l) => !nonRules.has(l)) : horizontals, "h");
-  const v = rules(_optionalChain([nonRules, 'optionalAccess', _39 => _39.size]) ? verticals.filter((l) => !nonRules.has(l)) : verticals, "v");
+  const h = rules(_optionalChain([nonRules, 'optionalAccess', _45 => _45.size]) ? horizontals.filter((l) => !nonRules.has(l)) : horizontals, "h");
+  const v = rules(_optionalChain([nonRules, 'optionalAccess', _46 => _46.size]) ? verticals.filter((l) => !nonRules.has(l)) : verticals, "v");
   for (const g of grids) {
     if (!g.cells) continue;
     const ownH = childRules(h, g), ownV = childRules(v, g);
@@ -2143,9 +2920,9 @@ function recordOpenEndCellEdges(grid, cells, horizontals) {
   const end = horizontals.find((l) => OPEN_END_RULES.has(l) && Math.abs(l.y1 - b.y1) <= EDGE_NEAR2 && Math.abs(l.x1 - b.x1) <= EDGE_NEAR2 && Math.abs(l.x2 - b.x2) <= EDGE_NEAR2);
   const raw = end && OPEN_END_RULES.get(end);
   if (!raw) return;
-  const hs = raw.horizontals.filter((l) => !_optionalChain([raw, 'access', _40 => _40.nonRules, 'optionalAccess', _41 => _41.has, 'call', _42 => _42(l)]));
+  const hs = raw.horizontals.filter((l) => !_optionalChain([raw, 'access', _47 => _47.nonRules, 'optionalAccess', _48 => _48.has, 'call', _49 => _49(l)]));
   if (hs.some((l) => Math.abs(l.y1 - b.y1) <= EDGE_NEAR2 && Math.min(l.x2, b.x2) - Math.max(l.x1, b.x1) > TIP_MAX)) return;
-  const h = rules(hs, "h"), v = rules(raw.verticals.filter((l) => !_optionalChain([raw, 'access', _43 => _43.nonRules, 'optionalAccess', _44 => _44.has, 'call', _45 => _45(l)])), "v");
+  const h = rules(hs, "h"), v = rules(raw.verticals.filter((l) => !_optionalChain([raw, 'access', _50 => _50.nonRules, 'optionalAccess', _51 => _51.has, 'call', _52 => _52(l)])), "v");
   const edges = cells.map((c) => edgesOf(c.bbox, h, v));
   const last = grid.rowYs.length - 2;
   if (!cells.every((c, i) => {
@@ -2156,16 +2933,16 @@ function recordOpenEndCellEdges(grid, cells, horizontals) {
 }
 function takeClipCellEdges(from, to) {
   const e = CLIP_CELL_EDGES.get(from);
-  if (e) _chunkAM5ALISVcjs.CELL_EDGES.set(to, e);
+  if (e) _chunkNW2CKOFLcjs.CELL_EDGES.set(to, e);
 }
 function hasOpenCellSeam(a, b) {
-  const u = _chunkAM5ALISVcjs.CELL_EDGES.get(a), d = _chunkAM5ALISVcjs.CELL_EDGES.get(b);
+  const u = _chunkNW2CKOFLcjs.CELL_EDGES.get(a), d = _chunkNW2CKOFLcjs.CELL_EDGES.get(b);
   return !!u && !!d && u.t && !u.b && !d.t && d.b && u.l && u.r && d.l && d.r;
 }
 function joinCellEdges(a, b) {
-  const u = _chunkAM5ALISVcjs.CELL_EDGES.get(a), d = _chunkAM5ALISVcjs.CELL_EDGES.get(b);
+  const u = _chunkNW2CKOFLcjs.CELL_EDGES.get(a), d = _chunkNW2CKOFLcjs.CELL_EDGES.get(b);
   if (!u || !d) return;
-  _chunkAM5ALISVcjs.CELL_EDGES.set(a, { t: u.t, b: d.b, l: u.l || d.l, r: u.r || d.r });
+  _chunkNW2CKOFLcjs.CELL_EDGES.set(a, { t: u.t, b: d.b, l: u.l || d.l, r: u.r || d.r });
 }
 
 // src/pdf/cell-extract.ts
@@ -2341,7 +3118,7 @@ function tagScripts(text, lines) {
     const [s, e, kind] = marks[m];
     out = out.slice(0, s) + `<${kind}>` + out.slice(s, e) + `</${kind}>` + out.slice(e);
   }
-  return _chunkAM5ALISVcjs.tidyScriptTags.call(void 0, out);
+  return _chunkNW2CKOFLcjs.tidyScriptTags.call(void 0, out);
 }
 
 // src/pdf/line-wrap.ts
@@ -2377,12 +3154,12 @@ var WrapLexicon = (_class = class {constructor() { _class.prototype.__init.call(
         const t = toks[i], n = t.length;
         if (i > 0 && i < toks.length - 1) {
           bump(this.words, t);
-          const run = _nullishCoalesce(_optionalChain([t, 'access', _46 => _46.match, 'call', _47 => _47(/^[가-힣]+/), 'optionalAccess', _48 => _48[0]]), () => ( ""));
+          const run = _nullishCoalesce(_optionalChain([t, 'access', _53 => _53.match, 'call', _54 => _54(/^[가-힣]+/), 'optionalAccess', _55 => _55[0]]), () => ( ""));
           for (let j = 2; j <= Math.min(run.length, 6); j++) this.heads.add(run.slice(0, j));
         }
         if (i + 1 < toks.length) {
           this.pairs.add(t + " " + toks[i + 1]);
-          const tail = _optionalChain([t, 'access', _49 => _49.match, 'call', _50 => _50(/[가-힣]+$/), 'optionalAccess', _51 => _51[0]]);
+          const tail = _optionalChain([t, 'access', _56 => _56.match, 'call', _57 => _57(/[가-힣]+$/), 'optionalAccess', _58 => _58[0]]);
           if (tail) this.spacedHeads.add(tail + " " + toks[i + 1].charAt(0));
         }
         for (let a = 0; a + 1 < n; a++) {
@@ -2419,14 +3196,14 @@ var WrapLexicon = (_class = class {constructor() { _class.prototype.__init.call(
     const n = left.length;
     if (n < 2 || right.length < 2) return null;
     const k1 = pairKey(left.charCodeAt(n - 2), left.charCodeAt(n - 1)), k2 = pairKey(right.charCodeAt(0), right.charCodeAt(1));
-    return decideCounts(_nullishCoalesce(_optionalChain([this, 'access', _52 => _52.joined2, 'access', _53 => _53.get, 'call', _54 => _54(k1), 'optionalAccess', _55 => _55.get, 'call', _56 => _56(k2)]), () => ( 0)), _nullishCoalesce(_optionalChain([this, 'access', _57 => _57.spaced2, 'access', _58 => _58.get, 'call', _59 => _59(k1), 'optionalAccess', _60 => _60.get, 'call', _61 => _61(k2)]), () => ( 0)));
+    return decideCounts(_nullishCoalesce(_optionalChain([this, 'access', _59 => _59.joined2, 'access', _60 => _60.get, 'call', _61 => _61(k1), 'optionalAccess', _62 => _62.get, 'call', _63 => _63(k2)]), () => ( 0)), _nullishCoalesce(_optionalChain([this, 'access', _64 => _64.spaced2, 'access', _65 => _65.get, 'call', _66 => _66(k1), 'optionalAccess', _67 => _67.get, 'call', _68 => _68(k2)]), () => ( 0)));
   }
   /** 꺾인 자리 증거: "" 붙음 · " " 띄움 · null 모름 (두 글자 증거가 갈리거나 없으면 한 글자) */
   evidence(left, right) {
     const n = left.length;
     if (n >= 2 && right.length >= 2) {
       const k1 = pairKey(left.charCodeAt(n - 2), left.charCodeAt(n - 1)), k2 = pairKey(right.charCodeAt(0), right.charCodeAt(1));
-      const v = decideCounts(_nullishCoalesce(_optionalChain([this, 'access', _62 => _62.joined2, 'access', _63 => _63.get, 'call', _64 => _64(k1), 'optionalAccess', _65 => _65.get, 'call', _66 => _66(k2)]), () => ( 0)), _nullishCoalesce(_optionalChain([this, 'access', _67 => _67.spaced2, 'access', _68 => _68.get, 'call', _69 => _69(k1), 'optionalAccess', _70 => _70.get, 'call', _71 => _71(k2)]), () => ( 0)));
+      const v = decideCounts(_nullishCoalesce(_optionalChain([this, 'access', _69 => _69.joined2, 'access', _70 => _70.get, 'call', _71 => _71(k1), 'optionalAccess', _72 => _72.get, 'call', _73 => _73(k2)]), () => ( 0)), _nullishCoalesce(_optionalChain([this, 'access', _74 => _74.spaced2, 'access', _75 => _75.get, 'call', _76 => _76(k1), 'optionalAccess', _77 => _77.get, 'call', _78 => _78(k2)]), () => ( 0)));
       if (v !== null) return v;
     }
     if (n && right.length) {
@@ -2501,11 +3278,11 @@ function wrapJoiner(prevText, nextText, lex, heads = true) {
   if (particleContinues(left, right)) return "";
   if (endsAsWord(left)) return " ";
   if (/[A-Za-z]-$/.test(left) && /^[A-Za-z]/.test(right) && !/[가-힣]/.test(prev + next)) {
-    return _optionalChain([lex, 'optionalAccess', _72 => _72.joinedWord, 'call', _73 => _73(left, right.replace(/[.,;:!?)]*$/, ""))]) ? "" : " ";
+    return _optionalChain([lex, 'optionalAccess', _79 => _79.joinedWord, 'call', _80 => _80(left, right.replace(/[.,;:!?)]*$/, ""))]) ? "" : " ";
   }
   if (/[·ㆍ‧-]/.test(a) && !/[·ㆍ‧…]{2}$/.test(prev) && /[가-힣A-Za-z0-9]/.test(b)) return "";
   if (/[A-Za-z]/.test(a) && /[A-Za-z]/.test(b) || /\d/.test(a) && /\d/.test(b)) return " ";
-  const ev = _optionalChain([lex, 'optionalAccess', _74 => _74.evidence, 'call', _75 => _75(left, right)]);
+  const ev = _optionalChain([lex, 'optionalAccess', _81 => _81.evidence, 'call', _82 => _82(left, right)]);
   if (ev != null) return ev;
   if (lex && /[가-힣A-Za-z0-9]$/.test(left) && /^[가-힣A-Za-z0-9]/.test(right) && lex.joinedWord(left, right.replace(/[.,)」』’”;:]+$/, ""))) return "";
   if (/\d$/.test(left) && COUNTER.test(right)) return "";
@@ -2513,7 +3290,7 @@ function wrapJoiner(prevText, nextText, lex, heads = true) {
   const r1 = right.replace(/[.,)」』’”]+$/, "");
   if (lex && /[가-힣]$/.test(left) && /^[가-힣]$/.test(r1) && !STANDALONE_SYLLABLE.test(r1) && !lex.isWord(r1) && !lex.isWord(right)) return "";
   if (lex && heads) {
-    const tail = _optionalChain([left, 'access', _76 => _76.match, 'call', _77 => _77(/[가-힣]+$/), 'optionalAccess', _78 => _78[0]]), run = _optionalChain([right, 'access', _79 => _79.match, 'call', _80 => _80(/^[가-힣]+/), 'optionalAccess', _81 => _81[0]]);
+    const tail = _optionalChain([left, 'access', _83 => _83.match, 'call', _84 => _84(/[가-힣]+$/), 'optionalAccess', _85 => _85[0]]), run = _optionalChain([right, 'access', _86 => _86.match, 'call', _87 => _87(/^[가-힣]+/), 'optionalAccess', _88 => _88[0]]);
     if (tail && run && !STANDALONE_SYLLABLE.test(tail) && lex.startsWord(tail + run.slice(0, 2)) && !lex.spacedHead(tail, run[0])) return "";
     if (/[가-힣]{2}$/.test(left) && /^\([^()\s]*\)/.test(right) && !endsAsWord(left) && !/(?:함|음|됨|임|다)$/.test(left) && !BARE_UNIT_PAREN.test(right) && !/^\(\d/.test(right)) return "";
   }
@@ -2548,14 +3325,14 @@ function joinPageBreakWraps(blocks, lex) {
     if (a.type !== "paragraph" && a.type !== "list" || b.type !== "paragraph") continue;
     const last = a.bbox && PARA_LAST_LINE.get(a.bbox), fs = last ? last.fontSize : 0;
     if (!last || fs <= 0 || (_nullishCoalesce(pageRight.get(a.pageNumber), () => ( Infinity))) - last.right >= BODY_FULL_TOL * fs) continue;
-    if (last.width < BODY_MIN_WIDTH_EM * fs || Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _82 => _82.style, 'optionalAccess', _83 => _83.fontSize]), () => ( 0))) - fs) > 0.15 * fs) continue;
+    if (last.width < BODY_MIN_WIDTH_EM * fs || Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _89 => _89.style, 'optionalAccess', _90 => _90.fontSize]), () => ( 0))) - fs) > 0.15 * fs) continue;
     const bt = b.text.replace(MARKUP, "");
     if (startsNewItem(a.text, b.text) || PAGE_REF_TAIL.test(a.text) || PAGE_ITEM_HEAD.test(bt)) continue;
     if (PAGE_HEAD_MARK.test(bt) && !(/^[\u25a0-\u25ff]/.test(bt) && a.text.includes(bt[0]))) continue;
     const firstLeft = b.bbox && PARA_FIRST_LEFT.get(b.bbox);
     const indented = firstLeft === void 0 || firstLeft - (_nullishCoalesce(pageLeft.get(b.pageNumber), () => ( firstLeft))) >= 0.3 * fs;
     if (indented && SENTENCE_END.test(a.text.replace(MARKUP, "").trimEnd())) continue;
-    if (Math.round(_nullishCoalesce(_optionalChain([b, 'access', _84 => _84.style, 'optionalAccess', _85 => _85.fontSize]), () => ( 0))) !== Math.round(fs) && titleLike(b.text)) continue;
+    if (Math.round(_nullishCoalesce(_optionalChain([b, 'access', _91 => _91.style, 'optionalAccess', _92 => _92.fontSize]), () => ( 0))) !== Math.round(fs) && titleLike(b.text)) continue;
     if (/\t/.test(a.text.slice(a.text.lastIndexOf("\n") + 1).replace(/^\S{1,8}\t/, "")) && titleLike(bt.trim().split("\n")[0])) continue;
     const joined = wrapJoiner(a.text, b.text, lex);
     const head = a.text, joiner = joined === "" && last.spaceAfter ? " " : joined;
@@ -2604,7 +3381,7 @@ function bodyLineJoins(lines, lex) {
   for (const l of lines) if (!HANGING.test(l.text) && l.right > inner) inner = l.right;
   const full = (l) => right - l.right < BODY_FULL_TOL * l.fontSize || right - inner <= 1.2 * l.fontSize && inner - l.right < BODY_FULL_TOL * l.fontSize;
   const nextWordNoRoom = (a, b) => {
-    const w = _optionalChain([b, 'access', _86 => _86.text, 'access', _87 => _87.trim, 'call', _88 => _88(), 'access', _89 => _89.match, 'call', _90 => _90(/^\S+/), 'optionalAccess', _91 => _91[0]]);
+    const w = _optionalChain([b, 'access', _93 => _93.text, 'access', _94 => _94.trim, 'call', _95 => _95(), 'access', _96 => _96.match, 'call', _97 => _97(/^\S+/), 'optionalAccess', _98 => _98[0]]);
     const n = [...b.text.trim()].length;
     if (!w || n === 0) return false;
     const em = (b.right - b.left) / n;
@@ -2800,7 +3577,7 @@ function cellTextToString(items, wrap) {
   const merged = mergeSuperscriptRows(lines).map((line) => sortLineByX(line));
   const textLines = merged.map((s) => {
     if (s.length === 1) return s[0].text;
-    if (s.length === 2 && /^[가-힣]$/.test(s[0].text) && /^[가-힣]$/.test(s[1].text) && !!_optionalChain([wrap, 'optionalAccess', _92 => _92.lex]) && (wrap.lex.isWord(s[0].text + s[1].text) || wrap.lex.evidence(s[0].text, s[1].text) === "" || REGION_LABELS.has(s[0].text + s[1].text)) && s[1].x - (s[0].x + s[0].w) >= Math.max(s[0].fontSize, s[1].fontSize) * 1.5 && s[1].x + s[1].w - s[0].x >= wrap.box.x2 - wrap.box.x1 - Math.max(s[0].fontSize, s[1].fontSize) * 2) return s[0].text + s[1].text;
+    if (s.length === 2 && /^[가-힣]$/.test(s[0].text) && /^[가-힣]$/.test(s[1].text) && !!_optionalChain([wrap, 'optionalAccess', _99 => _99.lex]) && (wrap.lex.isWord(s[0].text + s[1].text) || wrap.lex.evidence(s[0].text, s[1].text) === "" || REGION_LABELS.has(s[0].text + s[1].text)) && s[1].x - (s[0].x + s[0].w) >= Math.max(s[0].fontSize, s[1].fontSize) * 1.5 && s[1].x + s[1].w - s[0].x >= wrap.box.x2 - wrap.box.x1 - Math.max(s[0].fontSize, s[1].fontSize) * 2) return s[0].text + s[1].text;
     const evenSpaced = detectEvenSpacedItems(s, true);
     let result = s[0].text;
     for (let j = 1; j < s.length; j++) {
@@ -2946,12 +3723,12 @@ function markEvenRun(items, visible, result, start, end) {
 }
 function mergeCellTextLines(textLines, wrap) {
   if (textLines.length <= 1) return textLines[0] || "";
-  const numberWrapped = (k) => !!_optionalChain([wrap, 'optionalAccess', _93 => _93.wraps, 'access', _94 => _94[k]]) && (_nullishCoalesce(_optionalChain([wrap, 'access', _95 => _95.wide, 'optionalAccess', _96 => _96[k]]), () => ( true)));
+  const numberWrapped = (k) => !!_optionalChain([wrap, 'optionalAccess', _100 => _100.wraps, 'access', _101 => _101[k]]) && (_nullishCoalesce(_optionalChain([wrap, 'access', _102 => _102.wide, 'optionalAccess', _103 => _103[k]]), () => ( true)));
   const merged = [textLines[0]];
   for (let i = 1; i < textLines.length; i++) {
     const prev = merged[merged.length - 1];
     const curr = textLines[i];
-    if (wrap ? wrap.wraps[i - 1] && !_optionalChain([wrap, 'access', _97 => _97.spaced, 'optionalAccess', _98 => _98[i - 1]]) && !startsNewItem(prev, curr) && wrapJoiner(prev, curr, wrap.lex, false) === "" : /[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 8 && !curr.includes(" ")) {
+    if (wrap ? wrap.wraps[i - 1] && !_optionalChain([wrap, 'access', _104 => _104.spaced, 'optionalAccess', _105 => _105[i - 1]]) && !startsNewItem(prev, curr) && wrapJoiner(prev, curr, wrap.lex, false) === "" : /[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 8 && !curr.includes(" ")) {
       merged[merged.length - 1] = prev + curr;
     } else if (curr.trim().length <= 3 && /^[)\]%}]/.test(curr.trim())) {
       merged[merged.length - 1] = prev + curr.trim();
@@ -3046,7 +3823,7 @@ function normalizeUndersegmentedTable(originalCells, colXs, items, rowYs) {
   if (numRows > MAX_UNDERSEGMENTED_ROWS || numCols < MIN_UNDERSEGMENTED_COLUMNS) return null;
   if (items.length === 0) return null;
   if (numRows >= 3) {
-    if (_optionalChain([rowYs, 'optionalAccess', _99 => _99.length]) !== numRows + 1) return null;
+    if (_optionalChain([rowYs, 'optionalAccess', _106 => _106.length]) !== numRows + 1) return null;
     const rebuilt2 = [];
     let expanded = 0;
     for (let r = 0; r < numRows; r++) {
@@ -3140,7 +3917,7 @@ function sortLineByX(items) {
       e++;
     }
     const run = items.slice(s, e), seqs = run.map((i) => i.seq);
-    const ok = !wide ? !run.some((i) => _optionalChain([i, 'access', _100 => _100.text, 'optionalAccess', _101 => _101.startsWith, 'call', _102 => _102("$")])) : Math.max(...seqs) - Math.min(...seqs) <= 2 * (e - s - 1) && run.every((i) => Math.abs((_nullishCoalesce(i.fontSize, () => ( 0))) - (_nullishCoalesce(run[0].fontSize, () => ( 0)))) <= 0.5);
+    const ok = !wide ? !run.some((i) => _optionalChain([i, 'access', _107 => _107.text, 'optionalAccess', _108 => _108.startsWith, 'call', _109 => _109("$")])) : Math.max(...seqs) - Math.min(...seqs) <= 2 * (e - s - 1) && run.every((i) => Math.abs((_nullishCoalesce(i.fontSize, () => ( 0))) - (_nullishCoalesce(run[0].fontSize, () => ( 0)))) <= 0.5);
     if (e - s > 1 && seqs.every((q) => q !== void 0) && ok) {
       run.sort((a, b) => a.seq - b.seq);
       for (let k = 0; k < run.length; k++) items[s + k] = run[k];
@@ -3209,7 +3986,7 @@ function dominantStyle(items) {
   let maxCount = 0, dominantSize = 0;
   for (const i of items) {
     if (i.fontSize <= 0) continue;
-    const count = (freq.get(i.fontSize) || 0) + Math.max(1, _nullishCoalesce(_optionalChain([i, 'access', _103 => _103.text, 'access', _104 => _104.match, 'call', _105 => _105(/[\p{L}\p{N}]/gu), 'optionalAccess', _106 => _106.length]), () => ( 0)));
+    const count = (freq.get(i.fontSize) || 0) + Math.max(1, _nullishCoalesce(_optionalChain([i, 'access', _110 => _110.text, 'access', _111 => _111.match, 'call', _112 => _112(/[\p{L}\p{N}]/gu), 'optionalAccess', _113 => _113.length]), () => ( 0)));
     freq.set(i.fontSize, count);
     if (count > maxCount) {
       maxCount = count;
@@ -3217,7 +3994,7 @@ function dominantStyle(items) {
     }
   }
   if (dominantSize === 0) return void 0;
-  const fontName = _optionalChain([items, 'access', _107 => _107.find, 'call', _108 => _108((i) => i.fontSize === dominantSize), 'optionalAccess', _109 => _109.fontName]) || void 0;
+  const fontName = _optionalChain([items, 'access', _114 => _114.find, 'call', _115 => _115((i) => i.fontSize === dominantSize), 'optionalAccess', _116 => _116.fontName]) || void 0;
   return fontName ? { fontSize: dominantSize, fontName } : { fontSize: dominantSize };
 }
 function normalizeItems(rawItems) {
@@ -3362,7 +4139,7 @@ function splitAroundOverlays(c, overlays) {
   const ov = overlays.filter((o) => {
     for (let at = c.text.indexOf(o.text); at >= 0; at = c.text.indexOf(o.text, at + 1)) {
       const prefix = c.text.slice(0, at);
-      const est = c.x + glyphUnits(prefix.replace(/\s+/g, "")) * a0 + (_nullishCoalesce(_optionalChain([prefix, 'access', _110 => _110.match, 'call', _111 => _111(/\s+/g), 'optionalAccess', _112 => _112.length]), () => ( 0))) * ws;
+      const est = c.x + glyphUnits(prefix.replace(/\s+/g, "")) * a0 + (_nullishCoalesce(_optionalChain([prefix, 'access', _117 => _117.match, 'call', _118 => _118(/\s+/g), 'optionalAccess', _119 => _119.length]), () => ( 0))) * ws;
       if (Math.abs(est - o.x) <= OVERLAY_DUP_EM * fs) return false;
     }
     return true;
@@ -3487,7 +4264,7 @@ function mergeSuperscriptLines(lines) {
   return result;
 }
 function mergeLineSimple(items) {
-  if (items.length <= 1) return _optionalChain([items, 'access', _113 => _113[0], 'optionalAccess', _114 => _114.text]) || "";
+  if (items.length <= 1) return _optionalChain([items, 'access', _120 => _120[0], 'optionalAccess', _121 => _121.text]) || "";
   const sorted = sortLineByX([...items]);
   const isEvenSpaced = detectEvenSpacedItems(sorted);
   let result = sorted[0].text;
@@ -3575,7 +4352,7 @@ function isProseTable(table) {
   if (!(long > 0 && long >= total * 0.5 && longRows >= rows * 0.4)) return false;
   for (let c = 0; c < table.cols; c++) {
     const filled = table.cells.map((row) => row[c]).filter((cell) => cell && cell.colSpan < table.cols && cell.text.trim()).map((cell) => cell.text.trim());
-    if (filled.length >= 3 && filled.length >= rows * 0.6 && filled.every((text) => text.length <= 30 && (_nullishCoalesce(_optionalChain([text, 'access', _115 => _115.match, 'call', _116 => _116(/\p{L}/gu), 'optionalAccess', _117 => _117.length]), () => ( 0))) >= 2)) return false;
+    if (filled.length >= 3 && filled.length >= rows * 0.6 && filled.every((text) => text.length <= 30 && (_nullishCoalesce(_optionalChain([text, 'access', _122 => _122.match, 'call', _123 => _123(/\p{L}/gu), 'optionalAccess', _124 => _124.length]), () => ( 0))) >= 2)) return false;
   }
   return true;
 }
@@ -3604,7 +4381,7 @@ var TICK = /^-?[\d,]+(?:\.\d+)?%?$/;
 var QUANTITY = /^[-−–]?[\d,]*\.?\d+%?$/;
 var quantity = (token) => Number(token.replace(/^[−–]/, "-").replace(/[,%]/g, ""));
 function isValueAxisColumn(table, c) {
-  const lines = table.cells.flatMap((row) => (_nullishCoalesce(_optionalChain([row, 'access', _118 => _118[c], 'optionalAccess', _119 => _119.text]), () => ( ""))).split("\n").map((line) => line.trim().split(/\s+/)));
+  const lines = table.cells.flatMap((row) => (_nullishCoalesce(_optionalChain([row, 'access', _125 => _125[c], 'optionalAccess', _126 => _126.text]), () => ( ""))).split("\n").map((line) => line.trim().split(/\s+/)));
   const others = table.cells.flatMap((row) => row.filter((_, k) => k !== c).map((cell) => cell.text.trim().split(/\s+/))).filter((tokens) => tokens.every((token) => QUANTITY.test(token))).flat().map(quantity).filter((v) => !(Number.isInteger(v) && v >= 1900 && v <= 2100));
   for (const ticks of [lines.flat().filter((t) => TICK.test(t)).map(quantity), lines.map((tokens) => tokens[0]).filter((t) => TICK.test(t)).map(quantity)]) {
     const run = fallingRun(ticks);
@@ -3636,7 +4413,7 @@ function isChartTable(table, ocr = false) {
   const numeric = texts.filter((text) => NUMERIC_CELL.test(text)).length;
   if (numeric < texts.length * 0.5) return false;
   for (let c = 0; c < table.cols; c++) {
-    if (!ocr ? isValueAxisColumn(table, c) : hasValueAxis(table.cells.flatMap((row) => (_nullishCoalesce(_optionalChain([row, 'access', _120 => _120[c], 'optionalAccess', _121 => _121.text]), () => ( ""))).split(/\s+/)).filter((t) => TICK.test(t)).map((t) => Number(t.replace(/[,%]/g, ""))))) return true;
+    if (!ocr ? isValueAxisColumn(table, c) : hasValueAxis(table.cells.flatMap((row) => (_nullishCoalesce(_optionalChain([row, 'access', _127 => _127[c], 'optionalAccess', _128 => _128.text]), () => ( ""))).split(/\s+/)).filter((t) => TICK.test(t)).map((t) => Number(t.replace(/[,%]/g, ""))))) return true;
   }
   const values = texts.filter((text) => text.split(/\s+/).every((token) => QUANTITY.test(token))).length;
   const cells = table.rows * table.cols;
@@ -3689,7 +4466,7 @@ function clusterCellLines(items) {
 }
 var WRAP_INDENT_MAX = 3;
 function joinClusterCellLines(lines, box, lex) {
-  let out = _nullishCoalesce(_optionalChain([lines, 'access', _122 => _122[0], 'optionalAccess', _123 => _123.text]), () => ( ""));
+  let out = _nullishCoalesce(_optionalChain([lines, 'access', _129 => _129[0], 'optionalAccess', _130 => _130.text]), () => ( ""));
   for (let i = 1; i < lines.length; i++) {
     const a = lines[i - 1], b = lines[i];
     const join2 = !a.spaceAfter && cellLineWraps(box, box.x1, a.right, a.fontSize, b.firstCharW) && a.left - box.x1 <= WRAP_INDENT_MAX * a.fontSize && b.left - box.x1 <= WRAP_INDENT_MAX * b.fontSize && /<\/u>$/.test(a.text) === /^<u>/.test(b.text) && !startsNewItem(out, b.text) && wrapJoiner(out, b.text, lex, false) === "";
@@ -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 _nullishCoalesce(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((_nullishCoalesce(text[at - 1], () => ( ""))) + (_nullishCoalesce(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;
@@ -3908,7 +4738,7 @@ function detectAlignedTwoColumnTables(rows, pageNum) {
       continue;
     }
     const top = rows[i - 1];
-    const title = _optionalChain([top, 'optionalAccess', _124 => _124.items, 'access', _125 => _125.length]) === 1 && Math.abs(top.items[0].x - first[0].x) <= 5 && top.items[0].text.length <= 65 && top.y - first[0].y <= Math.max(24, first[0].fontSize * 2.8) ? top : void 0;
+    const title = _optionalChain([top, 'optionalAccess', _131 => _131.items, 'access', _132 => _132.length]) === 1 && Math.abs(top.items[0].x - first[0].x) <= 5 && top.items[0].text.length <= 65 && top.y - first[0].y <= Math.max(24, first[0].fontSize * 2.8) ? top : void 0;
     const tableRows = title ? [title, ...body] : body;
     const cells = tableRows.map((row, idx) => {
       if (title && idx === 0) return [{ text: row.items[0].text, colSpan: 2, rowSpan: 1 }, { text: "", colSpan: 1, rowSpan: 1 }];
@@ -3964,12 +4794,12 @@ function isTwoColumnProse(r) {
   if (t.rows < 8) return false;
   const dense = [];
   for (let c = 0; c < t.cols; c++) {
-    const filled = t.cells.filter((row) => _optionalChain([row, 'access', _126 => _126[c], 'optionalAccess', _127 => _127.text, 'access', _128 => _128.trim, 'call', _129 => _129()])).length;
+    const filled = t.cells.filter((row) => _optionalChain([row, 'access', _133 => _133[c], 'optionalAccess', _134 => _134.text, 'access', _135 => _135.trim, 'call', _136 => _136()])).length;
     if (filled / t.rows >= 0.3) dense.push(c);
   }
   if (dense.length !== 2) return false;
   for (const c of dense) {
-    const lens = t.cells.map((row) => _nullishCoalesce(_optionalChain([row, 'access', _130 => _130[c], 'optionalAccess', _131 => _131.text, 'access', _132 => _132.replace, 'call', _133 => _133(/\s+/g, ""), 'access', _134 => _134.length]), () => ( 0))).filter((n) => n > 0);
+    const lens = t.cells.map((row) => _nullishCoalesce(_optionalChain([row, 'access', _137 => _137[c], 'optionalAccess', _138 => _138.text, 'access', _139 => _139.replace, 'call', _140 => _140(/\s+/g, ""), 'access', _141 => _141.length]), () => ( 0))).filter((n) => n > 0);
     const avg = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
     if (avg < 12) return false;
   }
@@ -4396,7 +5226,7 @@ function assignRowItems(items, columns, numCols, headerFace) {
   const runs = [];
   for (const it of sorted) {
     const last = runs[runs.length - 1];
-    const prev = _optionalChain([last, 'optionalAccess', _135 => _135[last.length - 1]]);
+    const prev = _optionalChain([last, 'optionalAccess', _142 => _142[last.length - 1]]);
     if (prev && it.x - (prev.x + prev.w) <= Math.max(0.5, it.fontSize * 0.05) && !it.hasSpaceBefore) last.push(it);
     else runs.push([it]);
   }
@@ -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(_optionalChain([rows, 'access', _143 => _143[0], 'optionalAccess', _144 => _144.items, 'access', _145 => _145.map, 'call', _146 => _146((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(_optionalChain([rows, 'access', _136 => _136[0], 'optionalAccess', _137 => _137.items, 'access', _138 => _138.map, 'call', _139 => _139((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(_nullishCoalesce(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)) };
   });
@@ -4507,11 +5365,11 @@ function buildClusterTable(rows, columns, pageNum, lex) {
     const nonEmptyCols = cells[r].filter((c) => c.text.trim()).length;
     if (nonEmptyCols !== 1) continue;
     if (cells[r][0].text.trim() !== "") continue;
-    const contentText = _optionalChain([cells, 'access', _140 => _140[r], 'access', _141 => _141.find, 'call', _142 => _142((c) => c.text.trim()), 'optionalAccess', _143 => _143.text, 'access', _144 => _144.trim, 'call', _145 => _145()]) || "";
+    const contentText = _optionalChain([cells, 'access', _147 => _147[r], 'access', _148 => _148.find, 'call', _149 => _149((c) => c.text.trim()), 'optionalAccess', _150 => _150.text, 'access', _151 => _151.trim, 'call', _152 => _152()]) || "";
     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]);
@@ -4740,7 +5598,7 @@ function stackedTableBands(items) {
   const caption = (start, end) => lines.slice(start, end).some((line) => /^Table\s+\d+\s*[:.]/i.test(mergeLineSimple(line).trim()));
   while (runs.length > 0 && !caption(runs[runs.length - 1].end, lines.length)) runs.pop();
   if (runs.length < 2) return null;
-  if (runs.some((run, i) => !caption(run.end, _nullishCoalesce(_optionalChain([runs, 'access', _146 => _146[i + 1], 'optionalAccess', _147 => _147.start]), () => ( lines.length))))) return null;
+  if (runs.some((run, i) => !caption(run.end, _nullishCoalesce(_optionalChain([runs, 'access', _153 => _153[i + 1], 'optionalAccess', _154 => _154.start]), () => ( lines.length))))) return null;
   const tables = runs.map((run) => lines.slice(run.start, run.end).flat());
   const between = runs.slice(0, -1).map((run, i) => lines.slice(run.end, runs[i + 1].start).flat());
   const tail = lines.slice(runs[runs.length - 1].end);
@@ -5008,7 +5866,7 @@ function splitTrailingColumnRegion(items) {
 }
 function panelBlocks(items, panel, pageNum) {
   const lines = groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x));
-  const faceOf = (line) => _nullishCoalesce(_optionalChain([dominantStyle, 'call', _148 => _148(line), 'optionalAccess', _149 => _149.fontName]), () => ( ""));
+  const faceOf = (line) => _nullishCoalesce(_optionalChain([dominantStyle, 'call', _155 => _155(line), 'optionalAccess', _156 => _156.fontName]), () => ( ""));
   const runs = [];
   for (const line of lines) {
     const last = runs[runs.length - 1];
@@ -5190,7 +6048,7 @@ function validWrapBands(items, bands) {
 }
 function inheritedWrapBands(items) {
   const source = XY_WRAP_ITEMS.get(items[0]);
-  const present = _optionalChain([source, 'optionalAccess', _150 => _150.length]) === items.length ? new Set(items) : null;
+  const present = _optionalChain([source, 'optionalAccess', _157 => _157.length]) === items.length ? new Set(items) : null;
   const sameLeaf = present && source.every((item) => present.has(item));
   return sameLeaf ? validWrapBands(items, _nullishCoalesce(XY_WRAP_BANDS.get(items[0]), () => ( []))) : [];
 }
@@ -5229,7 +6087,7 @@ function wrappedLineBands(items, inherited) {
       left: box.x,
       right: box.x + box.width,
       y: row.reduce((n, i) => n + i.y, 0) / row.length,
-      fontSize: _nullishCoalesce(_optionalChain([dominantStyle, 'call', _151 => _151(row), 'optionalAccess', _152 => _152.fontSize]), () => ( 0)),
+      fontSize: _nullishCoalesce(_optionalChain([dominantStyle, 'call', _158 => _158(row), 'optionalAccess', _159 => _159.fontSize]), () => ( 0)),
       sources: row.map((item) => ({ item, state: { ...item } }))
     };
   });
@@ -5365,10 +6223,10 @@ function pushLineParagraphs(out, yLines, pageNum, lex) {
   const lines = attachDropCaps(yLines).map((items) => ({ items, text: mergeLineSimple(items) })).filter((l) => l.text.trim());
   const geo = lines.map((l) => {
     const b = computeBBox(l.items, pageNum);
-    return { text: l.text, left: b.x, right: b.x + b.width, y: l.items.reduce((s, i) => s + i.y, 0) / l.items.length, fontSize: _nullishCoalesce(_optionalChain([dominantStyle, 'call', _153 => _153(l.items), 'optionalAccess', _154 => _154.fontSize]), () => ( 0)) };
+    return { text: l.text, left: b.x, right: b.x + b.width, y: l.items.reduce((s, i) => s + i.y, 0) / l.items.length, fontSize: _nullishCoalesce(_optionalChain([dominantStyle, 'call', _160 => _160(l.items), 'optionalAccess', _161 => _161.fontSize]), () => ( 0)) };
   });
   const joins = bodyLineJoins(geo, lex);
-  const first = _optionalChain([lines, 'access', _155 => _155[0], 'optionalAccess', _156 => _156.items, 'access', _157 => _157[0]]);
+  const first = _optionalChain([lines, 'access', _162 => _162[0], 'optionalAccess', _163 => _163.items, 'access', _164 => _164[0]]);
   const bands = first ? _nullishCoalesce(XY_WRAP_BANDS.get(first), () => ( [])) : [];
   const hasBand = (top, bottom) => {
     let lo = 0, hi = bands.length;
@@ -5445,15 +6303,15 @@ function computeMedianFontSizeFromFreq(freq) {
 function detectHeadings(blocks, medianFontSize) {
   for (let bi = 0; bi < blocks.length; bi++) {
     const block = blocks[bi];
-    if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _158 => _158.style, 'optionalAccess', _159 => _159.fontSize])) continue;
+    if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _165 => _165.style, 'optionalAccess', _166 => _166.fontSize])) continue;
     const text = block.text.trim();
     if (text.length === 0 || text.length > 200) continue;
     if (/^\d+$/.test(text) && !isChapterNumber(block, blocks[bi + 1], medianFontSize)) continue;
     const ratio = block.style.fontSize / medianFontSize;
     let level = 0;
-    if (ratio >= _chunkAM5ALISVcjs.HEADING_RATIO_H1) level = 1;
-    else if (ratio >= _chunkAM5ALISVcjs.HEADING_RATIO_H2) level = 2;
-    else if (ratio >= _chunkAM5ALISVcjs.HEADING_RATIO_H3) level = 3;
+    if (ratio >= _chunkNW2CKOFLcjs.HEADING_RATIO_H1) level = 1;
+    else if (ratio >= _chunkNW2CKOFLcjs.HEADING_RATIO_H2) level = 2;
+    else if (ratio >= _chunkNW2CKOFLcjs.HEADING_RATIO_H3) level = 3;
     if (level > 0) {
       block.type = "heading";
       block.level = level;
@@ -5462,21 +6320,21 @@ function detectHeadings(blocks, medianFontSize) {
   }
 }
 function isChapterNumber(block, next, medianFontSize) {
-  const size = _nullishCoalesce(_optionalChain([block, 'access', _160 => _160.style, 'optionalAccess', _161 => _161.fontSize]), () => ( 0));
-  const nextSize = _nullishCoalesce(_optionalChain([next, 'optionalAccess', _162 => _162.style, 'optionalAccess', _163 => _163.fontSize]), () => ( 0));
-  const text = _nullishCoalesce(_optionalChain([next, 'optionalAccess', _164 => _164.text, 'optionalAccess', _165 => _165.trim, 'call', _166 => _166()]), () => ( ""));
-  const a = block.bbox, b = _optionalChain([next, 'optionalAccess', _167 => _167.bbox]);
-  return /^\d{1,2}$/.test(_nullishCoalesce(_optionalChain([block, 'access', _168 => _168.text, 'optionalAccess', _169 => _169.trim, 'call', _170 => _170()]), () => ( ""))) && size >= medianFontSize * 2.5 && !!next && (next.type === "paragraph" || next.type === "heading") && next.pageNumber === block.pageNumber && nextSize >= medianFontSize * _chunkAM5ALISVcjs.HEADING_RATIO_H1 && text.length > 0 && text.length <= 80 && !/^[\d\s.]+$/.test(text) && !!a && !!b && a.y > b.y && a.y - (b.y + b.height) <= size * 2;
+  const size = _nullishCoalesce(_optionalChain([block, 'access', _167 => _167.style, 'optionalAccess', _168 => _168.fontSize]), () => ( 0));
+  const nextSize = _nullishCoalesce(_optionalChain([next, 'optionalAccess', _169 => _169.style, 'optionalAccess', _170 => _170.fontSize]), () => ( 0));
+  const text = _nullishCoalesce(_optionalChain([next, 'optionalAccess', _171 => _171.text, 'optionalAccess', _172 => _172.trim, 'call', _173 => _173()]), () => ( ""));
+  const a = block.bbox, b = _optionalChain([next, 'optionalAccess', _174 => _174.bbox]);
+  return /^\d{1,2}$/.test(_nullishCoalesce(_optionalChain([block, 'access', _175 => _175.text, 'optionalAccess', _176 => _176.trim, 'call', _177 => _177()]), () => ( ""))) && size >= medianFontSize * 2.5 && !!next && (next.type === "paragraph" || next.type === "heading") && next.pageNumber === block.pageNumber && nextSize >= medianFontSize * _chunkNW2CKOFLcjs.HEADING_RATIO_H1 && text.length > 0 && text.length <= 80 && !/^[\d\s.]+$/.test(text) && !!a && !!b && a.y > b.y && a.y - (b.y + b.height) <= size * 2;
 }
 function mergeStackedHeadingLines(blocks, medianFontSize) {
   for (let i = 0; i < blocks.length - 1; ) {
     const a = blocks[i], b = blocks[i + 1];
     const ab = a.bbox, bb = b.bbox;
-    const af = _nullishCoalesce(_optionalChain([a, 'access', _171 => _171.style, 'optionalAccess', _172 => _172.fontSize]), () => ( 0)), bf = _nullishCoalesce(_optionalChain([b, 'access', _173 => _173.style, 'optionalAccess', _174 => _174.fontSize]), () => ( 0));
+    const af = _nullishCoalesce(_optionalChain([a, 'access', _178 => _178.style, 'optionalAccess', _179 => _179.fontSize]), () => ( 0)), bf = _nullishCoalesce(_optionalChain([b, 'access', _180 => _180.style, 'optionalAccess', _181 => _181.fontSize]), () => ( 0));
     const gap = ab && bb ? ab.y - (bb.y + bb.height) : Infinity;
-    const centered = ab && bb && _optionalChain([a, 'access', _175 => _175.style, 'optionalAccess', _176 => _176.fontName]) === _optionalChain([b, 'access', _177 => _177.style, 'optionalAccess', _178 => _178.fontName]) && Math.abs(ab.x + ab.width / 2 - (bb.x + bb.width / 2)) <= Math.max(5, af * 0.5);
+    const centered = ab && bb && _optionalChain([a, 'access', _182 => _182.style, 'optionalAccess', _183 => _183.fontName]) === _optionalChain([b, 'access', _184 => _184.style, 'optionalAccess', _185 => _185.fontName]) && Math.abs(ab.x + ab.width / 2 - (bb.x + bb.width / 2)) <= Math.max(5, af * 0.5);
     const sameAnchor = ab && bb && Math.abs(ab.x - bb.x) <= 5;
-    const wrapped = sameAnchor && _optionalChain([a, 'access', _179 => _179.style, 'optionalAccess', _180 => _180.fontName]) === _optionalChain([b, 'access', _181 => _181.style, 'optionalAccess', _182 => _182.fontName]) && af === bf && ab.width >= bb.width * 0.95 && (_nullishCoalesce(_optionalChain([a, 'access', _183 => _183.text, 'optionalAccess', _184 => _184.trim, 'call', _185 => _185(), 'access', _186 => _186.split, 'call', _187 => _187(/\s+/), 'access', _188 => _188.length]), () => ( 0))) >= 3;
+    const wrapped = sameAnchor && _optionalChain([a, 'access', _186 => _186.style, 'optionalAccess', _187 => _187.fontName]) === _optionalChain([b, 'access', _188 => _188.style, 'optionalAccess', _189 => _189.fontName]) && af === bf && ab.width >= bb.width * 0.95 && (_nullishCoalesce(_optionalChain([a, 'access', _190 => _190.text, 'optionalAccess', _191 => _191.trim, 'call', _192 => _192(), 'access', _193 => _193.split, 'call', _194 => _194(/\s+/), 'access', _195 => _195.length]), () => ( 0))) >= 3;
     const displayStack = centered && gap <= Math.min(af, bf) * 0.3 && Math.max(af, bf) <= Math.min(af, bf) * 1.45;
     if (a.type !== "heading" || b.type !== "heading" || !a.text || !b.text || /^\d+$/.test(a.text.trim()) || !ab || !bb || ab.page !== bb.page || !(sameAnchor && af >= medianFontSize * 2 && bf >= medianFontSize * 2) && !wrapped && !(centered && af >= medianFontSize * 1.25 && bf >= medianFontSize * 1.25) || Math.abs(af - bf) > Math.max(af, bf) * 0.15 && !displayStack || gap < -2 || gap > Math.max(af, bf) * 0.45 || a.text.length > (centered ? 120 : 50) || b.text.length > (centered ? 120 : 50)) {
       i++;
@@ -5505,25 +6363,25 @@ function detectTypographyHeadings(blocks) {
     if (page.some((block) => block.type === "heading")) continue;
     const faceWeight = /* @__PURE__ */ new Map();
     for (const block of page) {
-      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _189 => _189.style, 'optionalAccess', _190 => _190.fontName])) continue;
+      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _196 => _196.style, 'optionalAccess', _197 => _197.fontName])) continue;
       const faces = FACE_CHARS.get(block);
       if (faces) for (const [face, n] of faces) faceWeight.set(face, (_nullishCoalesce(faceWeight.get(face), () => ( 0))) + n);
       else faceWeight.set(block.style.fontName, (_nullishCoalesce(faceWeight.get(block.style.fontName), () => ( 0))) + block.text.length);
     }
-    const bodyFace = _optionalChain([[...faceWeight], 'access', _191 => _191.sort, 'call', _192 => _192((a, b) => b[1] - a[1]), 'access', _193 => _193[0], 'optionalAccess', _194 => _194[0]]);
+    const bodyFace = _optionalChain([[...faceWeight], 'access', _198 => _198.sort, 'call', _199 => _199((a, b) => b[1] - a[1]), 'access', _200 => _200[0], 'optionalAccess', _201 => _201[0]]);
     if (!bodyFace || (_nullishCoalesce(faceWeight.get(bodyFace), () => ( 0))) < 250) continue;
     const sizeWeight = /* @__PURE__ */ new Map();
     for (const block of page) {
-      if (block.type !== "paragraph" || !_optionalChain([block, 'access', _195 => _195.style, 'optionalAccess', _196 => _196.fontSize])) continue;
+      if (block.type !== "paragraph" || !_optionalChain([block, 'access', _202 => _202.style, 'optionalAccess', _203 => _203.fontSize])) continue;
       const faces = FACE_CHARS.get(block);
-      const chars = faces ? _nullishCoalesce(faces.get(bodyFace), () => ( 0)) : block.style.fontName === bodyFace ? _nullishCoalesce(_optionalChain([block, 'access', _197 => _197.text, 'optionalAccess', _198 => _198.length]), () => ( 0)) : 0;
+      const chars = faces ? _nullishCoalesce(faces.get(bodyFace), () => ( 0)) : block.style.fontName === bodyFace ? _nullishCoalesce(_optionalChain([block, 'access', _204 => _204.text, 'optionalAccess', _205 => _205.length]), () => ( 0)) : 0;
       if (chars) sizeWeight.set(block.style.fontSize, (_nullishCoalesce(sizeWeight.get(block.style.fontSize), () => ( 0))) + chars);
     }
-    const bodySize = _nullishCoalesce(_optionalChain([[...sizeWeight], 'access', _199 => _199.sort, 'call', _200 => _200((a, b) => b[1] - a[1]), 'access', _201 => _201[0], 'optionalAccess', _202 => _202[0]]), () => ( 0));
+    const bodySize = _nullishCoalesce(_optionalChain([[...sizeWeight], 'access', _206 => _206.sort, 'call', _207 => _207((a, b) => b[1] - a[1]), 'access', _208 => _208[0], 'optionalAccess', _209 => _209[0]]), () => ( 0));
     for (let i = 0; i < page.length; i++) {
       const block = page[i];
       const { text, bbox, style } = block;
-      if (block.type !== "paragraph" || !text || !bbox || !_optionalChain([style, 'optionalAccess', _203 => _203.fontName]) || !style.fontSize) continue;
+      if (block.type !== "paragraph" || !text || !bbox || !_optionalChain([style, 'optionalAccess', _210 => _210.fontName]) || !style.fontSize) continue;
       const title = text.trim();
       const numbered = /^\d+(?:\.\d+)*\.?\s+[A-Z가-힣]/.test(title);
       const faces = FACE_CHARS.get(block);
@@ -5553,16 +6411,16 @@ function detectDocumentStyleHeadings(blocks) {
   for (const page of byPage.values()) {
     const faceChars = /* @__PURE__ */ new Map();
     for (const block of page) {
-      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _204 => _204.style, 'optionalAccess', _205 => _205.fontName])) continue;
+      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _211 => _211.style, 'optionalAccess', _212 => _212.fontName])) continue;
       faceChars.set(block.style.fontName, (_nullishCoalesce(faceChars.get(block.style.fontName), () => ( 0))) + block.text.length);
     }
-    const bodyFace = _optionalChain([[...faceChars], 'access', _206 => _206.sort, 'call', _207 => _207((a, b) => b[1] - a[1]), 'access', _208 => _208[0], 'optionalAccess', _209 => _209[0]]);
+    const bodyFace = _optionalChain([[...faceChars], 'access', _213 => _213.sort, 'call', _214 => _214((a, b) => b[1] - a[1]), 'access', _215 => _215[0], 'optionalAccess', _216 => _216[0]]);
     if (!bodyFace || (_nullishCoalesce(faceChars.get(bodyFace), () => ( 0))) < 100) continue;
-    const labels = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _210 => _210.style, 'optionalAccess', _211 => _211.fontName]) && b.style.fontName !== bodyFace && b.text.trim().length >= 3 && b.text.trim().length <= 40);
+    const labels = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _217 => _217.style, 'optionalAccess', _218 => _218.fontName]) && b.style.fontName !== bodyFace && b.text.trim().length >= 3 && b.text.trim().length <= 40);
     for (const label of labels) {
-      const peers = labels.filter((b) => _optionalChain([b, 'access', _212 => _212.style, 'optionalAccess', _213 => _213.fontName]) === _optionalChain([label, 'access', _214 => _214.style, 'optionalAccess', _215 => _215.fontName]) && Math.abs(b.bbox.y - label.bbox.y) <= 3 && Math.abs(b.bbox.x - label.bbox.x) >= 60);
+      const peers = labels.filter((b) => _optionalChain([b, 'access', _219 => _219.style, 'optionalAccess', _220 => _220.fontName]) === _optionalChain([label, 'access', _221 => _221.style, 'optionalAccess', _222 => _222.fontName]) && Math.abs(b.bbox.y - label.bbox.y) <= 3 && Math.abs(b.bbox.x - label.bbox.x) >= 60);
       if (peers.length < 2) continue;
-      const value = page.find((b) => b.type === "paragraph" && b.bbox && _optionalChain([b, 'access', _216 => _216.style, 'optionalAccess', _217 => _217.fontName]) !== _optionalChain([label, 'access', _218 => _218.style, 'optionalAccess', _219 => _219.fontName]) && b.bbox.x >= label.bbox.x - 5 && b.bbox.x <= label.bbox.x + 20 && b.bbox.y < label.bbox.y && label.bbox.y - (b.bbox.y + b.bbox.height) <= 60);
+      const value = page.find((b) => b.type === "paragraph" && b.bbox && _optionalChain([b, 'access', _223 => _223.style, 'optionalAccess', _224 => _224.fontName]) !== _optionalChain([label, 'access', _225 => _225.style, 'optionalAccess', _226 => _226.fontName]) && b.bbox.x >= label.bbox.x - 5 && b.bbox.x <= label.bbox.x + 20 && b.bbox.y < label.bbox.y && label.bbox.y - (b.bbox.y + b.bbox.height) <= 60);
       if (value) {
         label.type = "heading";
         label.level = 2;
@@ -5571,7 +6429,7 @@ function detectDocumentStyleHeadings(blocks) {
     const first = page.find((b) => b.type !== "image" && b.type !== "separator");
     const second = page[page.indexOf(first) + 1];
     const third = page[page.indexOf(first) + 2];
-    if (!first || !second || !third || first.type !== "list" && first.type !== "paragraph" || second.type !== "paragraph" || !first.text || !second.text || !first.bbox || !second.bbox || !_optionalChain([first, 'access', _220 => _220.style, 'optionalAccess', _221 => _221.fontName]) || !_optionalChain([second, 'access', _222 => _222.style, 'optionalAccess', _223 => _223.fontName]) || !/^\d+(?:\.\d+)*\.\s+/.test(first.text.trim()) || first.style.fontName === bodyFace || second.style.fontName === bodyFace || first.text.length + second.text.length > 140 || Math.abs(first.bbox.x - second.bbox.x) > 30 || first.bbox.y - (second.bbox.y + second.bbox.height) > (_nullishCoalesce(first.style.fontSize, () => ( 0))) * 1.5 || _optionalChain([third, 'access', _224 => _224.style, 'optionalAccess', _225 => _225.fontName]) !== bodyFace) continue;
+    if (!first || !second || !third || first.type !== "list" && first.type !== "paragraph" || second.type !== "paragraph" || !first.text || !second.text || !first.bbox || !second.bbox || !_optionalChain([first, 'access', _227 => _227.style, 'optionalAccess', _228 => _228.fontName]) || !_optionalChain([second, 'access', _229 => _229.style, 'optionalAccess', _230 => _230.fontName]) || !/^\d+(?:\.\d+)*\.\s+/.test(first.text.trim()) || first.style.fontName === bodyFace || second.style.fontName === bodyFace || first.text.length + second.text.length > 140 || Math.abs(first.bbox.x - second.bbox.x) > 30 || first.bbox.y - (second.bbox.y + second.bbox.height) > (_nullishCoalesce(first.style.fontSize, () => ( 0))) * 1.5 || _optionalChain([third, 'access', _231 => _231.style, 'optionalAccess', _232 => _232.fontName]) !== bodyFace) continue;
     first.type = "heading";
     first.level = 1;
     first.text = `${first.text.trim()} ${second.text.trim()}`;
@@ -5595,18 +6453,18 @@ function detectSiblingStyleHeadings(blocks) {
   for (const page of byPage.values()) {
     const bodyChars = /* @__PURE__ */ new Map();
     for (const block of page) {
-      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _226 => _226.style, 'optionalAccess', _227 => _227.fontName])) continue;
+      if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _233 => _233.style, 'optionalAccess', _234 => _234.fontName])) continue;
       const face = block.style.fontName;
       bodyChars.set(face, (_nullishCoalesce(bodyChars.get(face), () => ( 0))) + block.text.length);
     }
-    const bodyFace = _optionalChain([[...bodyChars], 'access', _228 => _228.sort, 'call', _229 => _229((a, b) => b[1] - a[1]), 'access', _230 => _230[0], 'optionalAccess', _231 => _231[0]]);
-    const anchors = page.filter((b) => b.type === "heading" && b.text && _optionalChain([b, 'access', _232 => _232.style, 'optionalAccess', _233 => _233.fontName]) && b.style.fontName !== bodyFace);
+    const bodyFace = _optionalChain([[...bodyChars], 'access', _235 => _235.sort, 'call', _236 => _236((a, b) => b[1] - a[1]), 'access', _237 => _237[0], 'optionalAccess', _238 => _238[0]]);
+    const anchors = page.filter((b) => b.type === "heading" && b.text && _optionalChain([b, 'access', _239 => _239.style, 'optionalAccess', _240 => _240.fontName]) && b.style.fontName !== bodyFace);
     for (const anchor of anchors) {
       const numbered = /^([A-Z])\.\d+\s+/.exec(anchor.text.trim());
       const lettered = /^([A-Z])\s+/.exec(anchor.text.trim());
-      const peers = anchors.filter((b) => _optionalChain([b, 'access', _234 => _234.style, 'optionalAccess', _235 => _235.fontName]) === _optionalChain([anchor, 'access', _236 => _236.style, 'optionalAccess', _237 => _237.fontName]) && Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _238 => _238.style, 'optionalAccess', _239 => _239.fontSize]), () => ( 0))) - (_nullishCoalesce(_optionalChain([anchor, 'access', _240 => _240.style, 'optionalAccess', _241 => _241.fontSize]), () => ( 0)))) < 0.5);
+      const peers = anchors.filter((b) => _optionalChain([b, 'access', _241 => _241.style, 'optionalAccess', _242 => _242.fontName]) === _optionalChain([anchor, 'access', _243 => _243.style, 'optionalAccess', _244 => _244.fontName]) && Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _245 => _245.style, 'optionalAccess', _246 => _246.fontSize]), () => ( 0))) - (_nullishCoalesce(_optionalChain([anchor, 'access', _247 => _247.style, 'optionalAccess', _248 => _248.fontSize]), () => ( 0)))) < 0.5);
       if (peers.length < 2 && !numbered && !lettered) continue;
-      const candidates = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _242 => _242.style, 'optionalAccess', _243 => _243.fontName]) === _optionalChain([anchor, 'access', _244 => _244.style, 'optionalAccess', _245 => _245.fontName]) && Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _246 => _246.style, 'optionalAccess', _247 => _247.fontSize]), () => ( 0))) - (_nullishCoalesce(_optionalChain([anchor, 'access', _248 => _248.style, 'optionalAccess', _249 => _249.fontSize]), () => ( 0)))) < 0.5 && b.text.trim().length >= 3 && b.text.trim().length <= 80 && b.bbox.height <= (_nullishCoalesce(_optionalChain([b, 'access', _250 => _250.style, 'optionalAccess', _251 => _251.fontSize]), () => ( 0))) * 1.6 && /^[A-Z]/.test(b.text.trim()) && !/[.!?:;,]$/.test(b.text.trim()) && !/^(?:Table|Figure|Fig\.?|Appendix)\s+\d/i.test(b.text.trim()));
+      const candidates = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _249 => _249.style, 'optionalAccess', _250 => _250.fontName]) === _optionalChain([anchor, 'access', _251 => _251.style, 'optionalAccess', _252 => _252.fontName]) && Math.abs((_nullishCoalesce(_optionalChain([b, 'access', _253 => _253.style, 'optionalAccess', _254 => _254.fontSize]), () => ( 0))) - (_nullishCoalesce(_optionalChain([anchor, 'access', _255 => _255.style, 'optionalAccess', _256 => _256.fontSize]), () => ( 0)))) < 0.5 && b.text.trim().length >= 3 && b.text.trim().length <= 80 && b.bbox.height <= (_nullishCoalesce(_optionalChain([b, 'access', _257 => _257.style, 'optionalAccess', _258 => _258.fontSize]), () => ( 0))) * 1.6 && /^[A-Z]/.test(b.text.trim()) && !/[.!?:;,]$/.test(b.text.trim()) && !/^(?:Table|Figure|Fig\.?|Appendix)\s+\d/i.test(b.text.trim()));
       const siblings = candidates.filter((b) => numbered ? new RegExp(`^${numbered[1]}\\.\\d+\\s+`).test(b.text.trim()) : lettered ? /^[A-Z]\s+/.test(b.text.trim()) && Math.abs(anchor.bbox.x - b.bbox.x) < 8 : peers.some((h) => h.bbox && Math.abs(h.bbox.x - b.bbox.x) < 8));
       if (siblings.length < (numbered || lettered ? 1 : 2)) continue;
       for (const sibling of siblings) {
@@ -5625,13 +6483,13 @@ function detectRepeatedPageLabels(blocks) {
   }
   for (const page of byPage.values()) {
     const bodyChars = /* @__PURE__ */ new Map();
-    for (const b of page) if (b.type === "paragraph" && b.text && _optionalChain([b, 'access', _252 => _252.style, 'optionalAccess', _253 => _253.fontName])) {
+    for (const b of page) if (b.type === "paragraph" && b.text && _optionalChain([b, 'access', _259 => _259.style, 'optionalAccess', _260 => _260.fontName])) {
       const faces = FACE_CHARS.get(b);
       if (faces) for (const [face, n] of faces) bodyChars.set(face, (_nullishCoalesce(bodyChars.get(face), () => ( 0))) + n);
       else bodyChars.set(b.style.fontName, (_nullishCoalesce(bodyChars.get(b.style.fontName), () => ( 0))) + b.text.length);
     }
-    const bodyFace = _optionalChain([[...bodyChars], 'access', _254 => _254.sort, 'call', _255 => _255((a, b) => b[1] - a[1]), 'access', _256 => _256[0], 'optionalAccess', _257 => _257[0]]);
-    const candidates = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _258 => _258.style, 'optionalAccess', _259 => _259.fontName]) && b.style.fontName !== bodyFace && b.bbox.height <= (_nullishCoalesce(b.style.fontSize, () => ( 0))) * 1.6 && b.text.trim().length >= 5 && b.text.trim().length <= 80);
+    const bodyFace = _optionalChain([[...bodyChars], 'access', _261 => _261.sort, 'call', _262 => _262((a, b) => b[1] - a[1]), 'access', _263 => _263[0], 'optionalAccess', _264 => _264[0]]);
+    const candidates = page.filter((b) => b.type === "paragraph" && b.text && b.bbox && _optionalChain([b, 'access', _265 => _265.style, 'optionalAccess', _266 => _266.fontName]) && b.style.fontName !== bodyFace && b.bbox.height <= (_nullishCoalesce(b.style.fontSize, () => ( 0))) * 1.6 && b.text.trim().length >= 5 && b.text.trim().length <= 80);
     const groups = /* @__PURE__ */ new Map();
     for (const b of candidates) {
       const key = `${b.style.fontName}:${b.style.fontSize}`;
@@ -5667,19 +6525,19 @@ function detectPageLeadHeadings(blocks) {
   for (const page of byPage.values()) {
     const content = page.filter((b) => b.type !== "image" && b.type !== "separator" && !(b.type === "paragraph" && !b.style));
     const [first, second, third] = content;
-    if (!_optionalChain([first, 'optionalAccess', _260 => _260.bbox]) || !first.text || !_optionalChain([first, 'access', _261 => _261.style, 'optionalAccess', _262 => _262.fontSize]) || !second) continue;
+    if (!_optionalChain([first, 'optionalAccess', _267 => _267.bbox]) || !first.text || !_optionalChain([first, 'access', _268 => _268.style, 'optionalAccess', _269 => _269.fontSize]) || !second) continue;
     const firstText = first.text.trim();
     const captionLike = /^(?:Figure|Fig\.?|Table|표|그림)\s*\d/i;
     const hasImage = page.some((b) => b.type === "image");
-    const firstIsTitle = first.type === "paragraph" && firstText.length >= 5 && firstText.length <= 80 && first.bbox.height <= first.style.fontSize * 1.6 && (/^(?:CONTENTS|Table of Contents)$/i.test(firstText) || hasImage && /^[A-Z]/.test(firstText) && !captionLike.test(firstText) && second.type === "paragraph" && /^[A-Z]/.test(_nullishCoalesce(_optionalChain([second, 'access', _263 => _263.text, 'optionalAccess', _264 => _264.trim, 'call', _265 => _265()]), () => ( ""))) && (_nullishCoalesce(_optionalChain([second, 'access', _266 => _266.text, 'optionalAccess', _267 => _267.length]), () => ( 0))) >= 100 && second.bbox && first.bbox.y - (second.bbox.y + second.bbox.height) >= first.style.fontSize);
+    const firstIsTitle = first.type === "paragraph" && firstText.length >= 5 && firstText.length <= 80 && first.bbox.height <= first.style.fontSize * 1.6 && (/^(?:CONTENTS|Table of Contents)$/i.test(firstText) || hasImage && /^[A-Z]/.test(firstText) && !captionLike.test(firstText) && second.type === "paragraph" && /^[A-Z]/.test(_nullishCoalesce(_optionalChain([second, 'access', _270 => _270.text, 'optionalAccess', _271 => _271.trim, 'call', _272 => _272()]), () => ( ""))) && (_nullishCoalesce(_optionalChain([second, 'access', _273 => _273.text, 'optionalAccess', _274 => _274.length]), () => ( 0))) >= 100 && second.bbox && first.bbox.y - (second.bbox.y + second.bbox.height) >= first.style.fontSize);
     const firstAboveProse = first.type === "paragraph" && firstText.length >= 5 && firstText.length <= 80 && first.bbox.height <= first.style.fontSize * 2 && second.type === "paragraph" && second.bbox && second.bbox.height >= first.style.fontSize * 4 && Math.abs(first.bbox.x - second.bbox.x) <= first.style.fontSize * 2 && first.bbox.y - (second.bbox.y + second.bbox.height) >= first.style.fontSize * 2 && !captionLike.test(firstText) && !/^(?:doi:|https?:|www\.)/i.test(firstText);
-    const firstIsSection = first.type === "list" && /^\d+\.\s+[A-Z][A-Z\s]{12,}$/.test(firstText) && second.type === "paragraph" && (_nullishCoalesce(_optionalChain([second, 'access', _268 => _268.text, 'optionalAccess', _269 => _269.length]), () => ( 0))) >= 100;
+    const firstIsSection = first.type === "list" && /^\d+\.\s+[A-Z][A-Z\s]{12,}$/.test(firstText) && second.type === "paragraph" && (_nullishCoalesce(_optionalChain([second, 'access', _275 => _275.text, 'optionalAccess', _276 => _276.length]), () => ( 0))) >= 100;
     if (firstIsTitle || firstAboveProse || firstIsSection) {
       first.type = "heading";
       first.level = 1;
     }
-    if (first.type !== "heading" || captionLike.test(firstText) || second.type !== "paragraph" || !second.text || !second.bbox || !_optionalChain([second, 'access', _270 => _270.style, 'optionalAccess', _271 => _271.fontName]) || !second.style.fontSize || !_optionalChain([third, 'optionalAccess', _272 => _272.text]) || !third.bbox || second.text.trim().length < 5 || second.text.trim().length > 80 || captionLike.test(second.text.trim()) || /^(?:doi:|https?:)/i.test(second.text.trim()) || second.bbox.height > second.style.fontSize * 1.6 || Math.abs(second.bbox.x - third.bbox.x) > 30) continue;
-    const distinctFace = _optionalChain([third, 'access', _273 => _273.style, 'optionalAccess', _274 => _274.fontName]) !== second.style.fontName;
+    if (first.type !== "heading" || captionLike.test(firstText) || second.type !== "paragraph" || !second.text || !second.bbox || !_optionalChain([second, 'access', _277 => _277.style, 'optionalAccess', _278 => _278.fontName]) || !second.style.fontSize || !_optionalChain([third, 'optionalAccess', _279 => _279.text]) || !third.bbox || second.text.trim().length < 5 || second.text.trim().length > 80 || captionLike.test(second.text.trim()) || /^(?:doi:|https?:)/i.test(second.text.trim()) || second.bbox.height > second.style.fontSize * 1.6 || Math.abs(second.bbox.x - third.bbox.x) > 30) continue;
+    const distinctFace = _optionalChain([third, 'access', _280 => _280.style, 'optionalAccess', _281 => _281.fontName]) !== second.style.fontName;
     const namedContents = /^Table of Contents$/i.test(second.text.trim());
     if (distinctFace && third.text.length >= 60 || namedContents) {
       second.type = "heading";
@@ -5690,24 +6548,24 @@ function detectPageLeadHeadings(blocks) {
 function refineDocumentStyleHeadings(blocks) {
   const faceChars = /* @__PURE__ */ new Map();
   for (const block of blocks) {
-    if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _275 => _275.style, 'optionalAccess', _276 => _276.fontName])) continue;
+    if (block.type !== "paragraph" || !block.text || !_optionalChain([block, 'access', _282 => _282.style, 'optionalAccess', _283 => _283.fontName])) continue;
     faceChars.set(block.style.fontName, (_nullishCoalesce(faceChars.get(block.style.fontName), () => ( 0))) + block.text.length);
   }
   const [bodyFace, bodyChars] = _nullishCoalesce([...faceChars].sort((a, b) => b[1] - a[1])[0], () => ( []));
   if (!bodyFace || !bodyChars || bodyChars < 300) return;
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];
-    const text = _nullishCoalesce(_optionalChain([block, 'access', _277 => _277.text, 'optionalAccess', _278 => _278.trim, 'call', _279 => _279()]), () => ( ""));
+    const text = _nullishCoalesce(_optionalChain([block, 'access', _284 => _284.text, 'optionalAccess', _285 => _285.trim, 'call', _286 => _286()]), () => ( ""));
     if (block.type === "heading" && /(?:https?:\/\/|www\.|^arxiv:|^doi:)/i.test(text)) {
       block.type = "paragraph";
       block.level = void 0;
       continue;
     }
     const box = block.bbox, style = block.style;
-    if (block.type !== "paragraph" || !box || !_optionalChain([style, 'optionalAccess', _280 => _280.fontName]) || !style.fontSize || style.fontName === bodyFace || (_nullishCoalesce(faceChars.get(style.fontName), () => ( 0))) > bodyChars * 0.25 || text.length < 3 || text.length > 70 || text.includes("\n") || box.height > style.fontSize * 1.6 || /^(?:table|figure|fig\.?|source|doi:|arxiv:|https?:|www\.|[•●○▪▫⮚*∗†])/i.test(text) || /(?:https?:\/\/|www\.|@|[=¼≪þ])/i.test(text) || /^definition\s+\d+[.:]?\s+.*\b(?:is|are|means)\b/i.test(text) || /^[\d\s.,:%+\-–]+$/.test(text)) continue;
+    if (block.type !== "paragraph" || !box || !_optionalChain([style, 'optionalAccess', _287 => _287.fontName]) || !style.fontSize || style.fontName === bodyFace || (_nullishCoalesce(faceChars.get(style.fontName), () => ( 0))) > bodyChars * 0.25 || text.length < 3 || text.length > 70 || text.includes("\n") || box.height > style.fontSize * 1.6 || /^(?:table|figure|fig\.?|source|doi:|arxiv:|https?:|www\.|[•●○▪▫⮚*∗†])/i.test(text) || /(?:https?:\/\/|www\.|@|[=¼≪þ])/i.test(text) || /^definition\s+\d+[.:]?\s+.*\b(?:is|are|means)\b/i.test(text) || /^[\d\s.,:%+\-–]+$/.test(text)) continue;
     const previous = blocks[i - 1], next = blocks[i + 1];
-    const pb = _optionalChain([previous, 'optionalAccess', _281 => _281.bbox]), nb = _optionalChain([next, 'optionalAccess', _282 => _282.bbox]);
-    if (!pb || !nb || previous.pageNumber !== block.pageNumber || next.pageNumber !== block.pageNumber || previous.type !== "paragraph" && previous.type !== "heading" || next.type !== "paragraph" || _optionalChain([next, 'access', _283 => _283.style, 'optionalAccess', _284 => _284.fontName]) !== bodyFace || !next.text || next.text.length < 40 || style.fontSize < (_nullishCoalesce(next.style.fontSize, () => ( 0))) * 0.95 || pb.y - (box.y + box.height) < style.fontSize * 0.5 || box.y - (nb.y + nb.height) < 0 || box.y - (nb.y + nb.height) > style.fontSize * 2 || box.x + box.width / 2 < nb.x - 10 || box.x + box.width / 2 > nb.x + nb.width + 10) continue;
+    const pb = _optionalChain([previous, 'optionalAccess', _288 => _288.bbox]), nb = _optionalChain([next, 'optionalAccess', _289 => _289.bbox]);
+    if (!pb || !nb || previous.pageNumber !== block.pageNumber || next.pageNumber !== block.pageNumber || previous.type !== "paragraph" && previous.type !== "heading" || next.type !== "paragraph" || _optionalChain([next, 'access', _290 => _290.style, 'optionalAccess', _291 => _291.fontName]) !== bodyFace || !next.text || next.text.length < 40 || style.fontSize < (_nullishCoalesce(next.style.fontSize, () => ( 0))) * 0.95 || pb.y - (box.y + box.height) < style.fontSize * 0.5 || box.y - (nb.y + nb.height) < 0 || box.y - (nb.y + nb.height) > style.fontSize * 2 || box.x + box.width / 2 < nb.x - 10 || box.x + box.width / 2 > nb.x + nb.width + 10) continue;
     block.type = "heading";
     block.level = 2;
   }
@@ -5757,7 +6615,7 @@ function detectMarkerHeadings(blocks) {
       block.level = 4;
       continue;
     }
-    if (/^[가-힣]{2,6}$/.test(text) && _optionalChain([block, 'access', _285 => _285.style, 'optionalAccess', _286 => _286.fontSize])) {
+    if (/^[가-힣]{2,6}$/.test(text) && _optionalChain([block, 'access', _292 => _292.style, 'optionalAccess', _293 => _293.fontSize])) {
       const prev = blocks[i - 1];
       const next = blocks[i + 1];
       const prevIsStructural = !prev || prev.type === "table" || prev.type === "heading" || prev.type === "separator";
@@ -5798,7 +6656,7 @@ function detectTableCaptions(blocks) {
       block.table.caption = blocks[i - 1].text.trim();
       blocks.splice(i - 1, 1);
       i--;
-    } else if (isCaptionCandidate(blocks[i + 1], block) && _optionalChain([blocks, 'access', _287 => _287[i + 2], 'optionalAccess', _288 => _288.type]) !== "table") {
+    } else if (isCaptionCandidate(blocks[i + 1], block) && _optionalChain([blocks, 'access', _294 => _294[i + 2], 'optionalAccess', _295 => _295.type]) !== "table") {
       const cap = blocks[i + 1].bbox, tbl = block.bbox;
       block.table.caption = blocks[i + 1].text.trim();
       if (cap && tbl && cap.y + cap.height <= tbl.y + 1) block.table.captionBelow = true;
@@ -6036,7 +6894,7 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
   const bottomEntries = [];
   for (let bi = 0; bi < blocks.length; bi++) {
     const b = blocks[bi];
-    const text = !tables ? _optionalChain([b, 'access', _289 => _289.text, 'optionalAccess', _290 => _290.trim, 'call', _291 => _291()]) : b.type === "table" && b.table ? b.table.cells.flat().map((c) => c.text.trim()).filter(Boolean).join(" | ") : void 0;
+    const text = !tables ? _optionalChain([b, 'access', _296 => _296.text, 'optionalAccess', _297 => _297.trim, 'call', _298 => _298()]) : b.type === "table" && b.table ? b.table.cells.flat().map((c) => c.text.trim()).filter(Boolean).join(" | ") : void 0;
     if (!b.bbox || !b.pageNumber || !text) continue;
     const ph = pageHeights.get(b.bbox.page) || pageHeights.get(b.pageNumber);
     if (!ph) continue;
@@ -6069,7 +6927,7 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
     for (const [p, count] of patternCount) {
       const pages = [..._nullishCoalesce(patternPages.get(p), () => ( []))];
       const span2 = pages.length ? Math.max(...pages) - Math.min(...pages) + 1 : 0;
-      const varying = !tables && (_nullishCoalesce(_optionalChain([patternNumbers, 'access', _292 => _292.get, 'call', _293 => _293(p), 'optionalAccess', _294 => _294.size]), () => ( 0))) > 1;
+      const varying = !tables && (_nullishCoalesce(_optionalChain([patternNumbers, 'access', _299 => _299.get, 'call', _300 => _300(p), 'optionalAccess', _301 => _301.size]), () => ( 0))) > 1;
       const occ = _nullishCoalesce(patternOcc.get(p), () => ( []));
       const dense = pages.length >= span2 * 0.4;
       const loose = looseVaryingNumber(occ, entries === topEntries) && (entries === bottomEntries || dense || tracksPages(occ));
@@ -6081,8 +6939,8 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
     for (const e of entries) {
       const norm = e.text.replace(/\d+/g, "#");
       if (!repeatedPatterns.has(norm)) continue;
-      const noteMark = _optionalChain([e, 'access', _295 => _295.text, 'access', _296 => _296.match, 'call', _297 => _297(/^\d{1,3}\)/), 'optionalAccess', _298 => _298[0]]);
-      if (noteMark && _optionalChain([notes, 'optionalAccess', _299 => _299.get, 'call', _300 => _300(e.page), 'optionalAccess', _301 => _301.marks, 'access', _302 => _302.some, 'call', _303 => _303((m) => m.mark === noteMark)])) continue;
+      const noteMark = _optionalChain([e, 'access', _302 => _302.text, 'access', _303 => _303.match, 'call', _304 => _304(/^\d{1,3}\)/), 'optionalAccess', _305 => _305[0]]);
+      if (noteMark && _optionalChain([notes, 'optionalAccess', _306 => _306.get, 'call', _307 => _307(e.page), 'optionalAccess', _308 => _308.marks, 'access', _309 => _309.some, 'call', _310 => _310((m) => m.mark === noteMark)])) continue;
       const cand = blocks[e.blockIdx];
       const cb = cand.bbox;
       const tableNote = /^(?:주\s*(?:\d+\s*[).:]|[:：])|(?:자료|출처)\s*[:：]|\*\s+\S)/.test(e.text.replace(/ \| /g, " ")) && blocks.some((o) => {
@@ -6096,7 +6954,7 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
         if (bi === e.blockIdx) continue;
         const o = blocks[bi];
         if (!o.bbox || o.bbox.page !== cb.page) continue;
-        const oNorm = _optionalChain([o, 'access', _304 => _304.text, 'optionalAccess', _305 => _305.trim, 'call', _306 => _306(), 'access', _307 => _307.replace, 'call', _308 => _308(/\d+/g, "#")]);
+        const oNorm = _optionalChain([o, 'access', _311 => _311.text, 'optionalAccess', _312 => _312.trim, 'call', _313 => _313(), 'access', _314 => _314.replace, 'call', _315 => _315(/\d+/g, "#")]);
         if (oNorm && repeatedPatterns.has(oNorm)) continue;
         const overlap2 = Math.min(cb.y + cb.height, o.bbox.y + o.bbox.height) - Math.max(cb.y, o.bbox.y);
         if (overlap2 >= cb.height * 0.5) {
@@ -6224,7 +7082,7 @@ function recordRowRules(table, cells, bbox, hs) {
 function markImageCell(cell) {
   IMAGE_CELLS.add(cell);
 }
-var emptyCell = (cell) => !cell || !_optionalChain([cell, 'access', _309 => _309.text, 'optionalAccess', _310 => _310.trim, 'call', _311 => _311()]) && !_optionalChain([cell, 'access', _312 => _312.blocks, 'optionalAccess', _313 => _313.length]) && !IMAGE_CELLS.has(cell);
+var emptyCell = (cell) => !cell || !_optionalChain([cell, 'access', _316 => _316.text, 'optionalAccess', _317 => _317.trim, 'call', _318 => _318()]) && !_optionalChain([cell, 'access', _319 => _319.blocks, 'optionalAccess', _320 => _320.length]) && !IMAGE_CELLS.has(cell);
 function trimTable(table) {
   let cols = table.cols;
   while (cols > 0 && table.cells.every((row) => emptyCell(row[cols - 1]))) cols--;
@@ -6240,7 +7098,7 @@ function trimTable(table) {
 function trimTrailingEmptyTableCols(blocks) {
   for (const b of blocks) {
     if (b.type !== "table" || !b.table) continue;
-    for (const row of b.table.cells) for (const cell of row) if (_optionalChain([cell, 'access', _314 => _314.blocks, 'optionalAccess', _315 => _315.length])) trimTrailingEmptyTableCols(cell.blocks);
+    for (const row of b.table.cells) for (const cell of row) if (_optionalChain([cell, 'access', _321 => _321.blocks, 'optionalAccess', _322 => _322.length])) trimTrailingEmptyTableCols(cell.blocks);
     trimTable(b.table);
   }
 }
@@ -6260,7 +7118,7 @@ function mergeSliverColumns(grid, colXs, maxWidth) {
     }
     const ok = owner.every((row) => {
       const o = row[c];
-      return !!o && (o.colSpan > 1 || !o.text.trim() && !_optionalChain([o, 'access', _316 => _316.blocks, 'optionalAccess', _317 => _317.length]));
+      return !!o && (o.colSpan > 1 || !o.text.trim() && !_optionalChain([o, 'access', _323 => _323.blocks, 'optionalAccess', _324 => _324.length]));
     });
     if (!ok) continue;
     const spanning = /* @__PURE__ */ new Set();
@@ -6287,7 +7145,7 @@ var multiply = (m, t) => [
   m[1] * t[4] + m[3] * t[5] + m[5]
 ];
 function hollowCircle(image) {
-  if (!_optionalChain([image, 'optionalAccess', _318 => _318.data]) || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128 || Math.abs(image.width - image.height) > Math.min(image.width, image.height) * 0.1) return false;
+  if (!_optionalChain([image, 'optionalAccess', _325 => _325.data]) || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128 || Math.abs(image.width - image.height) > Math.min(image.width, image.height) * 0.1) return false;
   const stride = image.kind === _pdfmjs.ImageKind.RGB_24BPP ? 3 : image.kind === _pdfmjs.ImageKind.RGBA_32BPP ? 4 : 0;
   const { width, height, data } = image;
   if (!stride || data.length < width * height * stride) return false;
@@ -6352,9 +7210,9 @@ function smallVisibleImagePaints(fnArray, argsArray) {
     const op = fnArray[i], args = argsArray[i];
     if (op === _pdfmjs.OPS.save || op === _pdfmjs.OPS.paintFormXObjectBegin) {
       stack.push({ ctm, alpha, clip, unknownClip });
-      const matrix = op === _pdfmjs.OPS.paintFormXObjectBegin ? _optionalChain([args, 'optionalAccess', _319 => _319[0]]) : void 0;
+      const matrix = op === _pdfmjs.OPS.paintFormXObjectBegin ? _optionalChain([args, 'optionalAccess', _326 => _326[0]]) : void 0;
       if (Array.isArray(matrix) && matrix.length >= 6) ctm = multiply(ctm, matrix);
-      const bounds = op === _pdfmjs.OPS.paintFormXObjectBegin ? _optionalChain([args, 'optionalAccess', _320 => _320[1]]) : void 0;
+      const bounds = op === _pdfmjs.OPS.paintFormXObjectBegin ? _optionalChain([args, 'optionalAccess', _327 => _327[1]]) : void 0;
       if (Array.isArray(bounds) && bounds.length === 4) {
         const box = rectangle(bounds[0], bounds[1], bounds[2] - bounds[0], bounds[3] - bounds[1]);
         if (box && ctm[1] === 0 && ctm[2] === 0) intersectClip(box);
@@ -6362,17 +7220,17 @@ function smallVisibleImagePaints(fnArray, argsArray) {
       }
     } else if (op === _pdfmjs.OPS.restore || op === _pdfmjs.OPS.paintFormXObjectEnd) {
       const state = stack.pop();
-      ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _321 => _321.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
-      alpha = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _322 => _322.alpha]), () => ( 1));
-      clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _323 => _323.clip]), () => ( null));
-      unknownClip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _324 => _324.unknownClip]), () => ( false));
+      ctm = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _328 => _328.ctm]), () => ( [1, 0, 0, 1, 0, 0]));
+      alpha = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _329 => _329.alpha]), () => ( 1));
+      clip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _330 => _330.clip]), () => ( null));
+      unknownClip = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _331 => _331.unknownClip]), () => ( false));
     } else if (op === _pdfmjs.OPS.setGState) {
-      for (const [key, value] of _nullishCoalesce(_optionalChain([args, 'optionalAccess', _325 => _325[0]]), () => ( []))) {
+      for (const [key, value] of _nullishCoalesce(_optionalChain([args, 'optionalAccess', _332 => _332[0]]), () => ( []))) {
         if (key === "ca") alpha = typeof value === "number" ? value : 0;
       }
     } else if (op === _pdfmjs.OPS.constructPath) {
       const [operations, coordinates] = args;
-      pathRect = pathRect === void 0 && _optionalChain([operations, 'optionalAccess', _326 => _326.length]) === 1 && operations[0] === _pdfmjs.OPS.rectangle && _optionalChain([coordinates, 'optionalAccess', _327 => _327.length]) >= 4 && ctm[1] === 0 && ctm[2] === 0 ? rectangle(coordinates[0], coordinates[1], coordinates[2], coordinates[3]) : null;
+      pathRect = pathRect === void 0 && _optionalChain([operations, 'optionalAccess', _333 => _333.length]) === 1 && operations[0] === _pdfmjs.OPS.rectangle && _optionalChain([coordinates, 'optionalAccess', _334 => _334.length]) >= 4 && ctm[1] === 0 && ctm[2] === 0 ? rectangle(coordinates[0], coordinates[1], coordinates[2], coordinates[3]) : null;
     } else if (op === _pdfmjs.OPS.clip || op === _pdfmjs.OPS.eoClip) pendingClip = true;
     else if ([
       _pdfmjs.OPS.endPath,
@@ -6392,7 +7250,7 @@ function smallVisibleImagePaints(fnArray, argsArray) {
       pendingClip = false;
       pathRect = void 0;
     } else if (op === _pdfmjs.OPS.transform && Array.isArray(args) && args.length >= 6) ctm = multiply(ctm, args);
-    else if (op === _pdfmjs.OPS.paintImageXObject && typeof _optionalChain([args, 'optionalAccess', _328 => _328[0]]) === "string") {
+    else if (op === _pdfmjs.OPS.paintImageXObject && typeof _optionalChain([args, 'optionalAccess', _335 => _335[0]]) === "string") {
       if (typeof args[1] !== "number" || typeof args[2] !== "number" || args[1] < 16 || args[1] > 128 || args[2] < 16 || args[2] > 128) continue;
       const box = extractImageRegions([_pdfmjs.OPS.transform, _pdfmjs.OPS.paintImageXObject], [ctm, args])[0];
       if (!box || ctm[1] !== 0 || ctm[2] !== 0 || alpha < 0.99 || unknownClip || clip && (box.x1 + (box.x2 - box.x1) * 0.03 < clip.x1 || box.y1 + (box.y2 - box.y1) * 0.03 < clip.y1 || box.x2 - (box.x2 - box.x1) * 0.03 > clip.x2 || box.y2 - (box.y2 - box.y1) * 0.03 > clip.y2)) continue;
@@ -6411,14 +7269,14 @@ async function restoreImageBullets(items, page, fnArray, argsArray, shapes = /*
     const line = items.filter((item) => !item.isHidden && item.fontSize > 0 && item.x >= box.x2 && item.x - box.x2 <= item.fontSize * 0.7 && Math.abs(item.y + item.h / 2 - (box.y1 + box.y2) / 2) <= item.fontSize * 0.4 && height >= item.fontSize * 0.5 && height <= item.fontSize * 1.2).sort((a, b) => a.x - b.x)[0];
     if (!line || /^[○●•◦□■∙]/.test(line.text.trim()) || !/\p{L}/u.test(line.text)) continue;
     const row = items.filter((item) => Math.abs(item.y - line.y) <= 2 && item.x >= line.x);
-    if (row.reduce((n, item) => n + (_nullishCoalesce(_optionalChain([item, 'access', _329 => _329.text, 'access', _330 => _330.match, 'call', _331 => _331(/\p{L}/gu), 'optionalAccess', _332 => _332.length]), () => ( 0))), 0) < 12 || items.some((item) => item !== line && Math.abs(item.y - line.y) <= 2 && item.x < line.x)) continue;
+    if (row.reduce((n, item) => n + (_nullishCoalesce(_optionalChain([item, 'access', _336 => _336.text, 'access', _337 => _337.match, 'call', _338 => _338(/\p{L}/gu), 'optionalAccess', _339 => _339.length]), () => ( 0))), 0) < 12 || items.some((item) => item !== line && Math.abs(item.y - line.y) <= 2 && item.x < line.x)) continue;
     candidates.push({ id, x: box.x1, width, line });
   }
   let restored = 0;
   const used = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
     const same = candidates.filter((other) => other.id === candidate.id && other.line !== candidate.line && Math.abs(other.line.x - candidate.line.x) <= 1 && Math.abs(other.x - candidate.x) <= 1 && Math.abs(other.width - candidate.width) <= 1 && other.line.fontSize === candidate.line.fontSize && Math.abs(other.line.y - candidate.line.y) >= candidate.line.fontSize * 2);
-    const numbered = items.filter((item) => !item.isHidden && /^[①-⑮]\s*/.test(item.text.trim()) && item.fontName === candidate.line.fontName && item.fontSize === candidate.line.fontSize && Math.abs(item.x - candidate.x) <= 1 && (_nullishCoalesce(_optionalChain([item, 'access', _333 => _333.text, 'access', _334 => _334.match, 'call', _335 => _335(/\p{L}/gu), 'optionalAccess', _336 => _336.length]), () => ( 0))) >= 12).sort((a, b) => b.y - a.y);
+    const numbered = items.filter((item) => !item.isHidden && /^[①-⑮]\s*/.test(item.text.trim()) && item.fontName === candidate.line.fontName && item.fontSize === candidate.line.fontSize && Math.abs(item.x - candidate.x) <= 1 && (_nullishCoalesce(_optionalChain([item, 'access', _340 => _340.text, 'access', _341 => _341.match, 'call', _342 => _342(/\p{L}/gu), 'optionalAccess', _343 => _343.length]), () => ( 0))) >= 12).sort((a, b) => b.y - a.y);
     const numberedList = numbered.some((item, index) => index > 0 && item.text.trim().charCodeAt(0) === numbered[index - 1].text.trim().charCodeAt(0) + 1);
     if (!same.length && !numberedList || used.has(candidate.line)) continue;
     if (!shapes.has(candidate.id)) shapes.set(candidate.id, hollowCircle(await resolveImagePixels(page, candidate.id)));
@@ -6484,7 +7342,7 @@ function groupFlowBoxUnits(blocks, grids, hs, vs, images) {
   return units;
 }
 function arrowDirection(image) {
-  if (!_optionalChain([image, 'optionalAccess', _337 => _337.data]) || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128) return 0;
+  if (!_optionalChain([image, 'optionalAccess', _344 => _344.data]) || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128) return 0;
   const { width, height, data } = image;
   const stride = image.kind === _pdfmjs.ImageKind.RGB_24BPP ? 3 : image.kind === _pdfmjs.ImageKind.RGBA_32BPP ? 4 : 0;
   if (!stride || data.length < width * height * stride) return 0;
@@ -6552,7 +7410,7 @@ function isSideTabTable(box, table, others, pageWidth, pageHeight) {
 function removeSideTabs(blocks, pageWidths) {
   const edges = /* @__PURE__ */ new Map();
   for (const b of blocks) {
-    if (!b.bbox || b.pageNumber === void 0 || [..._nullishCoalesce(_optionalChain([b, 'access', _338 => _338.text, 'optionalAccess', _339 => _339.trim, 'call', _340 => _340()]), () => ( ""))].length <= MAX_CHARS) continue;
+    if (!b.bbox || b.pageNumber === void 0 || [..._nullishCoalesce(_optionalChain([b, 'access', _345 => _345.text, 'optionalAccess', _346 => _346.trim, 'call', _347 => _347()]), () => ( ""))].length <= MAX_CHARS) continue;
     const e = _nullishCoalesce(edges.get(b.pageNumber), () => ( { lefts: [], rights: [] }));
     e.lefts.push(b.bbox.x);
     e.rights.push(b.bbox.x + b.bbox.width);
@@ -6568,7 +7426,7 @@ function removeSideTabs(blocks, pageWidths) {
   const fallback = all.length ? { left: q(all.map((e) => e.left), 0.5), right: q(all.map((e) => e.right), 0.5) } : void 0;
   const key = (b) => {
     const w = b.pageNumber !== void 0 ? pageWidths.get(b.pageNumber) : void 0;
-    const text = _optionalChain([b, 'access', _341 => _341.text, 'optionalAccess', _342 => _342.trim, 'call', _343 => _343()]);
+    const text = _optionalChain([b, 'access', _348 => _348.text, 'optionalAccess', _349 => _349.trim, 'call', _350 => _350()]);
     const area = _nullishCoalesce((b.pageNumber !== void 0 ? body.get(b.pageNumber) : void 0), () => ( fallback));
     if (b.type === "table") {
       if (!w || !b.bbox || !b.table || !SIDE_TAB_TABLES.has(b.table)) return null;
@@ -7004,16 +7862,16 @@ function isProseSpread(items) {
   for (let i = 1; i < sorted.length; i++) {
     gaps.push(sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w));
   }
-  const maxGap = _chunk2JDVPQ33cjs.safeMax.call(void 0, gaps);
+  const maxGap = _chunkC3BOYTY5cjs.safeMax.call(void 0, gaps);
   const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
   if (items.length >= 4 && maxGap < 40 && avgLen < 5) return true;
-  const minGap = _chunk2JDVPQ33cjs.safeMin.call(void 0, gaps);
+  const minGap = _chunkC3BOYTY5cjs.safeMin.call(void 0, gaps);
   return minGap > 0 && maxGap - minGap <= Math.max(2, maxGap * 0.15) && (items.filter((i) => /^\P{L}*\p{Ll}/u.test(i.text)).length * 2 >= items.length || items.some((i) => /\p{L}[,.;:]["”’)]?$/u.test(i.text)));
 }
 function detectColumns(yLines) {
   const allItems = yLines.flat();
   if (allItems.length === 0) return null;
-  const pageWidth = _chunk2JDVPQ33cjs.safeMax.call(void 0, allItems.map((i) => i.x + i.w)) - _chunk2JDVPQ33cjs.safeMin.call(void 0, allItems.map((i) => i.x));
+  const pageWidth = _chunkC3BOYTY5cjs.safeMax.call(void 0, allItems.map((i) => i.x + i.w)) - _chunkC3BOYTY5cjs.safeMin.call(void 0, allItems.map((i) => i.x));
   if (pageWidth < 100) return null;
   let bigoLineIdx = -1;
   for (let i = 0; i < yLines.length; i++) {
@@ -7238,7 +8096,7 @@ var UNDER_BOX_PAIR_MAX_EM = 2.2;
 var UNDER_BOX_PAIR_OVERLAP = 0.8;
 function markUnderlineItems(items, horizontals, verticals, nonRules) {
   const underlines = [];
-  if (_optionalChain([nonRules, 'optionalAccess', _344 => _344.size])) horizontals = horizontals.filter((line) => !nonRules.has(line));
+  if (_optionalChain([nonRules, 'optionalAccess', _351 => _351.size])) horizontals = horizontals.filter((line) => !nonRules.has(line));
   if (items.length === 0 || horizontals.length === 0) return underlines;
   const tightOwners = /* @__PURE__ */ new Map();
   const tightlyOwned = (line) => {
@@ -7344,7 +8202,7 @@ function hasBoxTopPair(line, maxH, horizontals, cellItems) {
     if (ow <= 0) continue;
     const overlap2 = Math.min(line.x2, o.x2) - Math.max(line.x1, o.x1);
     if (overlap2 / Math.max(w, ow) < UNDER_BOX_PAIR_OVERLAP) continue;
-    const covered = _nullishCoalesce(_optionalChain([cellItems, 'optionalAccess', _345 => _345.reduce, 'call', _346 => _346((sum, item) => {
+    const covered = _nullishCoalesce(_optionalChain([cellItems, 'optionalAccess', _352 => _352.reduce, 'call', _353 => _353((sum, item) => {
       const below = item.y - o.y1;
       if (below < 0.5 || below > 3 || !item.text.trim()) return sum;
       return sum + Math.max(0, Math.min(o.x2, item.x + item.w) - Math.max(o.x1, item.x));
@@ -7411,13 +8269,13 @@ function partTex(group) {
   const base = Math.min(...g.filter((i) => i.fontSize >= size * SCRIPT_SIZE_RATIO).map((i) => i.y));
   let s = "", run = "";
   const flush = () => {
-    if (run) s += _chunkAM5ALISVcjs.toTex.call(void 0, run);
+    if (run) s += _chunkNW2CKOFLcjs.toTex.call(void 0, run);
     run = "";
   };
   g.forEach((it, k) => {
     if (it.fontSize < size * SCRIPT_SIZE_RATIO && it.y - base >= size * SCRIPT_RISE_EM) {
       flush();
-      s += `^{${_chunkAM5ALISVcjs.toTex.call(void 0, it.text)}}`;
+      s += `^{${_chunkNW2CKOFLcjs.toTex.call(void 0, it.text)}}`;
       return;
     }
     if (k && it.x - (g[k - 1].x + g[k - 1].w) > spaceGapThreshold(it.fontSize)) run += " ";
@@ -7589,12 +8447,12 @@ function rebuildUnitLine(items, grid) {
 function prependUnitRow(cells, cols, line, usedItems) {
   const text = cleanCellText(line.map((item) => item.text).join(""));
   cells.unshift(Array.from({ length: cols }, (_, c) => ({ text: c === 0 ? text : "", colSpan: c === 0 ? cols : 1, rowSpan: 1 })));
-  for (const cell of cells[0]) _chunkAM5ALISVcjs.CELL_EDGES.set(cell, NO_EDGES);
+  for (const cell of cells[0]) _chunkNW2CKOFLcjs.CELL_EDGES.set(cell, NO_EDGES);
   for (const item of line) usedItems.add(item);
 }
 function attachUnitRow(items, grid, cells, cols, usedItems) {
   const all = cells.flat();
-  if (all.filter((c) => c.text.trim()).length * 2 < all.length || UNIT.test(_nullishCoalesce(_optionalChain([cells, 'access', _347 => _347[0], 'optionalAccess', _348 => _348[0], 'optionalAccess', _349 => _349.text]), () => ( "")))) return false;
+  if (all.filter((c) => c.text.trim()).length * 2 < all.length || UNIT.test(_nullishCoalesce(_optionalChain([cells, 'access', _354 => _354[0], 'optionalAccess', _355 => _355[0], 'optionalAccess', _356 => _356.text]), () => ( "")))) return false;
   const above = items.filter((it) => !usedItems.has(it) && it.y >= grid.bbox.y2 && it.y - grid.bbox.y2 <= 8 && it.x >= grid.bbox.x1 - 3 && it.x + it.w <= grid.bbox.x2 + 3);
   let nearest = Infinity;
   for (const it of above) nearest = Math.min(nearest, it.y);
@@ -7629,7 +8487,7 @@ function closeShadedTableEdges(clipGrids, horizontals, verticals, fillRects) {
   let hs = horizontals, vs = verticals;
   const restored = [];
   for (const grid of clipGrids) {
-    if (grid.clipParent || grid.rowYs.length !== 2 || grid.colXs.length < 3 || !_optionalChain([grid, 'access', _350 => _350.cells, 'optionalAccess', _351 => _351.length]) || grid.cells.some((c) => c.filler || c.rowSpan !== 1 || c.colSpan !== 1)) continue;
+    if (grid.clipParent || grid.rowYs.length !== 2 || grid.colXs.length < 3 || !_optionalChain([grid, 'access', _357 => _357.cells, 'optionalAccess', _358 => _358.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) => 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));
@@ -8093,7 +8951,7 @@ function takeFrameSpanningText(items, cutX, pageNum, lex) {
   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)) {
-      const run = runs[runs.length - 1], prev = _optionalChain([run, 'optionalAccess', _352 => _352[run.length - 1]]);
+      const run = runs[runs.length - 1], prev = _optionalChain([run, 'optionalAccess', _359 => _359[run.length - 1]]);
       if (prev && item.x - (prev.x + prev.w) <= Math.max(prev.fontSize, item.fontSize) * 0.6) run.push(item);
       else runs.push([item]);
     }
@@ -8137,7 +8995,7 @@ function groupFrameParagraphUnits(units, frames) {
   for (const unit of units) for (const block of unit) source.set(block, unit);
   const members = /* @__PURE__ */ new Map(), emitted = /* @__PURE__ */ new Set();
   for (const frame of frames) {
-    if (frame.length < 2 || frame.some((block) => block.type !== "paragraph" || _optionalChain([source, 'access', _353 => _353.get, 'call', _354 => _354(block), 'optionalAccess', _355 => _355.length]) !== 1)) continue;
+    if (frame.length < 2 || frame.some((block) => block.type !== "paragraph" || _optionalChain([source, 'access', _360 => _360.get, 'call', _361 => _361(block), 'optionalAccess', _362 => _362.length]) !== 1)) continue;
     for (const block of frame) members.set(block, frame);
   }
   const out = [];
@@ -8150,7 +9008,7 @@ function groupFrameParagraphUnits(units, frames) {
     }
   }
   for (const unit of out) {
-    if (unit.length < 2 || _optionalChain([FRAME_READING_UNITS, 'access', _356 => _356.get, 'call', _357 => _357(unit[0]), 'optionalAccess', _358 => _358.blocks]) === unit) continue;
+    if (unit.length < 2 || _optionalChain([FRAME_READING_UNITS, 'access', _363 => _363.get, 'call', _364 => _364(unit[0]), 'optionalAccess', _365 => _365.blocks]) === unit) continue;
     const bs = unit.map((b) => b.bbox).filter((b) => !!b);
     if (bs.length !== unit.length) continue;
     const x = Math.min(...bs.map((b) => b.x)), y = Math.min(...bs.map((b) => b.y));
@@ -8167,14 +9025,14 @@ function groupFrameParagraphUnits(units, frames) {
 function recordFrameTitle(table, source, pageNum) {
   if (!CLIP_TABLES.has(table) || table.rows !== 1 || table.cols !== 3 || source.length < 2) return;
   const cells = table.cells[0];
-  if (cells.length !== 3 || cells.some((c) => c.colSpan !== 1 || c.rowSpan !== 1 || _optionalChain([c, 'access', _359 => _359.blocks, 'optionalAccess', _360 => _360.length]) || c.text.includes("\n"))) return;
+  if (cells.length !== 3 || cells.some((c) => c.colSpan !== 1 || c.rowSpan !== 1 || _optionalChain([c, 'access', _366 => _366.blocks, 'optionalAccess', _367 => _367.length]) || c.text.includes("\n"))) return;
   const [label, spacer, title] = cells;
   if (!/^(?:붙임|별첨|첨부|부록)\s*\d{1,3}$/.test(label.text.trim()) || spacer.text.trim() || !title.text.trim()) return;
   if (cells.some((c) => {
-    const e = _chunkAM5ALISVcjs.CELL_EDGES.get(c);
+    const e = _chunkNW2CKOFLcjs.CELL_EDGES.get(c);
     return !e || e.t || e.b || e.l || e.r;
   })) return;
-  const xs = TABLE_COLXS.get(table), style = dominantStyle(source), fs = _nullishCoalesce(_optionalChain([style, 'optionalAccess', _361 => _361.fontSize]), () => ( 0));
+  const xs = TABLE_COLXS.get(table), style = dominantStyle(source), fs = _nullishCoalesce(_optionalChain([style, 'optionalAccess', _368 => _368.fontSize]), () => ( 0));
   if (!xs || xs.length !== 4 || fs <= 0) return;
   const width = xs[3] - xs[0], gap = xs[2] - xs[1];
   if (width < fs * 12 || gap <= 0 || gap > fs * 1.5 || xs[1] - xs[0] > width * 0.25 || xs[3] - xs[2] < width * 0.6) return;
@@ -8232,7 +9090,7 @@ function extendNestedShadedHeaders(clipGrids, lineGrids, horizontals, verticals,
   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 || !_optionalChain([c, 'access', _362 => _362.cells, 'optionalAccess', _363 => _363.length]) || c.cells.some((cell) => cell.filler || cell.rowSpan !== 1 || cell.colSpan !== 1)) continue;
+    if (!parent || c.rowYs.length !== 2 || c.colXs.length < 3 || !_optionalChain([c, 'access', _369 => _369.cells, 'optionalAccess', _370 => _370.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 && 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)));
@@ -8255,7 +9113,7 @@ function attachSideTabBlocks(tab, body, pageNum) {
     bbox: computeBBox(items, pageNum),
     style: dominantStyle(items)
   });
-  const prefix = ordered.filter((g) => !_optionalChain([caps, 'optionalAccess', _364 => _364.has, 'call', _365 => _365(g)])).map((g) => ({
+  const prefix = ordered.filter((g) => !_optionalChain([caps, 'optionalAccess', _371 => _371.has, 'call', _372 => _372(g)])).map((g) => ({
     type: "paragraph",
     text: g.text.trim(),
     pageNumber: pageNum,
@@ -8264,7 +9122,7 @@ function attachSideTabBlocks(tab, body, pageNum) {
   }));
   const groups = /* @__PURE__ */ new Map();
   for (const g of ordered) {
-    const cap = _optionalChain([caps, 'optionalAccess', _366 => _366.get, 'call', _367 => _367(g)]);
+    const cap = _optionalChain([caps, 'optionalAccess', _373 => _373.get, 'call', _374 => _374(g)]);
     if (cap) groups.set(cap, [..._nullishCoalesce(groups.get(cap), () => ( [])), g]);
   }
   for (const [cap, glyphs] of groups) {
@@ -8298,7 +9156,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   const filled = fillBlanks(items, horizontals, verticals);
   items = filled.items;
   horizontals = filled.horizontals;
-  const prevPage = _optionalChain([carry, 'optionalAccess', _368 => _368.page]) === pageNum - 1 ? carry.clip : void 0;
+  const prevPage = _optionalChain([carry, 'optionalAccess', _375 => _375.page]) === pageNum - 1 ? carry.clip : void 0;
   const clipResult = detectTables ? buildClipCellGrids(extracted.clipRects, horizontals, verticals, pageWidth, pageHeight, items.map((it) => ({ x: it.x + it.w / 2, y: it.y + it.h / 2 })), extracted.fillRects, prevPage) : { grids: [], containers: [], page: void 0 };
   if (carry) {
     carry.page = pageNum;
@@ -8555,14 +9413,14 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
         if (!assignedItems.has(textItems[ti])) usedItems.delete(owners[ti]);
       }
     }
-    if (unitLine.length > 0 && rebuiltUsed && !/^\s*\(\s*단위\s*[:：]/.test(_nullishCoalesce(_optionalChain([finalGrid, 'access', _369 => _369[0], 'optionalAccess', _370 => _370[0], 'optionalAccess', _371 => _371.text]), () => ( "")))) {
+    if (unitLine.length > 0 && rebuiltUsed && !/^\s*\(\s*단위\s*[:：]/.test(_nullishCoalesce(_optionalChain([finalGrid, 'access', _376 => _376[0], 'optionalAccess', _377 => _377[0], 'optionalAccess', _378 => _378.text]), () => ( "")))) {
       prependUnitRow(finalGrid, numCols, unitLine, usedItems);
       finalRows++;
     }
     if (!rebuiltUsed && attachUnitRow(items, grid, finalGrid, numCols, usedItems)) finalRows++;
     let semanticOneColumn = false;
     if (!grid.cells && !nestedAttached && numCols === 1 && numGridRows >= 2) {
-      const populatedRows = finalGrid.filter((row) => _optionalChain([row, 'access', _372 => _372[0], 'optionalAccess', _373 => _373.text, 'access', _374 => _374.trim, 'call', _375 => _375()]));
+      const populatedRows = finalGrid.filter((row) => _optionalChain([row, 'access', _379 => _379[0], 'optionalAccess', _380 => _380.text, 'access', _381 => _381.trim, 'call', _382 => _382()]));
       if (populatedRows.length >= 4) {
         const fontSizes = tableItems.map((item) => item.fontSize).filter((size) => size > 0).sort((a, b) => a - b);
         const medianFont = _nullishCoalesce(fontSizes[Math.floor(fontSizes.length / 2)], () => ( 0));
@@ -8658,7 +9516,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       height: grid.bbox.y2 - grid.bbox.y1
     };
     if (numRows === 1 && numCols === 1 && gridW < pageWidth * 0.35) {
-      const prose = _nullishCoalesce(_optionalChain([finalGrid, 'access', _376 => _376[0], 'optionalAccess', _377 => _377[0], 'optionalAccess', _378 => _378.text]), () => ( ""));
+      const prose = _nullishCoalesce(_optionalChain([finalGrid, 'access', _383 => _383[0], 'optionalAccess', _384 => _384[0], 'optionalAccess', _385 => _385.text]), () => ( ""));
       const besideLines = (side) => new Set(side.map((it) => Math.round(it.y / 3))).size;
       const rightLines = items.filter((it) => it.x >= grid.bbox.x2 + 3 && it.y >= grid.bbox.y1 && it.y <= grid.bbox.y2);
       const leftLines = items.filter((it) => it.x + it.w <= grid.bbox.x1 - 3 && it.y >= grid.bbox.y1 && it.y <= grid.bbox.y2);
@@ -8677,8 +9535,8 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       }
     }
     if (!grid.cells && !nestedAttached && shouldDemoteTable(irTable)) {
-      const paragraphs = numRows === 1 && numCols === 1 ? _optionalChain([irTable, 'access', _379 => _379.cells, 'access', _380 => _380[0], 'optionalAccess', _381 => _381[0], 'optionalAccess', _382 => _382.blocks]) : void 0;
-      if (_optionalChain([paragraphs, 'optionalAccess', _383 => _383.length])) {
+      const paragraphs = numRows === 1 && numCols === 1 ? _optionalChain([irTable, 'access', _386 => _386.cells, 'access', _387 => _387[0], 'optionalAccess', _388 => _388[0], 'optionalAccess', _389 => _389.blocks]) : void 0;
+      if (_optionalChain([paragraphs, 'optionalAccess', _390 => _390.length])) {
         blocks.push(...paragraphs);
         frameParagraphUnits.push(paragraphs);
         recordFrameReadingUnit(paragraphs, tableBbox);
@@ -8705,23 +9563,27 @@ 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;
       const overlapX = (x) => Math.min(x.x + x.width, b.x + b.width) - Math.max(x.x, b.x);
-      return !blocks.some((x) => x.bbox && x.bbox.y >= b.y - 2 && x.bbox.y + x.bbox.height <= b.y + b.height + 2 && (x.type === "paragraph" ? (_nullishCoalesce(_optionalChain([x, 'access', _384 => _384.text, 'optionalAccess', _385 => _385.match, 'call', _386 => _386(/\p{L}/gu), 'optionalAccess', _387 => _387.length]), () => ( 0))) >= 10 && overlapX(x.bbox) >= 0.8 * b.width : x.type === "table" && !ocrPage && _optionalChain([x, 'access', _388 => _388.table, 'optionalAccess', _389 => _389.cols]) === cr.table.cols && overlapX(x.bbox) >= 0.5 * Math.min(x.bbox.width, b.width)));
+      return !blocks.some((x) => x.bbox && x.bbox.y >= b.y - 2 && x.bbox.y + x.bbox.height <= b.y + b.height + 2 && (x.type === "paragraph" ? (_nullishCoalesce(_optionalChain([x, 'access', _391 => _391.text, 'optionalAccess', _392 => _392.match, 'call', _393 => _393(/\p{L}/gu), 'optionalAccess', _394 => _394.length]), () => ( 0))) >= 10 && overlapX(x.bbox) >= 0.8 * b.width : x.type === "table" && !ocrPage && _optionalChain([x, 'access', _395 => _395.table, 'optionalAccess', _396 => _396.cols]) === cr.table.cols && overlapX(x.bbox) >= 0.5 * Math.min(x.bbox.width, b.width)));
     });
     if (clusterResults.length > 0) {
       const ciToIdx = /* @__PURE__ */ new Map();
@@ -8758,7 +9620,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
         groupSizes.push(1);
       }
       const allY = remaining.map((i) => i.y);
-      const pageH = _chunk2JDVPQ33cjs.safeMax.call(void 0, allY) - _chunk2JDVPQ33cjs.safeMin.call(void 0, allY);
+      const pageH = _chunkC3BOYTY5cjs.safeMax.call(void 0, allY) - _chunkC3BOYTY5cjs.safeMin.call(void 0, allY);
       const gapThreshold = Math.max(15, pageH * 0.03);
       const sides = frameColumnTextBands(remaining, spanning, gx);
       const textBlocks = [];
@@ -8774,7 +9636,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       finalTextBlocks.push(...detectListBlocks(textBlocks));
     } else {
       const allY = remaining.map((i) => i.y);
-      const pageH = _chunk2JDVPQ33cjs.safeMax.call(void 0, allY) - _chunk2JDVPQ33cjs.safeMin.call(void 0, allY);
+      const pageH = _chunkC3BOYTY5cjs.safeMax.call(void 0, allY) - _chunkC3BOYTY5cjs.safeMin.call(void 0, allY);
       const gapThreshold = Math.max(15, pageH * 0.03);
       const groups = xyCutOrder(remaining, gapThreshold);
       const textBlocks = [];
@@ -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));
@@ -9102,7 +9968,7 @@ function extractPageBlocksFallback(items, pageNum, fullPage = false, detectTable
       blocks.push(...columnTextToBlocks(tableText, pageNum, bbox, dominantStyle(items)));
     } else {
       const allY = items.map((i) => i.y);
-      const pageHeight = _chunk2JDVPQ33cjs.safeMax.call(void 0, allY) - _chunk2JDVPQ33cjs.safeMin.call(void 0, allY);
+      const pageHeight = _chunkC3BOYTY5cjs.safeMax.call(void 0, allY) - _chunkC3BOYTY5cjs.safeMin.call(void 0, allY);
       const gapThreshold = Math.max(15, pageHeight * 0.03);
       const orderedGroups = proseCutX !== null ? splitTwoColumnProse(items, proseCutX) : xyCutOrder(items, gapThreshold, 0, void 0, minGap);
       for (const group of orderedGroups) {
@@ -9134,19 +10000,19 @@ function mergeOcrImageRegions(blocks, page, regions, ocrBlocks) {
       const overlapH = Math.max(0, Math.min(b.y + b.height, region.y2) - Math.max(b.y, region.y1));
       return overlapW * overlapH >= b.width * b.height * 0.8;
     });
-    const labels = candidates.filter((b) => b.type === "paragraph" && b.bbox.height <= 24 && (_nullishCoalesce(_optionalChain([b, 'access', _390 => _390.text, 'optionalAccess', _391 => _391.match, 'call', _392 => _392(/[\p{L}\p{N}]/gu), 'optionalAccess', _393 => _393.length]), () => ( 0))) >= 2);
+    const labels = candidates.filter((b) => b.type === "paragraph" && b.bbox.height <= 24 && (_nullishCoalesce(_optionalChain([b, 'access', _397 => _397.text, 'optionalAccess', _398 => _398.match, 'call', _399 => _399(/[\p{L}\p{N}]/gu), 'optionalAccess', _400 => _400.length]), () => ( 0))) >= 2);
     const axisFragments = rotatedAxisFragments(candidates);
     const accepted = candidates.filter((b) => {
-      if (b.type === "paragraph") return (_nullishCoalesce(_optionalChain([b, 'access', _394 => _394.text, 'optionalAccess', _395 => _395.match, 'call', _396 => _396(/[\p{L}\p{N}]/gu), 'optionalAccess', _397 => _397.length]), () => ( 0))) >= 2 || !axisFragments.has(b) && (supportedDiagramLabel(b, labels, region) || axisTick(b, candidates));
+      if (b.type === "paragraph") return (_nullishCoalesce(_optionalChain([b, 'access', _401 => _401.text, 'optionalAccess', _402 => _402.match, 'call', _403 => _403(/[\p{L}\p{N}]/gu), 'optionalAccess', _404 => _404.length]), () => ( 0))) >= 2 || !axisFragments.has(b) && (supportedDiagramLabel(b, labels, region) || axisTick(b, candidates));
       const t = b.table;
       if (b.type !== "table" || !t || UNRULED_REGION_TABLES.has(b)) return false;
       const lone = t.cells.filter((row) => row.filter((c) => c.text.trim()).length === 1 && row.some((c) => c.colSpan === t.cols)).length;
       if (t.rows >= 2 && lone * 2 >= t.rows) return false;
       if (t.rows === 1 && t.cols === 1) {
-        const text = _nullishCoalesce(_optionalChain([t, 'access', _398 => _398.cells, 'access', _399 => _399[0], 'optionalAccess', _400 => _400[0], 'optionalAccess', _401 => _401.text]), () => ( ""));
-        return (_nullishCoalesce(_optionalChain([text, 'access', _402 => _402.match, 'call', _403 => _403(/\n/g), 'optionalAccess', _404 => _404.length]), () => ( 0))) >= 5 && (_nullishCoalesce(_optionalChain([text, 'access', _405 => _405.match, 'call', _406 => _406(/\d/g), 'optionalAccess', _407 => _407.length]), () => ( 0))) >= text.length * 0.25;
+        const text = _nullishCoalesce(_optionalChain([t, 'access', _405 => _405.cells, 'access', _406 => _406[0], 'optionalAccess', _407 => _407[0], 'optionalAccess', _408 => _408.text]), () => ( ""));
+        return (_nullishCoalesce(_optionalChain([text, 'access', _409 => _409.match, 'call', _410 => _410(/\n/g), 'optionalAccess', _411 => _411.length]), () => ( 0))) >= 5 && (_nullishCoalesce(_optionalChain([text, 'access', _412 => _412.match, 'call', _413 => _413(/\d/g), 'optionalAccess', _414 => _414.length]), () => ( 0))) >= text.length * 0.25;
       }
-      const headerLabels = _nullishCoalesce(_optionalChain([t, 'access', _408 => _408.cells, 'access', _409 => _409[0], 'optionalAccess', _410 => _410.filter, 'call', _411 => _411((c) => c.text.replace(/[^A-Za-z가-힣]/g, "").length >= 2), 'access', _412 => _412.length]), () => ( 0));
+      const headerLabels = _nullishCoalesce(_optionalChain([t, 'access', _415 => _415.cells, 'access', _416 => _416[0], 'optionalAccess', _417 => _417.filter, 'call', _418 => _418((c) => c.text.replace(/[^A-Za-z가-힣]/g, "").length >= 2), 'access', _419 => _419.length]), () => ( 0));
       return t.rows >= 2 && t.cols >= 2 && headerLabels >= t.cols * 0.75 && t.cells.slice(1).some((row) => row.filter((c) => c.text.trim()).length >= 2);
     });
     const selected = candidates.flatMap((b) => accepted.includes(b) ? [b] : b.type === "table" && b.table ? rowParagraphs(b).filter((p) => /[\p{L}\p{N}]{2}/u.test(_nullishCoalesce(p.text, () => ( "")))) : []);
@@ -9163,14 +10029,14 @@ function mergeOcrImageRegions(blocks, page, regions, ocrBlocks) {
     for (const block of selected) {
       if (seen2.has(block)) continue;
       const frame = FRAME_READING_UNITS.get(block);
-      const source = _optionalChain([frame, 'optionalAccess', _413 => _413.blocks, 'access', _414 => _414.every, 'call', _415 => _415((member) => selectedSet.has(member))]) ? frame.blocks : [block];
+      const source = _optionalChain([frame, 'optionalAccess', _420 => _420.blocks, 'access', _421 => _421.every, 'call', _422 => _422((member) => selectedSet.has(member))]) ? frame.blocks : [block];
       source.forEach((member) => seen2.add(member));
       const available = source.filter((member) => !hasOriginal(member));
       const units = frame && available.length === source.length && source === frame.blocks ? [{ blocks: available, bbox: frame.bbox, atomic: true }] : available.map((member) => ({ blocks: [member], bbox: member.bbox, atomic: false }));
       for (const unit of units) {
         const b = unit.bbox;
         const index = blocks.findIndex((existing) => {
-          const e = _nullishCoalesce(_optionalChain([FRAME_READING_UNITS, 'access', _416 => _416.get, 'call', _417 => _417(existing), 'optionalAccess', _418 => _418.bbox]), () => ( existing.bbox));
+          const e = _nullishCoalesce(_optionalChain([FRAME_READING_UNITS, 'access', _423 => _423.get, 'call', _424 => _424(existing), 'optionalAccess', _425 => _425.bbox]), () => ( existing.bbox));
           if (existing.pageNumber !== page || !e) return false;
           const beside = e.y < region.y2 && e.y + e.height > region.y1 && e.x >= region.x2 - 1;
           if (placedHere.has(existing) && Math.abs(e.y + e.height / 2 - b.y - b.height / 2) <= Math.min(e.height, b.height) * 0.25) return e.x > b.x;
@@ -9188,16 +10054,16 @@ function mergeOcrImageRegions(blocks, page, regions, ocrBlocks) {
 }
 function axisTick(block, candidates) {
   const b = block.bbox;
-  if (!/^\d$/u.test(_nullishCoalesce(_optionalChain([block, 'access', _419 => _419.text, 'optionalAccess', _420 => _420.trim, 'call', _421 => _421()]), () => ( "")))) return false;
-  const numeric = candidates.filter((o) => o !== block && o.type === "paragraph" && o.bbox && /^[\d\s.,%+−-]+$/u.test(_nullishCoalesce(_optionalChain([o, 'access', _422 => _422.text, 'optionalAccess', _423 => _423.trim, 'call', _424 => _424()]), () => ( ""))) && /\d/u.test(_nullishCoalesce(o.text, () => ( ""))) && Math.max(o.bbox.height, b.height) <= Math.min(o.bbox.height, b.height) * 2);
+  if (!/^\d$/u.test(_nullishCoalesce(_optionalChain([block, 'access', _426 => _426.text, 'optionalAccess', _427 => _427.trim, 'call', _428 => _428()]), () => ( "")))) return false;
+  const numeric = candidates.filter((o) => o !== block && o.type === "paragraph" && o.bbox && /^[\d\s.,%+−-]+$/u.test(_nullishCoalesce(_optionalChain([o, 'access', _429 => _429.text, 'optionalAccess', _430 => _430.trim, 'call', _431 => _431()]), () => ( ""))) && /\d/u.test(_nullishCoalesce(o.text, () => ( ""))) && Math.max(o.bbox.height, b.height) <= Math.min(o.bbox.height, b.height) * 2);
   const cy = b.y + b.height / 2, right = b.x + b.width;
   const row = numeric.filter((o) => Math.abs(o.bbox.y + o.bbox.height / 2 - cy) <= Math.min(o.bbox.height, b.height) * 0.35);
   const column = numeric.filter((o) => Math.abs(o.bbox.x + o.bbox.width - right) <= Math.max(o.bbox.height, b.height) * 0.5);
   return row.length >= 2 || column.length >= 2;
 }
 function supportedDiagramLabel(block, labels, region) {
-  const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _425 => _425.text, 'optionalAccess', _426 => _426.trim, 'call', _427 => _427()]), () => ( ""));
-  if (!b || !/^[\p{L}\p{N}]$/u.test(text) || b.height < 4 || b.width < 1 || b.width > b.height * 2 || b.x < region.x1 || b.y < region.y1 || b.x + b.width > region.x2 || b.y + b.height > region.y2 || b.width * b.height > (region.x2 - region.x1) * (region.y2 - region.y1) * 5e-3 || labels.length < 3 || !labels.some((l) => /\p{L}{3}/u.test(_nullishCoalesce(l.text, () => ( "")))) || labels.filter((l) => !/\p{L}/u.test(_nullishCoalesce(l.text, () => ( ""))) && (_nullishCoalesce(_optionalChain([l, 'access', _428 => _428.text, 'optionalAccess', _429 => _429.match, 'call', _430 => _430(/\p{N}/gu), 'optionalAccess', _431 => _431.length]), () => ( 0))) >= 2).length < 2) return false;
+  const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _432 => _432.text, 'optionalAccess', _433 => _433.trim, 'call', _434 => _434()]), () => ( ""));
+  if (!b || !/^[\p{L}\p{N}]$/u.test(text) || b.height < 4 || b.width < 1 || b.width > b.height * 2 || b.x < region.x1 || b.y < region.y1 || b.x + b.width > region.x2 || b.y + b.height > region.y2 || b.width * b.height > (region.x2 - region.x1) * (region.y2 - region.y1) * 5e-3 || labels.length < 3 || !labels.some((l) => /\p{L}{3}/u.test(_nullishCoalesce(l.text, () => ( "")))) || labels.filter((l) => !/\p{L}/u.test(_nullishCoalesce(l.text, () => ( ""))) && (_nullishCoalesce(_optionalChain([l, 'access', _435 => _435.text, 'optionalAccess', _436 => _436.match, 'call', _437 => _437(/\p{N}/gu), 'optionalAccess', _438 => _438.length]), () => ( 0))) >= 2).length < 2) return false;
   let above = false, below = false;
   for (const label of labels) {
     const a = label.bbox, em = Math.max(b.height, a.height);
@@ -9212,7 +10078,7 @@ function rotatedAxisFragments(candidates) {
   const paragraphs = candidates.filter((b) => b.type === "paragraph" && b.bbox.height <= 24);
   const axes = [];
   for (const block of paragraphs) {
-    const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _432 => _432.text, 'optionalAccess', _433 => _433.trim, 'call', _434 => _434()]), () => ( ""));
+    const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _439 => _439.text, 'optionalAccess', _440 => _440.trim, 'call', _441 => _441()]), () => ( ""));
     if (!/^[\d\s.,%+−-]+$/u.test(text) || !/\d/u.test(text) || b.width > b.height * 6) continue;
     const axis = axes.find((a) => Math.abs(a[0].bbox.x + a[0].bbox.width - b.x - b.width) <= Math.max(a[0].bbox.height, b.height) * 0.5);
     if (axis) axis.push(block);
@@ -9229,8 +10095,8 @@ function rotatedAxisFragments(candidates) {
     const em = Math.max(...axis.map((a) => a.bbox.height)), right = axis[0].bbox.x + axis[0].bbox.width;
     if (top - bottom < em * 6) continue;
     const left = paragraphs.filter((block) => {
-      const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _435 => _435.text, 'optionalAccess', _436 => _436.trim, 'call', _437 => _437()]), () => ( ""));
-      return /\p{Script=Latin}/u.test(text) && (_nullishCoalesce(_optionalChain([text, 'access', _438 => _438.match, 'call', _439 => _439(/[\p{L}\p{N}]/gu), 'optionalAccess', _440 => _440.length]), () => ( 0))) <= 3 && b.width <= b.height * 3 && b.x + b.width >= right - em * 6 && b.x + b.width <= right - Math.max(em, b.height) && b.y >= bottom && b.y + b.height <= top;
+      const b = block.bbox, text = _nullishCoalesce(_optionalChain([block, 'access', _442 => _442.text, 'optionalAccess', _443 => _443.trim, 'call', _444 => _444()]), () => ( ""));
+      return /\p{Script=Latin}/u.test(text) && (_nullishCoalesce(_optionalChain([text, 'access', _445 => _445.match, 'call', _446 => _446(/[\p{L}\p{N}]/gu), 'optionalAccess', _447 => _447.length]), () => ( 0))) <= 3 && b.width <= b.height * 3 && b.x + b.width >= right - em * 6 && b.x + b.width <= right - Math.max(em, b.height) && b.y >= bottom && b.y + b.height <= top;
     });
     const stack = left.filter((a) => left.some((b) => {
       if (a === b || !aligned(a, b)) return false;
@@ -9240,7 +10106,7 @@ function rotatedAxisFragments(candidates) {
     if (stack.length < 2) continue;
     for (const block of paragraphs) {
       const b = block.bbox;
-      if (b.y >= bottom && b.y + b.height <= top && b.x + b.width >= right - em * 6 && b.x + b.width <= right - Math.max(em, b.height) && /^[\p{L}\p{N}]$/u.test(_nullishCoalesce(_optionalChain([block, 'access', _441 => _441.text, 'optionalAccess', _442 => _442.trim, 'call', _443 => _443()]), () => ( ""))) && stack.some((s) => aligned(s, block))) fragments.add(block);
+      if (b.y >= bottom && b.y + b.height <= top && b.x + b.width >= right - em * 6 && b.x + b.width <= right - Math.max(em, b.height) && /^[\p{L}\p{N}]$/u.test(_nullishCoalesce(_optionalChain([block, 'access', _448 => _448.text, 'optionalAccess', _449 => _449.trim, 'call', _450 => _450()]), () => ( ""))) && stack.some((s) => aligned(s, block))) fragments.add(block);
     }
   }
   return fragments;
@@ -9317,5 +10183,28 @@ function rowParagraphs(block) {
 
 
 
-exports.DEFAULT_OCR_MODELS = DEFAULT_OCR_MODELS; exports.resolveOcrModels = resolveOcrModels; exports.ocrSelectionKey = ocrSelectionKey; exports.ocrSourcePath = ocrSourcePath; exports.ensureOcrModelsFor = ensureOcrModelsFor; exports.ocrModelsCached = ocrModelsCached; exports.parseCharacterDict = parseCharacterDict; exports.extractLines = extractLines; exports.extractImageRegions = extractImageRegions; exports.NO_EDGES = NO_EDGES; exports.hasOpenCellSeam = hasOpenCellSeam; exports.joinCellEdges = joinCellEdges; exports.filterHiddenText = filterHiddenText; exports.collapseEvenSpacing = collapseEvenSpacing; exports.computeBBox = computeBBox; exports.dominantStyle = dominantStyle; exports.normalizeItems = normalizeItems; exports.groupByY = groupByY; exports.mergeLineSimple = mergeLineSimple; exports.WrapLexicon = WrapLexicon; exports.startsNewItem = startsNewItem; exports.wrapJoiner = wrapJoiner; exports.joinPageBreakWraps = joinPageBreakWraps; exports.splitPageBreakWraps = splitPageBreakWraps; exports.latinSoftWrap = latinSoftWrap; exports.TOC_BLOCKS = TOC_BLOCKS; exports.computeMedianFontSizeFromFreq = computeMedianFontSizeFromFreq; exports.detectHeadings = detectHeadings; exports.mergeStackedHeadingLines = mergeStackedHeadingLines; exports.detectTypographyHeadings = detectTypographyHeadings; exports.detectDocumentStyleHeadings = detectDocumentStyleHeadings; exports.detectSiblingStyleHeadings = detectSiblingStyleHeadings; exports.detectRepeatedPageLabels = detectRepeatedPageLabels; exports.detectPageLeadHeadings = detectPageLeadHeadings; exports.refineDocumentStyleHeadings = refineDocumentStyleHeadings; exports.detectMarkerHeadings = detectMarkerHeadings; exports.detectTableCaptions = detectTableCaptions; exports.detectKoreanListBlocks = detectKoreanListBlocks; exports.removeHeaderFooterBlocks = removeHeaderFooterBlocks; exports.runningLinePatterns = runningLinePatterns; exports.stripAbsorbedRunningLines = stripAbsorbedRunningLines; exports.CLIP_TABLES = CLIP_TABLES; exports.FRAME_TITLE_BLOCKS = FRAME_TITLE_BLOCKS; exports.TABLE_COLXS = TABLE_COLXS; exports.TABLE_ROWYS = TABLE_ROWYS; exports.TABLE_TAIL = TABLE_TAIL; exports.PART_COLXS = PART_COLXS; exports.EMPTY_PARTS = EMPTY_PARTS; exports.IMAGE_CELLS = IMAGE_CELLS; exports.FILLER_CELLS = FILLER_CELLS; exports.CONT_PARTS = CONT_PARTS; exports.CELL_LINES = CELL_LINES; exports.ROW_RULES = ROW_RULES; exports.trimTrailingEmptyTableCols = trimTrailingEmptyTableCols; exports.restoreImageBullets = restoreImageBullets; exports.detectRightArrowRegions = detectRightArrowRegions; exports.removeSideTabs = removeSideTabs; exports.extractPageBlocksWithLines = extractPageBlocksWithLines; exports.UNRULED_REGION_TABLES = UNRULED_REGION_TABLES; exports.mergeOcrImageRegions = mergeOcrImageRegions;
-//# sourceMappingURL=chunk-JIU7E7Z6.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_OCR_MODELS = DEFAULT_OCR_MODELS; exports.resolveOcrModels = resolveOcrModels; exports.ocrSelectionKey = ocrSelectionKey; exports.ocrSourcePath = ocrSourcePath; exports.ensureOcrModelsFor = ensureOcrModelsFor; exports.ocrModelsCached = ocrModelsCached; exports.parseCharacterDict = parseCharacterDict; exports.grayCrop = grayCrop; exports.inkStats = inkStats; exports.splitRowBands = splitRowBands; exports.leadingTriangle = leadingTriangle; exports.leaderRuns = leaderRuns; exports.inkBounds = inkBounds; exports.bracketFeatures = bracketFeatures; exports.romanStems = romanStems; exports.circledAt = circledAt; exports.quoteHead = quoteHead; exports.edgeTrim = edgeTrim; exports.tallInkCount = tallInkCount; exports.gapGlyphs = gapGlyphs; exports.ringBullet = ringBullet; exports.dashRatio = dashRatio; exports.discAt = discAt; exports.serifOne = serifOne; exports.starRun = starRun; exports.bracketShape = bracketShape; exports.leadingBullet = leadingBullet; exports.rememberOcrTextGaps = rememberOcrTextGaps; exports.copyOcrTextGaps = copyOcrTextGaps; exports.findOcrTextGaps = findOcrTextGaps; exports.extractLines = extractLines; exports.extractImageRegions = extractImageRegions; exports.NO_EDGES = NO_EDGES; exports.hasOpenCellSeam = hasOpenCellSeam; exports.joinCellEdges = joinCellEdges; exports.filterHiddenText = filterHiddenText; exports.collapseEvenSpacing = collapseEvenSpacing; exports.computeBBox = computeBBox; exports.dominantStyle = dominantStyle; exports.normalizeItems = normalizeItems; exports.groupByY = groupByY; exports.mergeLineSimple = mergeLineSimple; exports.WrapLexicon = WrapLexicon; exports.startsNewItem = startsNewItem; exports.wrapJoiner = wrapJoiner; exports.joinPageBreakWraps = joinPageBreakWraps; exports.splitPageBreakWraps = splitPageBreakWraps; exports.latinSoftWrap = latinSoftWrap; exports.TOC_BLOCKS = TOC_BLOCKS; exports.computeMedianFontSizeFromFreq = computeMedianFontSizeFromFreq; exports.detectHeadings = detectHeadings; exports.mergeStackedHeadingLines = mergeStackedHeadingLines; exports.detectTypographyHeadings = detectTypographyHeadings; exports.detectDocumentStyleHeadings = detectDocumentStyleHeadings; exports.detectSiblingStyleHeadings = detectSiblingStyleHeadings; exports.detectRepeatedPageLabels = detectRepeatedPageLabels; exports.detectPageLeadHeadings = detectPageLeadHeadings; exports.refineDocumentStyleHeadings = refineDocumentStyleHeadings; exports.detectMarkerHeadings = detectMarkerHeadings; exports.detectTableCaptions = detectTableCaptions; exports.detectKoreanListBlocks = detectKoreanListBlocks; exports.removeHeaderFooterBlocks = removeHeaderFooterBlocks; exports.runningLinePatterns = runningLinePatterns; exports.stripAbsorbedRunningLines = stripAbsorbedRunningLines; exports.CLIP_TABLES = CLIP_TABLES; exports.FRAME_TITLE_BLOCKS = FRAME_TITLE_BLOCKS; exports.TABLE_COLXS = TABLE_COLXS; exports.TABLE_ROWYS = TABLE_ROWYS; exports.TABLE_TAIL = TABLE_TAIL; exports.PART_COLXS = PART_COLXS; exports.EMPTY_PARTS = EMPTY_PARTS; exports.IMAGE_CELLS = IMAGE_CELLS; exports.FILLER_CELLS = FILLER_CELLS; exports.CONT_PARTS = CONT_PARTS; exports.CELL_LINES = CELL_LINES; exports.ROW_RULES = ROW_RULES; exports.trimTrailingEmptyTableCols = trimTrailingEmptyTableCols; exports.restoreImageBullets = restoreImageBullets; exports.detectRightArrowRegions = detectRightArrowRegions; exports.removeSideTabs = removeSideTabs; exports.extractPageBlocksWithLines = extractPageBlocksWithLines; exports.UNRULED_REGION_TABLES = UNRULED_REGION_TABLES; exports.mergeOcrImageRegions = mergeOcrImageRegions;
+//# sourceMappingURL=chunk-73MRAQXA.cjs.map