kordoc 4.14.2 → 4.14.4

package/dist/chunk-IMAAFSAX.cjs

@@ -0,0 +1,1352 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkQEJUY6SKcjs = require('./chunk-QEJUY6SK.cjs');
+
+
+var _chunkUSHQCF5Tcjs = require('./chunk-USHQCF5T.cjs');
+
+// src/ocr/ruling-lines.ts
+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));
+  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 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 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];
+  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 = readRuns(at, line, span);
+    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
+var _promises = require('fs/promises');
+var _path = require('path');
+
+// src/ocr/models.ts
+var OCR_DET_MODEL = {
+  name: "PP-OCRv5 mobile det",
+  filename: "det.onnx",
+  url: "https://huggingface.co/PaddlePaddle/PP-OCRv5_mobile_det_onnx/resolve/main/inference.onnx",
+  sha256: "a431985659dc921974177a95adcfbb90fd9e51989a5e04d70d0b75f597b6e61d",
+  sizeMb: 5
+};
+var OCR_REC_MODEL = {
+  name: "PP-OCRv5 korean rec",
+  filename: "rec_korean.onnx",
+  url: "https://huggingface.co/PaddlePaddle/korean_PP-OCRv5_mobile_rec_onnx/resolve/main/inference.onnx",
+  sha256: "92f0b7785e64fc9090106a241cf4c1eb97472824558272751b88a2a4476d3a08",
+  sizeMb: 13
+};
+var OCR_REC_DICT = {
+  name: "PP-OCRv5 korean dict",
+  filename: "rec_korean.yml",
+  url: "https://huggingface.co/PaddlePaddle/korean_PP-OCRv5_mobile_rec_onnx/resolve/main/inference.yml",
+  sha256: "f757fa1c40e99edcf27e9cce879b93eb2a51fa46f5ef39095689b8c37dd75998",
+  sizeMb: 1
+};
+var ALL_OCR_MODELS = [OCR_DET_MODEL, OCR_REC_MODEL, OCR_REC_DICT];
+function getOcrModelsDir() {
+  return _chunkQEJUY6SKcjs.getModelsDir.call(void 0, "ppocr");
+}
+async function ensureOcrModels(onProgress) {
+  return _chunkQEJUY6SKcjs.ensureModelsIn.call(void 0, getOcrModelsDir(), ALL_OCR_MODELS, onProgress);
+}
+function parseCharacterDict(yml) {
+  const lines = yml.split("\n");
+  const chars = [];
+  let inDict = false;
+  let dictIndent = -1;
+  for (const line of lines) {
+    if (!inDict) {
+      const m2 = /^(\s*)character_dict:\s*$/.exec(line);
+      if (m2) {
+        inDict = true;
+        dictIndent = m2[1].length;
+      }
+      continue;
+    }
+    const m = /^(\s*)- (.*)$/.exec(line);
+    if (m && m[1].length >= dictIndent) {
+      let v = m[2];
+      if (v.length >= 2 && (v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"'))) {
+        v = v.slice(1, -1).replace(/''/g, "'");
+      }
+      chars.push(v);
+      continue;
+    }
+    if (line.trim() !== "") break;
+  }
+  return chars;
+}
+
+// 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', _2 => _2[0], 'optionalAccess', _3 => _3[0]]), () => ( 0)), y1: _nullishCoalesce(_optionalChain([bands, 'access', _4 => _4[0], 'optionalAccess', _5 => _5[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 };
+}
+
+// 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");
+  s = s.replace(/\(cid:\d*\)/g, "");
+  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 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) || !_optionalChain([ends, 'access', _6 => _6.get, 'call', _7 => _7(it), 'optionalAccess', _8 => _8.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) || !_optionalChain([ends, 'access', _9 => _9.get, 'call', _10 => _10(it), 'optionalAccess', _11 => _11.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;
+    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,
+  splitLeaders: 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 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 {
+  
+  
+  
+  
+  
+  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", () => Promise.resolve().then(() => _interopRequireWildcard(require("onnxruntime-node")))),
+      tryImport(
+        "sharp",
+        () => Promise.resolve().then(() => _interopRequireWildcard(require("sharp")))
+      )
+    ]);
+    const sharpAny = sharpModRaw;
+    const sharpMod = typeof sharpAny === "function" ? sharpAny : _nullishCoalesce(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(_path.join.call(void 0, dir, OCR_DET_MODEL.filename), sessionOpts),
+      ortMod.InferenceSession.create(_path.join.call(void 0, dir, OCR_REC_MODEL.filename), sessionOpts),
+      _promises.readFile.call(void 0, _path.join.call(void 0, 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 (e2) {
+        }
+      }
+    }
+  }
+  /**
+   * 페이지 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 = [];
+    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) {
+          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;
+        }
+      }
+      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);
+    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 });
+    });
+    let items = [];
+    for (const { job, text: raw, confidence } of best.values()) {
+      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;
+      }
+      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, ...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);
+    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, vectorOps) {
+  const result = /* @__PURE__ */ new Map();
+  if (targets.size === 0) return result;
+  const pdfiumMod = await tryImport2(
+    "@hyzyla/pdfium",
+    () => Promise.resolve().then(() => _interopRequireWildcard(require("@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;
+      _optionalChain([onProgress, 'optionalCall', _12 => _12(++done, targets.size)]);
+      try {
+        const blocks = await withTimeout(
+          ocrOnePage(page, pageNo, mode, engine, warnings, detectTables, _optionalChain([vectorOps, 'optionalAccess', _13 => _13.get, 'call', _14 => _14(pageNo)])),
+          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, vectorOps) {
+  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 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) {
+      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;
+    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);
+  }
+  const sharpModRaw = await tryImport2(
+    "sharp",
+    () => Promise.resolve().then(() => _interopRequireWildcard(require("sharp")))
+  );
+  const sharpAny = sharpModRaw;
+  const sharp = typeof sharpAny === "function" ? sharpAny : _nullishCoalesce(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, opList = { fnArray: [], argsArray: [] }) {
+  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 _chunkUSHQCF5Tcjs.extractPageBlocksWithLines.call(void 0, norm, pageNumber, opList, 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;
+}
+
+
+
+
+
+
+
+
+
+exports.ensureOcrModels = ensureOcrModels; exports.getOcrEngine = getOcrEngine; exports.detectRulingLines = detectRulingLines; exports.rulingToPdfLines = rulingToPdfLines; exports.deskewPage = deskewPage; exports.runPdfOcr = runPdfOcr; exports.ocrItemsToBlocks = ocrItemsToBlocks;
+//# sourceMappingURL=chunk-IMAAFSAX.cjs.map