kordoc 4.1.0 → 4.2.1

package/dist/chunk-35U3MVA2.cjs

@@ -0,0 +1,560 @@
+"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 _chunkH7OWEYH2cjs = require('./chunk-H7OWEYH2.cjs');
+
+
+var _chunkR22KDUKWcjs = require('./chunk-R22KDUKW.cjs');
+
+// 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
+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 _chunkH7OWEYH2cjs.getModelsDir.call(void 0, "ppocr");
+}
+async function ensureOcrModels(onProgress) {
+  return _chunkH7OWEYH2cjs.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/engine.ts
+var DET_LONG_SIDE = 960;
+var DET_THRESH = 0.3;
+var DET_BOX_THRESH = 0.6;
+var DET_UNCLIP_RATIO = 1.5;
+var DET_MIN_SIZE = 3;
+var DET_MAX_BOXES = 1e3;
+var REC_HEIGHT = 48;
+var REC_MIN_WIDTH = 320;
+var REC_MAX_WIDTH = 3200;
+var TEXT_SCORE = 0.5;
+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 픽셀 → 텍스트 라인 인식.
+   * 반환 좌표는 입력 픽셀 기준. 라인은 위→아래, 좌→우 정렬.
+   */
+  async recognizePage(rgba, width, height) {
+    if (width < DET_MIN_SIZE || height < DET_MIN_SIZE) return [];
+    const boxes = await this.detect(rgba, width, height);
+    const items = [];
+    for (const b of boxes) {
+      const r = await this.recognizeLine(rgba, width, height, b);
+      if (r && r.confidence >= TEXT_SCORE && r.text.trim()) items.push(r);
+    }
+    items.sort((a, b) => a.y - b.y || a.x - b.x);
+    return items;
+  }
+  // ─── det ─────────────────────────────────────────────
+  async detect(rgba, width, height) {
+    const ratio = DET_LONG_SIDE / 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);
+    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 * DET_UNCLIP_RATIO / (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 ─────────────────────────────────────────────
+  async recognizeLine(rgba, width, height, box) {
+    const rw = Math.min(REC_MAX_WIDTH, Math.max(16, Math.round(box.w * REC_HEIGHT / box.h)));
+    const padded = Math.max(REC_MIN_WIDTH, rw);
+    const rgb = await this.sharp(rgba, { raw: { width, height, channels: 4 } }).extract({ left: box.x, top: box.y, width: box.w, height: box.h }).resize(rw, REC_HEIGHT, { fit: "fill" }).removeAlpha().raw().toBuffer();
+    const plane = padded * REC_HEIGHT;
+    const input = new Float32Array(3 * plane);
+    for (let y = 0; y < REC_HEIGHT; y++) {
+      for (let x = 0; x < rw; x++) {
+        const src = (y * rw + x) * 3;
+        const dst = y * padded + x;
+        input[dst] = rgb[src + 2] / 255 / 0.5 - 1;
+        input[plane + dst] = rgb[src + 1] / 255 / 0.5 - 1;
+        input[2 * plane + dst] = rgb[src] / 255 / 0.5 - 1;
+      }
+    }
+    const tensor = new this.ort.Tensor("float32", input, [1, 3, REC_HEIGHT, padded]);
+    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;
+    const decoded = ctcDecode(data, T, C, this.dict);
+    if (!decoded) return null;
+    return { text: decoded.text, x: box.x, y: box.y, w: box.w, h: box.h, confidence: decoded.confidence };
+  }
+};
+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) {
+  const visited = new Uint8Array(w * h);
+  const boxes = [];
+  const stack = [];
+  for (let start = 0; start < w * h; start++) {
+    if (visited[start] || prob[start] <= DET_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] > DET_THRESH) {
+        visited[p - 1] = 1;
+        stack.push(p - 1);
+      }
+      if (px < w - 1 && !visited[p + 1] && prob[p + 1] > DET_THRESH) {
+        visited[p + 1] = 1;
+        stack.push(p + 1);
+      }
+      if (py > 0 && !visited[p - w] && prob[p - w] > DET_THRESH) {
+        visited[p - w] = 1;
+        stack.push(p - w);
+      }
+      if (py < h - 1 && !visited[p + w] && prob[p + w] > DET_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 >= DET_BOX_THRESH).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/pdf-ocr.ts
+var OCR_RENDER_SCALE = 3;
+var PAGE_TIMEOUT_MS = 12e4;
+async function runPdfOcr(buffer, targets, mode, warnings, onProgress) {
+  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', _2 => _2(++done, targets.size)]);
+      try {
+        const blocks = await withTimeout(
+          ocrOnePage(page, pageNo, mode, engine, warnings),
+          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) {
+  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 items = await engine.recognizePage(rgba, rw, rh);
+    const scale = rh / pdfH;
+    const ruling = detectRulingLines(rgba, rw, rh, scale);
+    const extraLines = rulingToPdfLines(ruling, scale, pdfH);
+    return ocrItemsToBlocks(items, pageNo, pdfW, pdfH, scale, extraLines);
+  }
+  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) {
+  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),
+      fontSize: Math.max(1, Math.round(h * 0.8)),
+      // 박스높이는 어센더+디센더 포함 — 글자크기 근사
+      fontName: "ocr",
+      isHidden: false
+    };
+  });
+  return _chunkR22KDUKWcjs.extractPageBlocksWithLines.call(void 0, norm, pageNumber, { fnArray: [], argsArray: [] }, pdfW, pdfH, extraLines);
+}
+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.runPdfOcr = runPdfOcr; exports.ocrItemsToBlocks = ocrItemsToBlocks;
+//# sourceMappingURL=chunk-35U3MVA2.cjs.map