kordoc 4.14.3 → 4.14.4

package/dist/{chunk-VJHAUMCF.js → chunk-MG6DJEX4.js}

@@ -6,18 +6,28 @@ import {
   ensureOcrModels,
   getOcrModelsDir,
   parseCharacterDict
-} from "./chunk-D6KQKMU3.js";
+} from "./chunk-7SE4EZ45.js";
 import {
   extractPageBlocksWithLines
-} from "./chunk-A275ZQLX.js";
+} from "./chunk-YAVHVFRY.js";
 
 // src/ocr/ruling-lines.ts
-var INK_LUMA_MAX = 190;
+var INK_LUMA_MAX = 205;
 var MIN_LINE_LENGTH_PT = 20;
 var MAX_LINE_WIDTH_PT = 2.5;
 var GAP_TOL_PX = 2;
 var BAND_OVERLAP_RATIO = 0.5;
 var SURROUND_INK_RATIO = 0.35;
+var DOT_MAX_GAP_PT = 1.3;
+var DOT_MAX_DASH_PT = 4;
+var DOT_MAX_PERIOD_PT = 2.2;
+var DOT_MIN_COUNT = 8;
+var DOT_TOUCH_PT = 1.5;
+var FILL_DELTA = 10;
+var FILL_MIN_LENGTH_PT = 10;
+var FILL_MIN_DEPTH_PT = 4;
+var FILL_FLAT_TOL = 12;
+var FILL_FLAT_RATIO = 0.8;
 function detectRulingLines(rgba, width, height, scale) {
   const minLenPx = Math.round(MIN_LINE_LENGTH_PT * scale);
   const maxThickPx = Math.max(1, Math.floor(MAX_LINE_WIDTH_PT * scale));
@@ -26,11 +36,164 @@ function detectRulingLines(rgba, width, height, scale) {
     const luma = rgba[i] * 77 + rgba[i + 1] * 150 + rgba[i + 2] * 29 >> 8;
     if (luma <= INK_LUMA_MAX && rgba[i + 3] >= 128) ink[p] = 1;
   }
-  const horizontals = detectBands(ink, width, height, minLenPx, maxThickPx, false);
-  const verticals = detectBands(ink, width, height, minLenPx, maxThickPx, true);
+  const solid = (at, line, span) => solidRuns(at, line, span, minLenPx);
+  const dot = {
+    maxGap: Math.max(2, Math.round(DOT_MAX_GAP_PT * scale)),
+    maxDash: Math.max(2, Math.round(DOT_MAX_DASH_PT * scale)),
+    maxPeriod: DOT_MAX_PERIOD_PT * scale
+  };
+  const dotted = (at, line, span) => dottedRuns(at, line, span, minLenPx, dot.maxGap, dot.maxDash, dot.maxPeriod);
+  const horizontals = detectBands(ink, width, height, maxThickPx, false, solid);
+  const verticals = detectBands(ink, width, height, maxThickPx, true, solid);
+  const dotH = detectBands(ink, width, height, maxThickPx, false, dotted);
+  const dotV = detectBands(ink, width, height, maxThickPx, true, dotted);
+  const tol = Math.max(2, Math.round(DOT_TOUCH_PT * scale));
+  const allH = [...horizontals, ...dotH], allV = [...verticals, ...dotV];
+  const touchesV = (a) => allV.some((p) => p.x1 >= a.x1 - tol && p.x1 <= a.x2 + tol && a.y1 >= p.y1 - tol && a.y1 <= p.y2 + tol);
+  const touchesH = (a) => allH.some((p) => p.y1 >= a.y1 - tol && p.y1 <= a.y2 + tol && a.x1 >= p.x1 - tol && a.x1 <= p.x2 + tol);
+  horizontals.push(...dotH.filter(touchesV));
+  verticals.push(...dotV.filter(touchesH));
+  const inkV = [...verticals];
+  const ruleH = horizontals.filter((p) => inkV.some((v) => v.x1 >= p.x1 - tol && v.x1 <= p.x2 + tol && p.y1 >= v.y1 - tol && p.y1 <= v.y2 + tol));
+  const fill = fillEdges(rgba, width, height, scale);
+  const fillH = fill.horizontals.filter((a) => ruleH.some((p) => Math.abs(p.x1 - a.x1) <= tol && Math.abs(p.x2 - a.x2) <= tol));
+  horizontals.push(...fillH);
+  const edgeH = [...ruleH, ...fillH];
+  verticals.push(...fill.verticals.filter((a) => inkV.some((p) => Math.abs(p.x1 - a.x1) <= tol && p.y1 <= a.y2 + tol && p.y2 >= a.y1 - tol) || edgeH.some((p) => (Math.abs(p.x1 - a.x1) <= tol || Math.abs(p.x2 - a.x1) <= tol) && p.y1 >= a.y1 - tol && p.y1 <= a.y2 + tol)));
   return { horizontals, verticals };
 }
-function detectBands(ink, width, height, minLenPx, maxThickPx, transpose) {
+function fillEdges(rgba, width, height, scale) {
+  const k = Math.max(1, Math.round(scale));
+  const w = Math.floor(width / k), h = Math.floor(height / k), n = w * h;
+  const luma = new Uint8Array(n);
+  const hist = new Uint32Array(256);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      let mx = 0;
+      for (let by = 0; by < k; by++) {
+        let i = ((y * k + by) * width + x * k) * 4;
+        for (let bx = 0; bx < k; bx++, i += 4) {
+          const l = rgba[i] * 77 + rgba[i + 1] * 150 + rgba[i + 2] * 29 >> 8;
+          if (l > mx) mx = l;
+        }
+      }
+      luma[y * w + x] = mx;
+      hist[mx]++;
+    }
+  }
+  let bg = 255;
+  for (let v = 0; v < 256; v++) if (hist[v] > hist[bg]) bg = v;
+  const tint = new Uint8Array(n);
+  for (let p = 0; p < n; p++) if (luma[p] < bg - FILL_DELTA) tint[p] = 1;
+  const depth = Math.max(2, Math.round(FILL_MIN_DEPTH_PT * scale / k));
+  const minLen = Math.round(FILL_MIN_LENGTH_PT * scale / k);
+  const solid = (at, line, span) => solidRuns(at, line, span, minLen);
+  const run = new Uint16Array(n);
+  const mask = new Uint8Array(n);
+  const out = { horizontals: [], verticals: [] };
+  for (const [dx, dy] of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
+    const step = dy * w + dx;
+    const ys = dy > 0 ? [h - 1, -1, -1] : [0, h, 1];
+    const xs = dx > 0 ? [w - 1, -1, -1] : [0, w, 1];
+    for (let y = ys[0]; y !== ys[1]; y += ys[2]) {
+      for (let x = xs[0]; x !== xs[1]; x += xs[2]) {
+        const p = y * w + x;
+        const nx = x + dx, ny = y + dy;
+        run[p] = tint[p] ? nx >= 0 && nx < w && ny >= 0 && ny < h ? Math.min(65535, run[p + step] + 1) : 1 : 0;
+      }
+    }
+    mask.fill(0);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const p = y * w + x;
+        if (run[p] < depth) continue;
+        const ox = x - dx, oy = y - dy;
+        if (ox < 0 || oy < 0 || ox >= w || oy >= h || !tint[p - step]) mask[p] = 1;
+      }
+    }
+    const vertical = dx !== 0;
+    const flat = (s) => {
+      const d = depth >> 1;
+      const vals = [];
+      if (vertical) {
+        const x = Math.round(s.x1) + dx * d;
+        for (let y = Math.round(s.y1); y <= s.y2; y++) if (x >= 0 && x < w) vals.push(luma[y * w + x]);
+      } else {
+        const y = Math.round(s.y1) + dy * d;
+        for (let x = Math.round(s.x1); x <= s.x2; x++) if (y >= 0 && y < h) vals.push(luma[y * w + x]);
+      }
+      if (!vals.length) return false;
+      const med = [...vals].sort((a, b) => a - b)[vals.length >> 1];
+      return vals.filter((v) => Math.abs(v - med) <= FILL_FLAT_TOL).length >= vals.length * FILL_FLAT_RATIO;
+    };
+    for (const s of detectBands(mask, w, h, 1, vertical, solid)) {
+      if (!flat(s)) continue;
+      const c = (v) => v * k + (k - 1) / 2;
+      (vertical ? out.verticals : out.horizontals).push({ x1: c(s.x1), y1: c(s.y1), x2: c(s.x2), y2: c(s.y2), thicknessPx: 1 });
+    }
+  }
+  return out;
+}
+function solidRuns(at, line, span, minLenPx) {
+  const runs = [];
+  let runStart = -1;
+  let gap = 0;
+  for (let pos = 0; pos <= span; pos++) {
+    const on = pos < span && at(line, pos) === 1;
+    if (on) {
+      if (runStart < 0) runStart = pos;
+      gap = 0;
+    } else if (runStart >= 0) {
+      if (++gap > GAP_TOL_PX || pos >= span) {
+        const hi = pos - gap;
+        if (hi - runStart + 1 >= minLenPx) runs.push({ lo: runStart, hi });
+        runStart = -1;
+        gap = 0;
+      }
+    }
+  }
+  return runs;
+}
+function dottedRuns(at, line, span, minLenPx, maxGap, maxDash, maxPeriod) {
+  const runs = [];
+  const chain = [];
+  const median = (xs) => xs.sort((a, b) => a - b)[xs.length >> 1];
+  const flush = () => {
+    const cnt = chain.length >> 1;
+    if (cnt >= DOT_MIN_COUNT && chain[chain.length - 1] - chain[0] + 1 >= minLenPx) {
+      const periods = [], dashes = [], gaps = [];
+      for (let k = 0; k < cnt; k++) {
+        dashes.push(chain[2 * k + 1] - chain[2 * k] + 1);
+        if (k) {
+          periods.push(chain[2 * k] - chain[2 * k - 2]);
+          gaps.push(chain[2 * k] - chain[2 * k - 1] - 1);
+        }
+      }
+      if (median(periods) <= maxPeriod || median(dashes) >= 1.5 * median(gaps)) runs.push({ lo: chain[0], hi: chain[chain.length - 1] });
+    }
+    chain.length = 0;
+  };
+  let s = -1;
+  for (let pos = 0; pos <= span; pos++) {
+    const on = pos < span && at(line, pos) === 1;
+    if (on) {
+      if (s < 0) s = pos;
+      continue;
+    }
+    if (s < 0) continue;
+    const lo = s, hi = pos - 1;
+    s = -1;
+    if (hi - lo + 1 > maxDash) {
+      flush();
+      continue;
+    }
+    if (chain.length && lo - chain[chain.length - 1] - 1 > maxGap) flush();
+    chain.push(lo, hi);
+  }
+  flush();
+  return runs;
+}
+function detectBands(ink, width, height, maxThickPx, transpose, readRuns) {
   const lines = transpose ? width : height;
   const span = transpose ? height : width;
   const at = transpose ? (line, pos) => ink[pos * width + line] : (line, pos) => ink[line * width + pos];
@@ -55,23 +218,7 @@ function detectBands(ink, width, height, minLenPx, maxThickPx, transpose) {
     );
   };
   for (let line = 0; line < lines; line++) {
-    const runs = [];
-    let runStart = -1;
-    let gap = 0;
-    for (let pos = 0; pos <= span; pos++) {
-      const on = pos < span && at(line, pos) === 1;
-      if (on) {
-        if (runStart < 0) runStart = pos;
-        gap = 0;
-      } else if (runStart >= 0) {
-        if (++gap > GAP_TOL_PX || pos >= span) {
-          const hi = pos - gap;
-          if (hi - runStart + 1 >= minLenPx) runs.push({ lo: runStart, hi });
-          runStart = -1;
-          gap = 0;
-        }
-      }
-    }
+    const runs = readRuns(at, line, span);
     const next = [];
     const used = /* @__PURE__ */ new Set();
     for (const band of open) {
@@ -257,6 +404,113 @@ function splitRowBands(gray, w, h, ink, minBandRatio) {
     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);
@@ -294,6 +548,7 @@ function restoreSymbols(text) {
   s = s.replace(/^([Oo])(\s?)(?=[\uac00-\ud7a3])/, "\u25CB$2");
   s = s.replace(/(?<![A-Za-z])O{2,}(?![A-Za-z])/g, (m, i) => /[\uac00-\ud7a3]$/.test(s.slice(Math.max(0, i - 2), i).trimEnd()) || /^\s?[\uac00-\ud7a3]/.test(s.slice(i + m.length)) ? "\u25CB".repeat(m.length) : m);
   s = s.replace(/[\u2206\u0394]/g, "\u25B3");
+  s = s.replace(/\(cid:\d*\)/g, "");
   return smartQuotes(joinDigitGroups(s));
 }
 function joinDigitGroups(s) {
@@ -329,6 +584,53 @@ function smartQuotes(s) {
 function isDotFragment(text) {
   return /^[\s.\u00b7\u2024\u2025\u2026\u2027\u2219\u22c5\u318d]+$/.test(text);
 }
+function joinLeaderItems(items, ends) {
+  const gone = /* @__PURE__ */ new Set();
+  const sameLine = (a, b) => Math.abs(a.y + a.h / 2 - (b.y + b.h / 2)) <= Math.max(a.h, b.h) / 2;
+  const merge = (left, right) => {
+    const x2 = Math.max(left.x + left.w, right.x + right.w), y2 = Math.max(left.y + left.h, right.y + right.h);
+    left.text = left.text.replace(/\s*\u2026$/, "") + " \u2026 " + right.text.replace(/^\u2026\s*/, "");
+    left.x = Math.min(left.x, right.x);
+    left.y = Math.min(left.y, right.y);
+    left.w = x2 - left.x;
+    left.h = y2 - left.y;
+    left.confidence = Math.min(left.confidence, right.confidence);
+    gone.add(right);
+  };
+  const neighbor = (it, toLeft) => {
+    let best = null;
+    for (const o of items) {
+      if (o === it || gone.has(o) || !sameLine(o, it)) continue;
+      if (toLeft ? o.x + o.w > it.x + 2 : o.x < it.x + it.w - 2) continue;
+      if (!best || (toLeft ? o.x + o.w > best.x + best.w : o.x < best.x)) best = o;
+    }
+    return best;
+  };
+  for (const it of [...items].sort((a, b) => b.x - a.x)) {
+    if (gone.has(it) || !ends.get(it)?.lead) continue;
+    const left = neighbor(it, true);
+    if (left) merge(left, it);
+  }
+  for (const it of [...items].sort((a, b) => a.x - b.x)) {
+    if (gone.has(it) || !ends.get(it)?.trail) continue;
+    const right = neighbor(it, false);
+    if (right) merge(it, right);
+  }
+  const toc = items.filter((it) => !gone.has(it) && /\s\u2026\s\d{1,4}$/.test(it.text));
+  if (toc.length >= 2) {
+    for (const it of items) {
+      if (gone.has(it) || toc.includes(it) || !/^[\s.:\u00b7\u2026]*\d{1,4}$/.test(it.text)) continue;
+      const x2 = it.x + it.w;
+      if (toc.filter((t) => Math.abs(t.x + t.w - x2) <= Math.max(t.h, it.h)).length < 2) continue;
+      const left = neighbor(it, true);
+      if (!left || toc.includes(left)) continue;
+      left.text = left.text.replace(/[\s.:\u00b7\u2026]+$/, "");
+      it.text = it.text.replace(/^[\s.:\u00b7\u2026]+/, "");
+      merge(left, it);
+    }
+  }
+  return items.filter((it) => !gone.has(it));
+}
 function restoreBulletItems(items) {
   for (const it of items) {
     if (it.text !== "O" && it.text !== "o") continue;
@@ -419,7 +721,8 @@ var DEFAULT_OCR_TUNING = Object.freeze({
   splitTall: true,
   minInkContrast: 35,
   postprocess: true,
-  tightBoxes: true
+  tightBoxes: true,
+  splitLeaders: true
 });
 var DET_MIN_SIZE = 3;
 var DET_MAX_BOXES = 1e3;
@@ -427,6 +730,9 @@ var REC_MIN_WIDTH = 320;
 var REC_BATCH_MAX_PIXELS = 48 * 16e3;
 var TALL_RATIO = 1.5;
 var ROTATE_RATIO = 3;
+var LEADER_MIN_DOTS = 4;
+var LEADER_CONTEXT = 0.5;
+var MIN_INK_RATIO = 0.01;
 var DET_MEAN = [0.485, 0.456, 0.406];
 var DET_STD = [0.229, 0.224, 0.225];
 var OcrEngine = class _OcrEngine {
@@ -489,11 +795,13 @@ var OcrEngine = class _OcrEngine {
     if (width < DET_MIN_SIZE || height < DET_MIN_SIZE) return [];
     const boxes = await this.detect(rgba, width, height, tuning);
     const jobs = [];
+    const joins = [];
     let group = 0;
     for (const b of boxes) {
       const gray = grayCrop(rgba, width, b);
       const ink = inkStats(gray);
       if (tuning.minInkContrast > 0 && ink.contrast < tuning.minInkContrast) continue;
+      if (tuning.minInkContrast > 0 && ink.inkRatio < MIN_INK_RATIO) continue;
       if (tuning.splitTall && b.h >= b.w * TALL_RATIO) {
         const bands = splitRowBands(gray, b.w, b.h, ink, 0.45);
         if (bands.length >= 2) {
@@ -506,6 +814,24 @@ var OcrEngine = class _OcrEngine {
           continue;
         }
       }
+      const leaders = tuning.splitLeaders ? leaderRuns(gray, b.w, b.h, ink, LEADER_MIN_DOTS) : [];
+      if (leaders.length) {
+        const join2 = joins.length;
+        joins.push({ box: b, parts: [], trailDots: false });
+        let x0 = 0, dots = false;
+        for (const [a, c] of [...leaders, [b.w, b.w]]) {
+          const bare = { x: b.x + x0, y: b.y, w: a - x0, h: b.h };
+          const end = c > a ? Math.min(c, a + Math.round(b.h * LEADER_CONTEXT)) : a;
+          x0 = c;
+          if (bare.w >= DET_MIN_SIZE && inkStats(grayCrop(rgba, width, bare)).contrast >= Math.max(1, tuning.minInkContrast)) {
+            jobs.push({ box: { ...bare, w: end - (bare.x - b.x) }, rot: 0, group: group++, join: join2, dotsBefore: dots, trimDots: end > a });
+            dots = false;
+          }
+          if (c > a) dots = true;
+        }
+        joins[join2].trailDots = dots;
+        continue;
+      }
       jobs.push({ box: b, rot: 0, group: group++ });
     }
     const results = await this.recognizeJobs(rgba, width, jobs, tuning.recBatch);
@@ -516,27 +842,50 @@ var OcrEngine = class _OcrEngine {
       const cur = best.get(job.group);
       if (!cur || r.confidence > cur.confidence) best.set(job.group, { job, ...r });
     });
-    const items = [];
+    let items = [];
     for (const { job, text: raw, confidence } of best.values()) {
-      const text = tuning.postprocess ? restoreSymbols(raw.trim()) : raw;
+      let text = tuning.postprocess ? restoreSymbols(raw.trim()) : raw;
       if (!text.trim()) continue;
+      if (tuning.postprocess && /^\d/.test(text) && job.rot === 0) {
+        const g = grayCrop(rgba, width, job.box);
+        const tri = leadingTriangle(g, job.box.w, job.box.h, inkStats(g));
+        if (tri) text = tri + text;
+      }
       if (tuning.postprocess && isDotFragment(text)) continue;
       if (confidence < tuning.textScore) {
         if (stats) stats.droppedLowConf++;
         continue;
       }
-      let b = job.box;
-      if (tuning.tightBoxes) {
-        const gray = grayCrop(rgba, width, b);
-        const t = inkBounds(gray, b.w, b.h, inkStats(gray));
-        b = { x: b.x + t.x0, y: b.y + t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0 };
+      if (job.join !== void 0) {
+        if (job.trimDots) text = text.replace(/[\s.:\u00b7\u2022\u2024\u2025\u2026\u2219\u22c5\u318d]+$/u, "");
+        if (text) joins[job.join].parts.push({ x: job.box.x, text, dotsBefore: job.dotsBefore === true, confidence });
+        continue;
       }
-      items.push({ text, x: b.x, y: b.y, w: b.w, h: b.h, confidence });
+      items.push({ text, ...this.itemBox(rgba, width, job.box, tuning), confidence });
     }
+    const leaderEnds = /* @__PURE__ */ new Map();
+    for (const j of joins) {
+      if (!j.parts.length) continue;
+      j.parts.sort((a, b) => a.x - b.x);
+      let text = "";
+      for (const p of j.parts) text += (p.dotsBefore ? text ? " \u2026 " : "\u2026" : text ? " " : "") + p.text;
+      if (j.trailDots) text += " \u2026";
+      const item = { text, ...this.itemBox(rgba, width, j.box, tuning), confidence: Math.min(...j.parts.map((p) => p.confidence)) };
+      items.push(item);
+      leaderEnds.set(item, { lead: j.parts[0].dotsBefore, trail: j.trailDots });
+    }
+    if (leaderEnds.size) items = joinLeaderItems(items, leaderEnds);
     if (tuning.postprocess) restoreBulletItems(items);
     items.sort((a, b) => a.y - b.y || a.x - b.x);
     return items;
   }
+  /** 결과 좌표 — det 박스 그대로 또는 박스 안 잉크 외곽 (tightBoxes) */
+  itemBox(rgba, width, b, tuning) {
+    if (!tuning.tightBoxes) return b;
+    const gray = grayCrop(rgba, width, b);
+    const t = inkBounds(gray, b.w, b.h, inkStats(gray));
+    return { x: b.x + t.x0, y: b.y + t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0 };
+  }
   // ─── det ─────────────────────────────────────────────
   async detect(rgba, width, height, tuning) {
     const ratio = tuning.detLongSide / Math.max(width, height);
@@ -802,7 +1151,7 @@ function rotateRgba(rgba, width, height, deg) {
 // src/ocr/pdf-ocr.ts
 var OCR_RENDER_SCALE = 3;
 var PAGE_TIMEOUT_MS = 12e4;
-async function runPdfOcr(buffer, targets, mode, warnings, onProgress, detectTables = true) {
+async function runPdfOcr(buffer, targets, mode, warnings, onProgress, detectTables = true, vectorOps) {
   const result = /* @__PURE__ */ new Map();
   if (targets.size === 0) return result;
   const pdfiumMod = await tryImport2(
@@ -828,7 +1177,7 @@ async function runPdfOcr(buffer, targets, mode, warnings, onProgress, detectTabl
       onProgress?.(++done, targets.size);
       try {
         const blocks = await withTimeout(
-          ocrOnePage(page, pageNo, mode, engine, warnings, detectTables),
+          ocrOnePage(page, pageNo, mode, engine, warnings, detectTables, vectorOps?.get(pageNo)),
           PAGE_TIMEOUT_MS,
           `OCR \uD398\uC774\uC9C0 ${pageNo} \uD0C0\uC784\uC544\uC6C3 (${PAGE_TIMEOUT_MS / 1e3}\uCD08)`
         );
@@ -847,7 +1196,7 @@ async function runPdfOcr(buffer, targets, mode, warnings, onProgress, detectTabl
   }
   return result;
 }
-async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables) {
+async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables, vectorOps) {
   const { originalWidth: pdfW, originalHeight: pdfH } = page.getOriginalSize();
   const rendered = await page.render({
     scale: OCR_RENDER_SCALE,
@@ -856,7 +1205,7 @@ async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables) {
   const { data: bgra, width: rw, height: rh } = rendered;
   const rgba = bgraToRgba(bgra);
   if (mode === "builtin") {
-    const { rgba: upright } = deskewPage(rgba, rw, rh);
+    const upright = vectorOps ? rgba : deskewPage(rgba, rw, rh).rgba;
     const stats = { droppedLowConf: 0 };
     const items = await engine.recognizePage(upright, rw, rh, stats);
     if (stats.droppedLowConf > 0) {
@@ -867,6 +1216,7 @@ async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables) {
       });
     }
     const scale = rh / pdfH;
+    if (vectorOps) return ocrItemsToBlocks(items, pageNo, pdfW, pdfH, scale, void 0, detectTables, vectorOps);
     const ruling = detectRulingLines(upright, rw, rh, scale);
     const extraLines = rulingToPdfLines(ruling, scale, pdfH);
     return ocrItemsToBlocks(items, pageNo, pdfW, pdfH, scale, extraLines, detectTables);
@@ -885,7 +1235,7 @@ async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables) {
   }
   return [{ type: "paragraph", text: text.trim(), pageNumber: pageNo }];
 }
-function ocrItemsToBlocks(items, pageNumber, pdfW, pdfH, scale, extraLines, detectTables = true) {
+function ocrItemsToBlocks(items, pageNumber, pdfW, pdfH, scale, extraLines, detectTables = true, opList = { fnArray: [], argsArray: [] }) {
   const norm = items.map((it) => {
     const h = it.h / scale;
     return {
@@ -901,7 +1251,7 @@ function ocrItemsToBlocks(items, pageNumber, pdfW, pdfH, scale, extraLines, dete
       isHidden: false
     };
   });
-  return extractPageBlocksWithLines(norm, pageNumber, { fnArray: [], argsArray: [] }, pdfW, pdfH, extraLines, detectTables);
+  return extractPageBlocksWithLines(norm, pageNumber, opList, pdfW, pdfH, extraLines, detectTables);
 }
 async function tryImport2(name, loader) {
   try {
@@ -946,4 +1296,4 @@ export {
   runPdfOcr,
   ocrItemsToBlocks
 };
-//# sourceMappingURL=chunk-VJHAUMCF.js.map
+//# sourceMappingURL=chunk-MG6DJEX4.js.map