kordoc 4.14.2 → 4.14.3

package/dist/chunk-VJHAUMCF.js

@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+import {
+  OCR_DET_MODEL,
+  OCR_REC_DICT,
+  OCR_REC_MODEL,
+  ensureOcrModels,
+  getOcrModelsDir,
+  parseCharacterDict
+} from "./chunk-D6KQKMU3.js";
+import {
+  extractPageBlocksWithLines
+} from "./chunk-A275ZQLX.js";
+
+// src/ocr/ruling-lines.ts
+var INK_LUMA_MAX = 190;
+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;
+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));
+  const ink = new Uint8Array(width * height);
+  for (let p = 0, i = 0; p < ink.length; p++, i += 4) {
+    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);
+  return { horizontals, verticals };
+}
+function detectBands(ink, width, height, minLenPx, maxThickPx, transpose) {
+  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];
+  const out = [];
+  let open = [];
+  const surroundInkRatio = (b, side) => {
+    if (side < 0 || side >= lines) return 0;
+    let dark = 0, total = 0;
+    for (let pos = b.lo; pos <= b.hi; pos += 3) {
+      total++;
+      if (at(side, pos) === 1) dark++;
+    }
+    return total > 0 ? dark / total : 0;
+  };
+  const emit = (b) => {
+    const thick = b.last - b.first + 1;
+    if (thick > maxThickPx) return;
+    if (surroundInkRatio(b, b.first - 2) >= SURROUND_INK_RATIO && surroundInkRatio(b, b.last + 2) >= SURROUND_INK_RATIO) return;
+    const center = (b.first + b.last) / 2;
+    out.push(
+      transpose ? { x1: center, y1: b.lo, x2: center, y2: b.hi, thicknessPx: thick } : { x1: b.lo, y1: center, x2: b.hi, y2: center, thicknessPx: thick }
+    );
+  };
+  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 next = [];
+    const used = /* @__PURE__ */ new Set();
+    for (const band of open) {
+      if (band.last !== line - 1) {
+        emit(band);
+        continue;
+      }
+      let merged = false;
+      for (let r = 0; r < runs.length; r++) {
+        if (used.has(r)) continue;
+        const run = runs[r];
+        const overlap = Math.min(band.hi, run.hi) - Math.max(band.lo, run.lo) + 1;
+        const shorter = Math.min(band.hi - band.lo, run.hi - run.lo) + 1;
+        if (overlap >= shorter * BAND_OVERLAP_RATIO) {
+          band.lo = Math.min(band.lo, run.lo);
+          band.hi = Math.max(band.hi, run.hi);
+          band.last = line;
+          next.push(band);
+          used.add(r);
+          merged = true;
+          break;
+        }
+      }
+      if (!merged) emit(band);
+    }
+    for (let r = 0; r < runs.length; r++) {
+      if (!used.has(r)) next.push({ lo: runs[r].lo, hi: runs[r].hi, first: line, last: line });
+    }
+    open = next;
+  }
+  for (const band of open) emit(band);
+  return out;
+}
+function rulingToPdfLines(ruling, scale, pdfHeight) {
+  const horizontals = ruling.horizontals.map((s) => {
+    const y = pdfHeight - (s.y1 + s.y2) / 2 / scale;
+    return {
+      x1: Math.min(s.x1, s.x2) / scale,
+      y1: y,
+      x2: Math.max(s.x1, s.x2) / scale,
+      y2: y,
+      lineWidth: s.thicknessPx / scale
+    };
+  });
+  const verticals = ruling.verticals.map((s) => {
+    const x = (s.x1 + s.x2) / 2 / scale;
+    const yA = pdfHeight - Math.max(s.y1, s.y2) / scale;
+    const yB = pdfHeight - Math.min(s.y1, s.y2) / scale;
+    return { x1: x, y1: yA, x2: x, y2: yB, lineWidth: s.thicknessPx / scale };
+  });
+  return { horizontals, verticals };
+}
+
+// src/ocr/engine.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// src/ocr/line-split.ts
+function grayCrop(rgba, pageW, box) {
+  const out = new Uint8Array(box.w * box.h);
+  for (let y = 0; y < box.h; y++) {
+    let si = ((box.y + y) * pageW + box.x) * 4;
+    let di = y * box.w;
+    for (let x = 0; x < box.w; x++, si += 4, di++) {
+      out[di] = rgba[si] * 77 + rgba[si + 1] * 150 + rgba[si + 2] * 29 >> 8;
+    }
+  }
+  return out;
+}
+function inkStats(gray) {
+  const hist = new Uint32Array(256);
+  for (let i = 0; i < gray.length; i++) hist[gray[i]]++;
+  const total = gray.length;
+  let sumAll = 0;
+  for (let v = 0; v < 256; v++) sumAll += v * hist[v];
+  let wB = 0, sumB = 0, best = -1, thr = 127;
+  for (let t = 0; t < 256; t++) {
+    wB += hist[t];
+    if (wB === 0) continue;
+    const wF = total - wB;
+    if (wF === 0) break;
+    sumB += t * hist[t];
+    const mB = sumB / wB;
+    const mF = (sumAll - sumB) / wF;
+    const between = wB * wF * (mB - mF) * (mB - mF);
+    if (between > best) {
+      best = between;
+      thr = t;
+    }
+  }
+  let nDark = 0, sDark = 0;
+  for (let v = 0; v <= thr; v++) {
+    nDark += hist[v];
+    sDark += v * hist[v];
+  }
+  const nLight = total - nDark;
+  const sLight = sumAll - sDark;
+  if (nDark === 0 || nLight === 0) return { threshold: thr, darkInk: true, contrast: 0, inkRatio: 0 };
+  const darkInk = nDark <= nLight;
+  return {
+    threshold: thr,
+    darkInk,
+    contrast: sLight / nLight - sDark / nDark,
+    inkRatio: (darkInk ? nDark : nLight) / total
+  };
+}
+function splitRowBands(gray, w, h, ink, minBandRatio) {
+  const isInk = (v) => ink.darkInk ? v <= ink.threshold : v > ink.threshold;
+  const colInk = new Uint32Array(w);
+  for (let y = 0; y < h; y++) {
+    const off = y * w;
+    for (let x = 0; x < w; x++) if (isInk(gray[off + x])) colInk[x]++;
+  }
+  const ruleCol = new Uint8Array(w);
+  let liveW = 0;
+  for (let x = 0; x < w; x++) {
+    if (colInk[x] >= h * 0.85) ruleCol[x] = 1;
+    else liveW++;
+  }
+  const rowInk = new Uint32Array(h);
+  for (let y = 0; y < h; y++) {
+    let n = 0;
+    const off = y * w;
+    for (let x = 0; x < w; x++) if (!ruleCol[x] && isInk(gray[off + x])) n++;
+    rowInk[y] = n >= liveW * 0.85 ? 0 : n;
+  }
+  const blank = Math.max(1, Math.floor(w * 0.02));
+  let bands = [];
+  let start = -1;
+  for (let y = 0; y <= h; y++) {
+    const on = y < h && rowInk[y] > blank;
+    if (on && start < 0) start = y;
+    else if (!on && start >= 0) {
+      bands.push([start, y]);
+      start = -1;
+    }
+  }
+  const inkCols = (y0, y1) => {
+    let x0 = w, x1 = -1;
+    for (let y = y0; y < y1; y++) {
+      const off = y * w;
+      for (let x = 0; x < w; x++) if (!ruleCol[x] && isInk(gray[off + x])) {
+        if (x < x0) x0 = x;
+        if (x > x1) x1 = x;
+      }
+    }
+    return x1 >= x0 ? [x0, x1 + 1] : [0, w];
+  };
+  if (bands.length <= 1) return [{ y0: bands[0]?.[0] ?? 0, y1: bands[0]?.[1] ?? h, x0: 0, x1: w }];
+  const widths = bands.map(([y0, y1]) => {
+    const [a, b] = inkCols(y0, y1);
+    return b - a;
+  }).sort((a, b) => a - b);
+  const charSize = widths[widths.length >> 1];
+  const minBand = Math.max(3, minBandRatio * charSize);
+  for (let i = 0; i + 1 < bands.length; ) {
+    const gap = bands[i + 1][0] - bands[i][1];
+    if (gap <= Math.max(2, charSize * 0.15) && bands[i + 1][1] - bands[i][0] <= charSize * 1.3) {
+      bands.splice(i, 2, [bands[i][0], bands[i + 1][1]]);
+    } else i++;
+  }
+  while (bands.length > 1 && bands[0][0] <= 1 && bands[0][1] - bands[0][0] < minBand) bands.shift();
+  while (bands.length > 1 && bands[bands.length - 1][1] >= h - 1 && bands[bands.length - 1][1] - bands[bands.length - 1][0] < minBand) bands.pop();
+  for (; ; ) {
+    let idx = -1, minH = Infinity;
+    for (let i = 0; i < bands.length; i++) {
+      const bh = bands[i][1] - bands[i][0];
+      if (bh < minBand && bh < minH) {
+        minH = bh;
+        idx = i;
+      }
+    }
+    if (idx < 0 || bands.length === 1) break;
+    const gapPrev = idx > 0 ? bands[idx][0] - bands[idx - 1][1] : Infinity;
+    const gapNext = idx < bands.length - 1 ? bands[idx + 1][0] - bands[idx][1] : Infinity;
+    const j = gapPrev <= gapNext ? idx - 1 : idx + 1;
+    const a = Math.min(idx, j), b = Math.max(idx, j);
+    bands = [...bands.slice(0, a), [bands[a][0], bands[b][1]], ...bands.slice(b + 1)];
+  }
+  if (bands.length === 1) return [{ y0: bands[0][0], y1: bands[0][1], x0: 0, x1: w }];
+  return bands.map(([y0, y1]) => {
+    const [x0, x1] = inkCols(y0, y1);
+    return { y0, y1, x0, x1 };
+  });
+}
+function 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 };
+}
+
+// src/ocr/postprocess.ts
+var HANGUL_START = /^[\uac00-\ud7a3]/;
+function restoreSymbols(text) {
+  let s = 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");
+  return smartQuotes(joinDigitGroups(s));
+}
+function joinDigitGroups(s) {
+  return s.replace(/(?<![\d,])\d{1,3}(?:, ?\d{3})+(?![\d])/g, (m) => m.replace(/, /g, ","));
+}
+function smartQuotes(s) {
+  if (!/['"]/.test(s)) return s;
+  const chars = [...s];
+  for (const q of ["'", '"']) {
+    const [open, close] = q === "'" ? ["\u2018", "\u2019"] : ["\u201C", "\u201D"];
+    const pos = [];
+    for (let i = 0; i < chars.length; i++) {
+      if (chars[i] !== q) continue;
+      const prev2 = i > 0 ? chars[i - 1] : "";
+      if (q === "'" && !/[\p{L}\p{N}]/u.test(prev2) && /^\d{2}(?!\d)/.test(chars.slice(i + 1, i + 4).join(""))) {
+        chars[i] = close;
+        continue;
+      }
+      pos.push(i);
+    }
+    if (pos.length === 0) continue;
+    const first = pos[0];
+    const prev = first > 0 ? chars[first - 1] : "";
+    const atOpen = prev === "" || /[\s(\[{<\u300c\u300e\u3010\u3008\u300a\u2018\u201c·,:]/.test(prev);
+    let isOpen = pos.length % 2 === 0 || atOpen;
+    for (const i of pos) {
+      chars[i] = isOpen ? open : close;
+      isOpen = !isOpen;
+    }
+  }
+  return chars.join("");
+}
+function isDotFragment(text) {
+  return /^[\s.\u00b7\u2024\u2025\u2026\u2027\u2219\u22c5\u318d]+$/.test(text);
+}
+function restoreBulletItems(items) {
+  for (const it of items) {
+    if (it.text !== "O" && it.text !== "o") continue;
+    const cy = it.y + it.h / 2;
+    let next = null;
+    for (const o of items) {
+      if (o === it || o.x < it.x + it.w * 0.5) continue;
+      if (Math.abs(o.y + o.h / 2 - cy) > Math.max(it.h, o.h) / 2) continue;
+      if (o.x - (it.x + it.w) > it.h * 3) continue;
+      if (!next || o.x < next.x) next = o;
+    }
+    if (next && HANGUL_START.test(next.text.trimStart())) it.text = "\u25CB";
+  }
+}
+
+// src/ocr/crop.ts
+var REC_HEIGHT = 48;
+var REC_MAX_WIDTH = 3200;
+var MIN_SIZE = 3;
+function bandBoxes(b, bands, pageH) {
+  const out = [];
+  for (let i = 0; i < bands.length; i++) {
+    const { y0, y1, x0, x1 } = bands[i];
+    const bh = y1 - y0;
+    const upGap = i > 0 ? (y0 - bands[i - 1].y1) / 2 : y0;
+    const downGap = i < bands.length - 1 ? (bands[i + 1].y0 - y1) / 2 : b.h - y1;
+    const top = Math.max(0, Math.round(b.y + y0 - Math.min(bh * 0.2, upGap)));
+    const bot = Math.min(pageH, Math.round(b.y + y1 + Math.min(bh * 0.2, downGap)));
+    const left = Math.max(b.x, Math.round(b.x + x0 - bh * 0.2));
+    const right = Math.min(b.x + b.w, Math.round(b.x + x1 + bh * 0.2));
+    if (bot - top >= MIN_SIZE && right - left >= MIN_SIZE) out.push({ x: left, y: top, w: right - left, h: bot - top });
+  }
+  return out;
+}
+function lineCrop(rgba, pageW, box, rot) {
+  const srcW = rot === 0 ? box.w : box.h;
+  const srcH = rot === 0 ? box.h : box.w;
+  const rw = Math.min(REC_MAX_WIDTH, Math.max(16, Math.round(srcW * REC_HEIGHT / srcH)));
+  const rgb = new Uint8Array(rw * REC_HEIGHT * 3);
+  const at = (u, v) => {
+    let px, py;
+    if (rot === 0) {
+      px = u;
+      py = v;
+    } else if (rot === 90) {
+      px = box.w - 1 - v;
+      py = u;
+    } else {
+      px = v;
+      py = box.h - 1 - u;
+    }
+    return ((box.y + py) * pageW + (box.x + px)) * 4;
+  };
+  const fx = srcW / rw;
+  const fy = srcH / REC_HEIGHT;
+  for (let dy = 0; dy < REC_HEIGHT; dy++) {
+    let sy = (dy + 0.5) * fy - 0.5;
+    if (sy < 0) sy = 0;
+    const y0 = Math.min(srcH - 1, Math.floor(sy));
+    const y1 = Math.min(srcH - 1, y0 + 1);
+    const wy = sy - y0;
+    for (let dx = 0; dx < rw; dx++) {
+      let sx = (dx + 0.5) * fx - 0.5;
+      if (sx < 0) sx = 0;
+      const x0 = Math.min(srcW - 1, Math.floor(sx));
+      const x1 = Math.min(srcW - 1, x0 + 1);
+      const wx = sx - x0;
+      const i00 = at(x0, y0), i01 = at(x1, y0), i10 = at(x0, y1), i11 = at(x1, y1);
+      const o = (dy * rw + dx) * 3;
+      for (let c = 0; c < 3; c++) {
+        const top = rgba[i00 + c] * (1 - wx) + rgba[i01 + c] * wx;
+        const bottom = rgba[i10 + c] * (1 - wx) + rgba[i11 + c] * wx;
+        rgb[o + c] = Math.round(top * (1 - wy) + bottom * wy);
+      }
+    }
+  }
+  return { rgb, w: rw };
+}
+
+// src/ocr/engine.ts
+var DEFAULT_OCR_TUNING = Object.freeze({
+  detLongSide: 960,
+  detThresh: 0.3,
+  detBoxThresh: 0.6,
+  detUnclip: 1.5,
+  textScore: 0.5,
+  recBatch: 1,
+  splitTall: true,
+  minInkContrast: 35,
+  postprocess: true,
+  tightBoxes: true
+});
+var DET_MIN_SIZE = 3;
+var DET_MAX_BOXES = 1e3;
+var REC_MIN_WIDTH = 320;
+var REC_BATCH_MAX_PIXELS = 48 * 16e3;
+var TALL_RATIO = 1.5;
+var ROTATE_RATIO = 3;
+var DET_MEAN = [0.485, 0.456, 0.406];
+var DET_STD = [0.229, 0.224, 0.225];
+var OcrEngine = class _OcrEngine {
+  det;
+  rec;
+  dict;
+  ort;
+  sharp;
+  constructor(parts) {
+    this.det = parts.det;
+    this.rec = parts.rec;
+    this.dict = parts.dict;
+    this.ort = parts.ort;
+    this.sharp = parts.sharp;
+  }
+  static async create() {
+    const [ortMod, sharpModRaw] = await Promise.all([
+      tryImport("onnxruntime-node", () => import("onnxruntime-node")),
+      tryImport(
+        "sharp",
+        () => import("sharp")
+      )
+    ]);
+    const sharpAny = sharpModRaw;
+    const sharpMod = typeof sharpAny === "function" ? sharpAny : sharpAny.default ?? sharpAny;
+    const dir = getOcrModelsDir();
+    const sessionOpts = {
+      graphOptimizationLevel: "all",
+      executionProviders: ["cpu"],
+      logSeverityLevel: 3
+      // paddle2onnx 변환 잔여물 W 로그 폭주 억제
+    };
+    const [det, rec, dictYml] = await Promise.all([
+      ortMod.InferenceSession.create(join(dir, OCR_DET_MODEL.filename), sessionOpts),
+      ortMod.InferenceSession.create(join(dir, OCR_REC_MODEL.filename), sessionOpts),
+      readFile(join(dir, OCR_REC_DICT.filename), "utf-8")
+    ]);
+    const dict = parseCharacterDict(dictYml);
+    if (dict.length === 0) throw new Error("OCR \uC0AC\uC804 \uD30C\uC2F1 \uC2E4\uD328 \u2014 \uBAA8\uB378 \uCE90\uC2DC\uB97C \uC0AD\uC81C \uD6C4 \uC7AC\uB2E4\uC6B4\uB85C\uB4DC\uD558\uC138\uC694");
+    return new _OcrEngine({ det, rec, dict, ort: ortMod, sharp: sharpMod });
+  }
+  /** onnxruntime-node 1.14+ InferenceSession.release() — 구버전은 무시 */
+  async destroy() {
+    for (const s of [this.det, this.rec]) {
+      const rel = s.release;
+      if (typeof rel === "function") {
+        try {
+          await rel.call(s);
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * 페이지 RGBA 픽셀 → 텍스트 라인 인식.
+   * 반환 좌표는 입력 픽셀 기준. 라인은 위→아래, 좌→우 정렬.
+   * @param stats 저신뢰(conf<0.5) 폐기 라인 카운트 출력 — 종전엔 무음 폐기라 관측 불가
+   */
+  async recognizePage(rgba, width, height, stats, tuning = DEFAULT_OCR_TUNING) {
+    if (width < DET_MIN_SIZE || height < DET_MIN_SIZE) return [];
+    const boxes = await this.detect(rgba, width, height, tuning);
+    const jobs = [];
+    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.splitTall && b.h >= b.w * TALL_RATIO) {
+        const bands = splitRowBands(gray, b.w, b.h, ink, 0.45);
+        if (bands.length >= 2) {
+          for (const sub of bandBoxes(b, bands, height)) jobs.push({ box: sub, rot: 0, group: group++ });
+          continue;
+        }
+        if (b.h >= b.w * ROTATE_RATIO) {
+          for (const rot of [0, 90, 270]) jobs.push({ box: b, rot, group });
+          group++;
+          continue;
+        }
+      }
+      jobs.push({ box: b, rot: 0, group: group++ });
+    }
+    const results = await this.recognizeJobs(rgba, width, jobs, tuning.recBatch);
+    const best = /* @__PURE__ */ new Map();
+    jobs.forEach((job, i) => {
+      const r = results[i];
+      if (!r) return;
+      const cur = best.get(job.group);
+      if (!cur || r.confidence > cur.confidence) best.set(job.group, { job, ...r });
+    });
+    const items = [];
+    for (const { job, text: raw, confidence } of best.values()) {
+      const text = tuning.postprocess ? restoreSymbols(raw.trim()) : raw;
+      if (!text.trim()) continue;
+      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 };
+      }
+      items.push({ text, x: b.x, y: b.y, w: b.w, h: b.h, confidence });
+    }
+    if (tuning.postprocess) restoreBulletItems(items);
+    items.sort((a, b) => a.y - b.y || a.x - b.x);
+    return items;
+  }
+  // ─── det ─────────────────────────────────────────────
+  async detect(rgba, width, height, tuning) {
+    const ratio = tuning.detLongSide / Math.max(width, height);
+    const dw = Math.max(32, Math.round(width * ratio / 32) * 32);
+    const dh = Math.max(32, Math.round(height * ratio / 32) * 32);
+    const rgb = await this.sharp(rgba, { raw: { width, height, channels: 4 } }).resize(dw, dh, { fit: "fill" }).removeAlpha().raw().toBuffer();
+    const plane = dw * dh;
+    const input = new Float32Array(3 * plane);
+    for (let i = 0; i < plane; i++) {
+      const r = rgb[i * 3] / 255;
+      const g = rgb[i * 3 + 1] / 255;
+      const b = rgb[i * 3 + 2] / 255;
+      input[i] = (b - DET_MEAN[0]) / DET_STD[0];
+      input[plane + i] = (g - DET_MEAN[1]) / DET_STD[1];
+      input[2 * plane + i] = (r - DET_MEAN[2]) / DET_STD[2];
+    }
+    const tensor = new this.ort.Tensor("float32", input, [1, 3, dh, dw]);
+    const out = await this.det.run({ [this.det.inputNames[0]]: tensor });
+    const probMap = out[this.det.outputNames[0]].data;
+    const rawBoxes = componentBoxes(probMap, dw, dh, tuning.detThresh, tuning.detBoxThresh);
+    const sx = width / dw;
+    const sy = height / dh;
+    const boxes = [];
+    for (const rb of rawBoxes.slice(0, DET_MAX_BOXES)) {
+      const bw = rb.x2 - rb.x1 + 1;
+      const bh = rb.y2 - rb.y1 + 1;
+      const delta = bw * bh * tuning.detUnclip / (2 * (bw + bh));
+      const x1 = Math.max(0, Math.floor((rb.x1 - delta) * sx));
+      const y1 = Math.max(0, Math.floor((rb.y1 - delta) * sy));
+      const x2 = Math.min(width, Math.ceil((rb.x2 + 1 + delta) * sx));
+      const y2 = Math.min(height, Math.ceil((rb.y2 + 1 + delta) * sy));
+      if (x2 - x1 < DET_MIN_SIZE || y2 - y1 < DET_MIN_SIZE) continue;
+      boxes.push({ x: x1, y: y1, w: x2 - x1, h: y2 - y1 });
+    }
+    return boxes;
+  }
+  // ─── rec ─────────────────────────────────────────────
+  /** 라인 작업들을 폭 비율 순으로 배치 인식 — 결과는 jobs 순서 */
+  async recognizeJobs(rgba, pageW, jobs, batchSize) {
+    const crops = jobs.map((j) => lineCrop(rgba, pageW, j.box, j.rot));
+    const order = crops.map((_, i) => i).sort((a, b) => crops[a].w - crops[b].w);
+    const results = new Array(jobs.length).fill(null);
+    const plane = REC_HEIGHT;
+    for (let s = 0; s < order.length; ) {
+      let e = s + 1;
+      while (e < order.length && e - s < Math.max(1, batchSize) && (e - s + 1) * Math.max(REC_MIN_WIDTH, crops[order[e]].w) * plane <= REC_BATCH_MAX_PIXELS) e++;
+      const idx = order.slice(s, e);
+      const bw = Math.max(REC_MIN_WIDTH, crops[idx[idx.length - 1]].w);
+      const n = idx.length;
+      const chw = 3 * REC_HEIGHT * bw;
+      const input = new Float32Array(n * chw);
+      idx.forEach((ci, k) => {
+        const c = crops[ci];
+        const base = k * chw;
+        const p = REC_HEIGHT * bw;
+        for (let y = 0; y < REC_HEIGHT; y++) {
+          for (let x = 0; x < c.w; x++) {
+            const src = (y * c.w + x) * 3;
+            const dst = base + y * bw + x;
+            input[dst] = c.rgb[src + 2] / 127.5 - 1;
+            input[dst + p] = c.rgb[src + 1] / 127.5 - 1;
+            input[dst + 2 * p] = c.rgb[src] / 127.5 - 1;
+          }
+        }
+      });
+      const tensor = new this.ort.Tensor("float32", input, [n, 3, REC_HEIGHT, bw]);
+      const out = await this.rec.run({ [this.rec.inputNames[0]]: tensor });
+      const logits = out[this.rec.outputNames[0]];
+      const [, T, C] = logits.dims;
+      const data = logits.data;
+      idx.forEach((ci, k) => {
+        results[ci] = ctcDecode(data.subarray(k * T * C, (k + 1) * T * C), T, C, this.dict);
+      });
+      s = e;
+    }
+    return results;
+  }
+};
+function ctcDecode(data, T, C, dict) {
+  let text = "";
+  let confSum = 0;
+  let confCount = 0;
+  let prev = -1;
+  for (let t = 0; t < T; t++) {
+    const off = t * C;
+    let best = 0;
+    let bestV = data[off];
+    for (let c = 1; c < C; c++) {
+      const v = data[off + c];
+      if (v > bestV) {
+        bestV = v;
+        best = c;
+      }
+    }
+    const repeat = best === prev;
+    prev = best;
+    if (best === 0 || repeat) continue;
+    let p = bestV;
+    if (p > 1.0001 || p < 0) {
+      let denom = 0;
+      for (let c = 0; c < C; c++) denom += Math.exp(data[off + c] - bestV);
+      p = 1 / denom;
+    }
+    confSum += p;
+    confCount++;
+    if (best >= 1 && best <= dict.length) text += dict[best - 1];
+    else if (best === dict.length + 1) text += " ";
+  }
+  if (!text) return null;
+  return { text, confidence: confCount > 0 ? confSum / confCount : 0 };
+}
+function componentBoxes(prob, w, h, thresh = DEFAULT_OCR_TUNING.detThresh, boxThresh = DEFAULT_OCR_TUNING.detBoxThresh) {
+  const visited = new Uint8Array(w * h);
+  const boxes = [];
+  const stack = [];
+  for (let start = 0; start < w * h; start++) {
+    if (visited[start] || prob[start] <= thresh) continue;
+    let x1 = start % w, x2 = x1, y1 = start / w | 0, y2 = y1;
+    let sum = 0;
+    let count = 0;
+    stack.length = 0;
+    stack.push(start);
+    visited[start] = 1;
+    while (stack.length) {
+      const p = stack.pop();
+      const px = p % w;
+      const py = p / w | 0;
+      sum += prob[p];
+      count++;
+      if (px < x1) x1 = px;
+      if (px > x2) x2 = px;
+      if (py < y1) y1 = py;
+      if (py > y2) y2 = py;
+      if (px > 0 && !visited[p - 1] && prob[p - 1] > thresh) {
+        visited[p - 1] = 1;
+        stack.push(p - 1);
+      }
+      if (px < w - 1 && !visited[p + 1] && prob[p + 1] > thresh) {
+        visited[p + 1] = 1;
+        stack.push(p + 1);
+      }
+      if (py > 0 && !visited[p - w] && prob[p - w] > thresh) {
+        visited[p - w] = 1;
+        stack.push(p - w);
+      }
+      if (py < h - 1 && !visited[p + w] && prob[p + w] > thresh) {
+        visited[p + w] = 1;
+        stack.push(p + w);
+      }
+    }
+    if (x2 - x1 + 1 < DET_MIN_SIZE && y2 - y1 + 1 < DET_MIN_SIZE) continue;
+    boxes.push({ x1, y1, x2, y2, score: sum / count });
+  }
+  return boxes.filter((b) => b.score >= boxThresh).sort((a, b) => a.y1 - b.y1 || a.x1 - b.x1);
+}
+async function tryImport(name, loader) {
+  try {
+    return await loader();
+  } catch (e) {
+    throw new Error(
+      `\uB0B4\uC7A5 OCR \uC744 \uC0AC\uC6A9\uD558\uB824\uBA74 optional dependency '${name}' \uC774 \uD544\uC694\uD569\uB2C8\uB2E4. \`npm install ${name}\` \uD6C4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694. \uC6D0\uC778: ${e.message}`
+    );
+  }
+}
+var enginePromise = null;
+function getOcrEngine() {
+  if (!enginePromise) {
+    enginePromise = OcrEngine.create().catch((err) => {
+      enginePromise = null;
+      throw err;
+    });
+  }
+  return enginePromise;
+}
+
+// src/ocr/deskew.ts
+var MAX_SKEW_DEG = 5;
+var MIN_APPLY_DEG = 0.25;
+var MIN_GAIN = 1.03;
+var TARGET_LONG = 1e3;
+function estimateSkew(rgba, width, height) {
+  const step = Math.max(1, Math.ceil(Math.max(width, height) / TARGET_LONG));
+  const sw = Math.floor(width / step), sh = Math.floor(height / step);
+  const xs = [], ys = [];
+  for (let y = 0; y < sh; y++) {
+    for (let x = 0; x < sw; x++) {
+      const i = (y * step * width + x * step) * 4;
+      const l = rgba[i] * 77 + rgba[i + 1] * 150 + rgba[i + 2] * 29 >> 8;
+      if (l < 128) {
+        xs.push(x);
+        ys.push(y);
+      }
+    }
+  }
+  if (xs.length < 200) return { angle: 0, gain: 1 };
+  const diag = Math.ceil(Math.hypot(sw, sh));
+  const hist = new Float64Array(2 * diag + 2);
+  const score = (deg) => {
+    const t = deg * Math.PI / 180;
+    const c = Math.cos(t), s = Math.sin(t);
+    hist.fill(0);
+    for (let k = 0; k < xs.length; k++) hist[Math.round(ys[k] * c + xs[k] * s) + diag]++;
+    let sum = 0;
+    for (let i = 0; i < hist.length; i++) sum += hist[i] * hist[i];
+    return sum;
+  };
+  const s0 = score(0);
+  let best = 0, bestS = s0;
+  for (let d = -MAX_SKEW_DEG; d <= MAX_SKEW_DEG + 1e-9; d += 0.2) {
+    const v = score(d);
+    if (v > bestS) {
+      bestS = v;
+      best = d;
+    }
+  }
+  const coarse = best;
+  for (let d = coarse - 0.2; d <= coarse + 0.2 + 1e-9; d += 0.02) {
+    const v = score(d);
+    if (v > bestS) {
+      bestS = v;
+      best = d;
+    }
+  }
+  return { angle: +(-best).toFixed(2), gain: s0 > 0 ? bestS / s0 : 1 };
+}
+function deskewPage(rgba, width, height) {
+  const est = estimateSkew(rgba, width, height);
+  if (Math.abs(est.angle) < MIN_APPLY_DEG || est.gain < MIN_GAIN) return { rgba, angle: 0 };
+  return { rgba: rotateRgba(rgba, width, height, est.angle), angle: est.angle };
+}
+function rotateRgba(rgba, width, height, deg) {
+  const out = new Uint8Array(rgba.length);
+  const t = deg * Math.PI / 180;
+  const c = Math.cos(t), s = Math.sin(t);
+  const cx = (width - 1) / 2, cy = (height - 1) / 2;
+  for (let y = 0; y < height; y++) {
+    const dy = y - cy;
+    for (let x = 0; x < width; x++) {
+      const dx = x - cx;
+      const sx = c * dx - s * dy + cx;
+      const sy = s * dx + c * dy + cy;
+      const o = (y * width + x) * 4;
+      const x0 = Math.floor(sx), y0 = Math.floor(sy);
+      if (x0 < 0 || y0 < 0 || x0 >= width - 1 || y0 >= height - 1) {
+        out[o] = 255;
+        out[o + 1] = 255;
+        out[o + 2] = 255;
+        out[o + 3] = 255;
+        continue;
+      }
+      const wx = sx - x0, wy = sy - y0;
+      const i00 = (y0 * width + x0) * 4, i01 = i00 + 4, i10 = i00 + width * 4, i11 = i10 + 4;
+      for (let ch = 0; ch < 4; ch++) {
+        const top = rgba[i00 + ch] * (1 - wx) + rgba[i01 + ch] * wx;
+        const bot = rgba[i10 + ch] * (1 - wx) + rgba[i11 + ch] * wx;
+        out[o + ch] = Math.round(top * (1 - wy) + bot * wy);
+      }
+    }
+  }
+  return out;
+}
+
+// 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) {
+  const result = /* @__PURE__ */ new Map();
+  if (targets.size === 0) return result;
+  const pdfiumMod = await tryImport2(
+    "@hyzyla/pdfium",
+    () => import("@hyzyla/pdfium")
+  );
+  if (mode === "builtin") {
+    await ensureOcrModels((p) => {
+      if (p.phase === "download" && p.downloaded === 0) {
+        process.stderr.write(`[kordoc-ocr] ${p.spec.name} \uB2E4\uC6B4\uB85C\uB4DC \uC911 (~${p.spec.sizeMb}MB)...
+`);
+      }
+    });
+  }
+  const engine = mode === "builtin" ? await getOcrEngine() : null;
+  const pdfium = await pdfiumMod.PDFiumLibrary.init();
+  const doc = await pdfium.loadDocument(new Uint8Array(buffer));
+  try {
+    let done = 0;
+    for (const page of doc.pages()) {
+      const pageNo = page.number + 1;
+      if (!targets.has(pageNo)) continue;
+      onProgress?.(++done, targets.size);
+      try {
+        const blocks = await withTimeout(
+          ocrOnePage(page, pageNo, mode, engine, warnings, detectTables),
+          PAGE_TIMEOUT_MS,
+          `OCR \uD398\uC774\uC9C0 ${pageNo} \uD0C0\uC784\uC544\uC6C3 (${PAGE_TIMEOUT_MS / 1e3}\uCD08)`
+        );
+        result.set(pageNo, blocks);
+      } catch (e) {
+        warnings.push({
+          page: pageNo,
+          message: `\uD398\uC774\uC9C0 ${pageNo} OCR \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`,
+          code: "OCR_FAILED"
+        });
+      }
+    }
+  } finally {
+    doc.destroy();
+    pdfium.destroy();
+  }
+  return result;
+}
+async function ocrOnePage(page, pageNo, mode, engine, warnings, detectTables) {
+  const { originalWidth: pdfW, originalHeight: pdfH } = page.getOriginalSize();
+  const rendered = await page.render({
+    scale: OCR_RENDER_SCALE,
+    render: async ({ data }) => data
+  });
+  const { data: bgra, width: rw, height: rh } = rendered;
+  const rgba = bgraToRgba(bgra);
+  if (mode === "builtin") {
+    const { rgba: upright } = deskewPage(rgba, rw, rh);
+    const stats = { droppedLowConf: 0 };
+    const items = await engine.recognizePage(upright, rw, rh, stats);
+    if (stats.droppedLowConf > 0) {
+      warnings.push({
+        page: pageNo,
+        message: `\uD398\uC774\uC9C0 ${pageNo}: \uC800\uC2E0\uB8B0 OCR \uB77C\uC778 ${stats.droppedLowConf}\uAC1C \uD3D0\uAE30 (\uC778\uC2DD \uACB0\uC190 \uAC00\uB2A5)`,
+        code: "OCR_LOW_CONF"
+      });
+    }
+    const scale = rh / pdfH;
+    const ruling = detectRulingLines(upright, rw, rh, scale);
+    const extraLines = rulingToPdfLines(ruling, scale, pdfH);
+    return ocrItemsToBlocks(items, pageNo, pdfW, pdfH, scale, extraLines, detectTables);
+  }
+  const sharpModRaw = await tryImport2(
+    "sharp",
+    () => import("sharp")
+  );
+  const sharpAny = sharpModRaw;
+  const sharp = typeof sharpAny === "function" ? sharpAny : sharpAny.default ?? sharpAny;
+  const png = await sharp(rgba, { raw: { width: rw, height: rh, channels: 4 } }).png().toBuffer();
+  const text = await mode(new Uint8Array(png), pageNo, "image/png");
+  if (!text.trim()) {
+    warnings.push({ page: pageNo, message: `\uD398\uC774\uC9C0 ${pageNo} OCR \uACB0\uACFC \uC5C6\uC74C`, code: "OCR_FAILED" });
+    return [];
+  }
+  return [{ type: "paragraph", text: text.trim(), pageNumber: pageNo }];
+}
+function ocrItemsToBlocks(items, pageNumber, pdfW, pdfH, scale, extraLines, detectTables = true) {
+  const norm = items.map((it) => {
+    const h = it.h / scale;
+    return {
+      text: it.text,
+      x: Math.round(it.x / scale),
+      // NormItem.y 는 pdfjs transform[5] = 베이스라인 (bottom-up) — 잉크 하단으로 근사
+      y: Math.round(pdfH - (it.y + it.h) / scale),
+      w: Math.round(it.w / scale),
+      h: Math.round(h),
+      // 박스는 잉크 외곽(engine tightBoxes) — 한글 줄 잉크 높이 ≈ 0.9em
+      fontSize: Math.max(1, Math.round(h / 0.9)),
+      fontName: "ocr",
+      isHidden: false
+    };
+  });
+  return extractPageBlocksWithLines(norm, pageNumber, { fnArray: [], argsArray: [] }, pdfW, pdfH, extraLines, detectTables);
+}
+async function tryImport2(name, loader) {
+  try {
+    return await loader();
+  } catch (e) {
+    throw new Error(
+      `OCR \uC744 \uC0AC\uC6A9\uD558\uB824\uBA74 optional dependency '${name}' \uC774 \uD544\uC694\uD569\uB2C8\uB2E4. \`npm install ${name}\` \uD6C4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694. \uC6D0\uC778: ${e.message}`
+    );
+  }
+}
+async function withTimeout(promise, ms, msg) {
+  promise.catch(() => {
+  });
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(msg)), ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function bgraToRgba(bgra) {
+  const out = new Uint8Array(bgra.length);
+  for (let i = 0; i < bgra.length; i += 4) {
+    out[i] = bgra[i + 2];
+    out[i + 1] = bgra[i + 1];
+    out[i + 2] = bgra[i];
+    out[i + 3] = bgra[i + 3];
+  }
+  return out;
+}
+
+export {
+  getOcrEngine,
+  detectRulingLines,
+  rulingToPdfLines,
+  deskewPage,
+  runPdfOcr,
+  ocrItemsToBlocks
+};
+//# sourceMappingURL=chunk-VJHAUMCF.js.map