kordoc 4.17.2 → 4.17.4

package/dist/chunk-YIANW5QX.cjs

@@ -1,248 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/script-tags.ts
-function wrapScript(text, kind) {
-  if (!kind) return text;
-  const m = /^(\s*)([\s\S]*?)(\s*)$/.exec(text);
-  return m[2] ? `${m[1]}<${kind}>${m[2]}</${kind}>${m[3]}` : text;
-}
-function tidyScriptTags(text) {
-  if (!text.includes("<su")) return text;
-  return text.replace(/<\/(sup|sub)><\1>/g, "").replace(/<(sup|sub)>(\s+)/g, "$2<$1>").replace(/(\s+)<\/(sup|sub)>/g, "</$2>$1").replace(/<(sup|sub)><\/\1>/g, "");
-}
-function plainScripts(md) {
-  if (!md.includes("<su")) return md;
-  return md.replace(/<(sup|sub)>([^<\n]*)<\/\1>/g, (_, kind, body) => {
-    const mark = kind === "sup" ? "^" : "_";
-    return /^(?:[+\-−]?[\p{L}\p{N}]+|[*∗†‡§¶]+)$/u.test(body) ? mark + body : `${mark}(${body})`;
-  });
-}
-var TAG_RE = /<\/?su[bp]>/g;
-function stripScriptTags(r) {
-  const s = (t) => t.includes("<su") ? t.replace(TAG_RE, "") : t;
-  const walk = (bs) => {
-    for (const b of _nullishCoalesce(bs, () => ( []))) {
-      if (b.text) b.text = s(b.text);
-      if (b.footnoteText) b.footnoteText = s(b.footnoteText);
-      for (const sp of _nullishCoalesce(b.spans, () => ( []))) sp.text = s(sp.text);
-      walk(b.children);
-      if (b.table) {
-        if (b.table.caption) b.table.caption = s(b.table.caption);
-        walk(b.table.captionBlocks);
-        for (const row of b.table.cells) for (const c of row) {
-          c.text = s(c.text);
-          walk(c.blocks);
-        }
-      }
-    }
-  };
-  walk(r.blocks);
-  if (r.markdown) r.markdown = s(r.markdown);
-  for (const p of _nullishCoalesce(r.pages, () => ( []))) p.markdown = s(p.markdown);
-  return r;
-}
-
-// src/table/layout-frames.ts
-var CELL_EDGES = /* @__PURE__ */ new WeakMap();
-var CONTENT_CELLS = /* @__PURE__ */ new WeakSet();
-var FRACTION_MAX_CHARS = 40;
-function anchorsOf(t) {
-  const out = [];
-  const covered = /* @__PURE__ */ new Set();
-  for (let r = 0; r < t.rows; r++) for (let c = 0; c < t.cols; c++) {
-    if (covered.has(r * t.cols + c)) continue;
-    const cell = _optionalChain([t, 'access', _2 => _2.cells, 'access', _3 => _3[r], 'optionalAccess', _4 => _4[c]]);
-    if (!cell) continue;
-    const rs = Math.max(1, Math.min(cell.rowSpan, t.rows - r)), cs = Math.max(1, Math.min(cell.colSpan, t.cols - c));
-    for (let dr = 0; dr < rs; dr++) for (let dc = 0; dc < cs; dc++) covered.add((r + dr) * t.cols + c + dc);
-    out.push({ r, c, rs, cs, cell });
-  }
-  return out;
-}
-function ruleGrids(t, anchors) {
-  const H = Array.from({ length: t.rows + 1 }, () => new Array(t.cols).fill(false));
-  const V = Array.from({ length: t.rows }, () => new Array(t.cols + 1).fill(false));
-  for (const a of anchors) {
-    const e = _nullishCoalesce(CELL_EDGES.get(a.cell), () => ( { t: true, b: true, l: true, r: true }));
-    for (let c = a.c; c < a.c + a.cs; c++) {
-      if (e.t) H[a.r][c] = true;
-      if (e.b) H[a.r + a.rs][c] = true;
-    }
-    for (let r = a.r; r < a.r + a.rs; r++) {
-      if (e.l) V[r][a.c] = true;
-      if (e.r) V[r][a.c + a.cs] = true;
-    }
-  }
-  return { H, V };
-}
-function toTex(s) {
-  return s.replace(/<\/?u>/g, "").replace(/([\\{}%#&_$])/g, "\\$1").replace(/<sup>(.*?)<\/sup>/g, "^{$1}").replace(/<sub>(.*?)<\/sub>/g, "_{$1}").replace(/[가-힣ㄱ-ㅎㅏ-ㅣ][가-힣ㄱ-ㅎㅏ-ㅣ\s·ㆍ]*/g, (m) => `\\text{${m.trim()}}`).trim();
-}
-function fractionPart(cell) {
-  const t = cell.text.trim();
-  return !!t && !t.includes("\n") && !_optionalChain([cell, 'access', _5 => _5.blocks, 'optionalAccess', _6 => _6.length]) && t.replace(/<\/?(?:u|sup|sub)>/g, "").length <= FRACTION_MAX_CHARS && !/(?<!\\)\$/.test(t);
-}
-function mergeFractions(t, anchors, H, V) {
-  const at = /* @__PURE__ */ new Map();
-  for (const a of anchors) at.set(a.r * t.cols + a.c, a);
-  let merged = false;
-  for (const u of anchors) {
-    const d = at.get((u.r + u.rs) * t.cols + u.c);
-    if (!d || d.cs !== u.cs || u.rs !== 1 || d.rs !== 1 || !fractionPart(u.cell) || !fractionPart(d.cell)) continue;
-    if (u.cs === t.cols && anchors.length !== 2) continue;
-    const bar = d.r, c1 = u.c, c2 = u.c + u.cs;
-    let ok = true;
-    for (let c = c1; c < c2 && ok; c++) if (!H[bar][c]) ok = false;
-    if (!ok || c1 > 0 && H[bar][c1 - 1] || c2 < t.cols && H[bar][c2]) continue;
-    for (let c = c1; c < c2 && ok; c++) if (H[u.r][c] || H[d.r + d.rs][c]) ok = false;
-    for (let r = u.r; r < d.r + d.rs && ok; r++) if (V[r][c1] || V[r][c2]) ok = false;
-    if (!ok) continue;
-    u.cell.text = `$\\frac{${toTex(u.cell.text)}}{${toTex(d.cell.text)}}$`;
-    u.cell.rowSpan = u.rs + d.rs;
-    t.cells[d.r][d.c] = { text: "", colSpan: 1, rowSpan: 1 };
-    at.delete(d.r * t.cols + d.c);
-    merged = true;
-  }
-  return merged;
-}
-function ruledRows(t, anchors, H, V) {
-  const inRow = new Array(t.rows).fill(0);
-  for (const a of anchors) for (let r = a.r; r < a.r + a.rs; r++) inRow[r]++;
-  return Array.from({ length: t.rows }, (_, r) => V[r].some(Boolean) || inRow[r] >= 2 && H[r].every(Boolean) && H[r + 1].every(Boolean));
-}
-function bandTable(t, anchors, V, H, r0, r1, keepEmptyCols) {
-  let list = anchors.filter((a) => a.r >= r0 && a.r <= r1).map((a) => ({ ...a, rs: Math.min(a.rs, r1 - a.r + 1) }));
-  const blank = (a) => !a.cell.text.trim() && !_optionalChain([a, 'access', _7 => _7.cell, 'access', _8 => _8.blocks, 'optionalAccess', _9 => _9.length]) && !CONTENT_CELLS.has(a.cell);
-  const drop = [];
-  for (let r = r0; r <= r1; r++) {
-    if ((!H[r].some(Boolean) || !H[r + 1].some(Boolean)) && list.filter((a) => a.r === r).every(blank)) drop.push(r);
-  }
-  if (drop.length) {
-    const shift = (y) => y - drop.filter((d) => d < y).length;
-    list = list.filter((a) => !drop.includes(a.r)).map((a) => ({ ...a, r: shift(a.r), rs: shift(a.r + a.rs) - shift(a.r) })).filter((a) => a.rs > 0);
-  }
-  let lo = Infinity, hi = -Infinity;
-  for (let r = r0; r <= r1; r++) {
-    for (let c = 0; c <= t.cols; c++) if (V[r][c]) {
-      lo = Math.min(lo, c);
-      hi = Math.max(hi, c);
-    }
-    for (const rr of [r, r + 1]) for (let c = 0; c < t.cols; c++) if (H[rr][c]) {
-      lo = Math.min(lo, c);
-      hi = Math.max(hi, c + 1);
-    }
-  }
-  if (lo < hi) list = list.filter((a) => a.c < hi && a.c + a.cs > lo || a.cell.text.trim() || _optionalChain([a, 'access', _10 => _10.cell, 'access', _11 => _11.blocks, 'optionalAccess', _12 => _12.length]));
-  if (!list.length) return null;
-  for (let right = keepEmptyCols ? 0 : Math.max(...list.map((a) => a.c + a.cs)); right > 1; ) {
-    const starts = list.filter((a) => a.c === right - 1);
-    if (!starts.length || !starts.every(blank)) break;
-    list = list.filter((a) => a.c !== right - 1).map((a) => a.c + a.cs === right ? { ...a, cs: a.cs - 1 } : a);
-    right--;
-  }
-  const colB = /* @__PURE__ */ new Set(), rowB = /* @__PURE__ */ new Set();
-  for (const a of list) {
-    colB.add(a.c);
-    colB.add(a.c + a.cs);
-    rowB.add(a.r);
-    rowB.add(a.r + a.rs);
-  }
-  const cx = [...colB].sort((x, y) => x - y), rx = [...rowB].sort((x, y) => x - y);
-  const cols = cx.length - 1, rows = rx.length - 1;
-  if (cols < 1 || rows < 1) return null;
-  const cells = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ({ text: "", colSpan: 1, rowSpan: 1 })));
-  for (const a of list) {
-    const r = rx.indexOf(a.r), c = cx.indexOf(a.c);
-    a.cell.rowSpan = rx.indexOf(a.r + a.rs) - r;
-    a.cell.colSpan = cx.indexOf(a.c + a.cs) - c;
-    cells[r][c] = a.cell;
-  }
-  return { rows, cols, cells, hasHeader: t.hasHeader };
-}
-function textRow(row, out, pageNumber, keepEmptyCols) {
-  const parts = [];
-  const flush = () => {
-    if (!parts.length) return;
-    if (parts.length === 1) {
-      for (const line of parts[0].split("\n")) if (line.trim()) out.push({ type: "paragraph", text: line.trim(), pageNumber });
-    } else {
-      const text = parts.map((p) => p.replace(/\s*\n\s*/g, " ").trim()).filter(Boolean).join(" ");
-      if (text) out.push({ type: "paragraph", text, pageNumber });
-    }
-    parts.length = 0;
-  };
-  for (const a of row) {
-    if (_optionalChain([a, 'access', _13 => _13.cell, 'access', _14 => _14.blocks, 'optionalAccess', _15 => _15.length])) {
-      flush();
-      out.push(...unframeLayoutTables(a.cell.blocks, keepEmptyCols));
-      continue;
-    }
-    if (a.cell.text.trim()) parts.push(a.cell.text.trim());
-  }
-  flush();
-}
-function unframeTable(t, pageNumber, keepEmptyCols) {
-  let anchors = anchorsOf(t);
-  if (!anchors.some((a) => CELL_EDGES.has(a.cell))) return null;
-  let { H, V } = ruleGrids(t, anchors);
-  if (mergeFractions(t, anchors, H, V)) {
-    anchors = anchorsOf(t);
-    ({ H, V } = ruleGrids(t, anchors));
-  }
-  const ruled = ruledRows(t, anchors, H, V);
-  if (ruled.every(Boolean)) {
-    const whole = bandTable(t, anchors, V, H, 0, t.rows - 1, keepEmptyCols);
-    if (!whole || whole.rows === t.rows && whole.cols === t.cols) return null;
-    return [{ type: "table", table: { ...t, rows: whole.rows, cols: whole.cols, cells: whole.cells }, pageNumber }];
-  }
-  const out = [];
-  if (t.caption) out.push({ type: "paragraph", text: t.caption, pageNumber });
-  for (let r = 0; r < t.rows; ) {
-    if (ruled[r]) {
-      let r1 = r;
-      while (r1 + 1 < t.rows && ruled[r1 + 1]) r1++;
-      const sub = bandTable(t, anchors, V, H, r, r1, keepEmptyCols);
-      if (sub) out.push({ type: "table", table: sub, pageNumber });
-      r = r1 + 1;
-      continue;
-    }
-    textRow(anchors.filter((a) => a.r === r).sort((x, y) => x.c - y.c), out, pageNumber, keepEmptyCols);
-    r++;
-  }
-  return out;
-}
-function unframeLayoutTables(blocks, keepEmptyCols = false) {
-  const out = [];
-  for (const b of blocks) {
-    if (b.type !== "table" || !b.table) {
-      out.push(b);
-      continue;
-    }
-    const flat = unframeTable(b.table, b.pageNumber, keepEmptyCols);
-    const kept = _nullishCoalesce(flat, () => ( [b]));
-    for (const k of kept) {
-      if (k.type === "table" && k.table) {
-        for (const row of k.table.cells) for (const cell of row) if (_optionalChain([cell, 'access', _16 => _16.blocks, 'optionalAccess', _17 => _17.length])) cell.blocks = unframeLayoutTables(cell.blocks, keepEmptyCols);
-      }
-      out.push(k);
-    }
-  }
-  return out;
-}
-
-// src/types.ts
-var HEADING_RATIO_H1 = 1.5;
-var HEADING_RATIO_H2 = 1.3;
-var HEADING_RATIO_H3 = 1.15;
-
-
-
-
-
-
-
-
-
-
-
-
-exports.wrapScript = wrapScript; exports.tidyScriptTags = tidyScriptTags; exports.plainScripts = plainScripts; exports.stripScriptTags = stripScriptTags; exports.CELL_EDGES = CELL_EDGES; exports.CONTENT_CELLS = CONTENT_CELLS; exports.unframeLayoutTables = unframeLayoutTables; exports.HEADING_RATIO_H1 = HEADING_RATIO_H1; exports.HEADING_RATIO_H2 = HEADING_RATIO_H2; exports.HEADING_RATIO_H3 = HEADING_RATIO_H3;
-//# sourceMappingURL=chunk-YIANW5QX.cjs.map

package/dist/chunk-YIANW5QX.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/mong-e/workspace/kordoc-quality-99/dist/chunk-YIANW5QX.cjs","../src/script-tags.ts","../src/table/layout-frames.ts","../src/types.ts"],"names":[],"mappings":"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","file":"/Users/mong-e/workspace/kordoc-quality-99/dist/chunk-YIANW5QX.cjs","sourcesContent":[null,"/**\n * 위·아래첨자 표지 — 파서가 첨자 글을 인라인 HTML `<sup>`·`<sub>` 로 감싸 IR 글에 넣는다(밑줄 `<u>` 와 같은 방식,\n * GFM 에 첨자 문법이 없다). 평문으로 펴면 \"10⁴ m²\" 가 \"104 m2\", \"x_i\" 가 \"xi\" 로 값이 바뀐다.\n * HWPX·HWP5·DOCX 는 글자 모양 속성, PDF 는 기준선·글자 크기로 판정한다.\n */\n\nimport type { IRBlock } from \"./types.js\"\n\nexport type ScriptKind = \"sup\" | \"sub\"\n\n/** 첨자 글을 태그로 감싼다 — 앞뒤 공백은 태그 밖으로, 공백뿐이면 그대로 */\nexport function wrapScript(text: string, kind: ScriptKind | null | undefined): string {\n  if (!kind) return text\n  const m = /^(\\s*)([\\s\\S]*?)(\\s*)$/.exec(text)!\n  return m[2] ? `${m[1]}<${kind}>${m[2]}</${kind}>${m[3]}` : text\n}\n\n/** 조각마다 감싼 태그 정리 — 이웃한 같은 태그를 합치고, 태그 안 앞뒤 공백을 밖으로 내고, 빈 태그를 지운다 */\nexport function tidyScriptTags(text: string): string {\n  if (!text.includes(\"<su\")) return text\n  return text\n    .replace(/<\\/(sup|sub)><\\1>/g, \"\")\n    .replace(/<(sup|sub)>(\\s+)/g, \"$2<$1>\")\n    .replace(/(\\s+)<\\/(sup|sub)>/g, \"</$2>$1\")\n    .replace(/<(sup|sub)><\\/\\1>/g, \"\")\n}\n\n/**\n * 평문(`plain`) 표기 — 태그를 걷되 값이 바뀌지 않게 `^`·`_` 로: \"10^4\"·\"m^2\"·\"H_2O\"·\"x^(n+1)\".\n * 글자·숫자(와 앞 부호)만이거나 주석 기호뿐이면 괄호 없이, 그 밖은 괄호로 묶는다.\n */\nexport function plainScripts(md: string): string {\n  if (!md.includes(\"<su\")) return md\n  return md.replace(/<(sup|sub)>([^<\\n]*)<\\/\\1>/g, (_, kind: string, body: string) => {\n    const mark = kind === \"sup\" ? \"^\" : \"_\"\n    return /^(?:[+\\-−]?[\\p{L}\\p{N}]+|[*∗†‡§¶]+)$/u.test(body) ? mark + body : `${mark}(${body})`\n  })\n}\n\nconst TAG_RE = /<\\/?su[bp]>/g\n\n/**\n * 첨자 표기를 끈 결과(`scriptTags: false`, PDF·이미지 기본) — 마크다운·쪽별 마크다운·IR 글(문단·span·각주·목록·표 칸·캡션)에서\n * 태그만 걷는다. 파이프라인은 그대로 돌고 끝에서 걷으므로 글자 순서는 첨자 판정 전과 같다\n */\nexport function stripScriptTags<T extends { markdown?: string; blocks?: IRBlock[]; pages?: Array<{ markdown: string }> }>(r: T): T {\n  const s = (t: string) => (t.includes(\"<su\") ? t.replace(TAG_RE, \"\") : t)\n  const walk = (bs: IRBlock[] | undefined): void => {\n    for (const b of bs ?? []) {\n      if (b.text) b.text = s(b.text)\n      if (b.footnoteText) b.footnoteText = s(b.footnoteText)\n      for (const sp of b.spans ?? []) sp.text = s(sp.text)\n      walk(b.children)\n      if (b.table) {\n        if (b.table.caption) b.table.caption = s(b.table.caption)\n        walk(b.table.captionBlocks)\n        for (const row of b.table.cells) for (const c of row) { c.text = s(c.text); walk(c.blocks) }\n      }\n    }\n  }\n  walk(r.blocks)\n  if (r.markdown) r.markdown = s(r.markdown)\n  for (const p of r.pages ?? []) p.markdown = s(p.markdown)\n  return r\n}\n","/**\n * 보이지 않는 틀 표 풀기 — 한글 문서는 테두리를 없앤 표로 쪽을 짜는 일이 흔하다. 법령 별표 272건 중 103건이 본문 전체를\n * 안 보이는 틀 표에 담았고 표 381개 중 95개는 보이는 변이 하나도 없다(2026-09-29 실측). 구조대로 표로 내면 화면·LLM 이\n * 원본에 없는 격자를 본다(할부거래법 시행령 [별표 1]: 원본은 글과 분수뿐인데 5열 표 한 장).\n *\n * 칸마다 보이는 변(`CELL_EDGES` — HWPX borderFill·HWP5 BORDER_FILL·PDF 획)으로 두 가지를 한다.\n *  ① 분수 — 위아래로 붙은 두 칸 사이 가로선만 보이고 두 칸의 다른 변이 모두 안 보이는 짧은 한 줄 칸 쌍은 분수를 칸으로\n *     조립한 것이다(할부거래법 \"A=P×r× (1+r)ⁿ / (1+r)ⁿ-1\"). 한 칸 `$\\frac{위}{아래}$` 로 합친다.\n *  ② 행 띠 — 세로선이 보이는 행과, 위아래 가로선이 온 폭에 그어진 사이에 칸이 둘 이상인 행(가로선만 긋는 표)은 표 띠다.\n *     이어진 표 띠만 새 표로 다시 짜고(띠 안에서 쓰지 않는 행·열 경계와 선 밖 빈 칸은 접음) 나머지 행은 칸 글을 문단으로\n *     푼다. 칸 안 블록(중첩표)은 재귀로 같은 처리. 표 띠 칸 안의 중첩표도 본다.\n * 테두리 정보가 하나도 없는 표(다른 포맷)는 손대지 않는다. 호출자는 파서가 마크다운을 만들기 직전 — 왕복 패치·양식 채우기처럼\n * 원 구조가 필요한 경로는 `layoutTables: \"keep\"` 으로 건너뛴다.\n */\n\nimport type { IRBlock, IRCell, IRTable } from \"../types.js\"\n\n/** 칸의 보이는 변 */\nexport interface Edges { t: boolean; b: boolean; l: boolean; r: boolean }\n\n/** IR 칸 → 보이는 변. 공개 IR 에는 나가지 않는 곁정보 (파서가 채움) */\nexport const CELL_EDGES = new WeakMap<IRCell, Edges>()\n/** 글·블록 없이도 내용이 있는 칸 — PDF 는 칸 그림을 칸 글과 따로 뽑아 그림 칸의 text·blocks 가 빈다. 빈 여백 행 접기가 그림 행을\n *  접지 않게 파서가 표시한다 (경찰복제 [별표] 특수복식 도면 행) */\nexport const CONTENT_CELLS = new WeakSet<IRCell>()\n\n/** 분수 칸 글 상한(자) — 분자·분모는 식 조각이다. 문장 칸이 가로선 하나로 나뉜 것과 가른다 */\nconst FRACTION_MAX_CHARS = 40\n\ninterface Anchor { r: number; c: number; rs: number; cs: number; cell: IRCell }\n\nfunction anchorsOf(t: IRTable): Anchor[] {\n  const out: Anchor[] = []\n  const covered = new Set<number>()\n  for (let r = 0; r < t.rows; r++) for (let c = 0; c < t.cols; c++) {\n    if (covered.has(r * t.cols + c)) continue\n    const cell = t.cells[r]?.[c]\n    if (!cell) continue\n    const rs = Math.max(1, Math.min(cell.rowSpan, t.rows - r)), cs = Math.max(1, Math.min(cell.colSpan, t.cols - c))\n    for (let dr = 0; dr < rs; dr++) for (let dc = 0; dc < cs; dc++) covered.add((r + dr) * t.cols + c + dc)\n    out.push({ r, c, rs, cs, cell })\n  }\n  return out\n}\n\n/** 단위 격자의 보이는 가로선 H[r][c](행 r 윗변)·세로선 V[r][c](열 c 왼변) — 맞닿은 두 칸 가운데 하나라도 그으면 보인다 */\nfunction ruleGrids(t: IRTable, anchors: Anchor[]): { H: boolean[][]; V: boolean[][] } {\n  const H = Array.from({ length: t.rows + 1 }, () => new Array<boolean>(t.cols).fill(false))\n  const V = Array.from({ length: t.rows }, () => new Array<boolean>(t.cols + 1).fill(false))\n  for (const a of anchors) {\n    // 테두리 정보가 없는 칸은 보이는 칸으로 둔다 — 모르면 표를 지키는 쪽이다\n    const e = CELL_EDGES.get(a.cell) ?? { t: true, b: true, l: true, r: true }\n    for (let c = a.c; c < a.c + a.cs; c++) { if (e.t) H[a.r][c] = true; if (e.b) H[a.r + a.rs][c] = true }\n    for (let r = a.r; r < a.r + a.rs; r++) { if (e.l) V[r][a.c] = true; if (e.r) V[r][a.c + a.cs] = true }\n  }\n  return { H, V }\n}\n\n/** 분자·분모 글 → LaTeX. 첨자 태그는 ^{}·_{}, 한글 낱말은 \\text{} */\nfunction toTex(s: string): string {\n  return s\n    .replace(/<\\/?u>/g, \"\")\n    .replace(/([\\\\{}%#&_$])/g, \"\\\\$1\")\n    .replace(/<sup>(.*?)<\\/sup>/g, \"^{$1}\")\n    .replace(/<sub>(.*?)<\\/sub>/g, \"_{$1}\")\n    .replace(/[가-힣ㄱ-ㅎㅏ-ㅣ][가-힣ㄱ-ㅎㅏ-ㅣ\\s·ㆍ]*/g, m => `\\\\text{${m.trim()}}`)\n    .trim()\n}\n\n/** 분수 조각 칸 — 한 줄 짧은 글, 블록 없음 */\nfunction fractionPart(cell: IRCell): boolean {\n  const t = cell.text.trim()\n  return !!t && !t.includes(\"\\n\") && !cell.blocks?.length && t.replace(/<\\/?(?:u|sup|sub)>/g, \"\").length <= FRACTION_MAX_CHARS\n    && !/(?<!\\\\)\\$/.test(t)\n}\n\n/** ① 칸으로 조립한 분수를 한 칸으로 합친다. 합친 쌍이 있으면 true (anchors·격자는 새로 만들어야 함) */\nfunction mergeFractions(t: IRTable, anchors: Anchor[], H: boolean[][], V: boolean[][]): boolean {\n  const at = new Map<number, Anchor>()\n  for (const a of anchors) at.set(a.r * t.cols + a.c, a)\n  let merged = false\n  for (const u of anchors) {\n    const d = at.get((u.r + u.rs) * t.cols + u.c)\n    if (!d || d.cs !== u.cs || u.rs !== 1 || d.rs !== 1 || !fractionPart(u.cell) || !fractionPart(d.cell)) continue\n    // 표 온 폭을 차지하는 두 칸은 칸 두 개짜리 표(2×1 분수 표)일 때만 — 서식 끝 \"…귀하\"·\"210mm×297mm\" 칸, 제목과 본문 줄이\n    // 가로선 하나로 나뉜 모양이 분수로 잡혔다 (정답 그림 대조: 오탐 10건 → 0, 진짜 분수 9개 유지)\n    if (u.cs === t.cols && anchors.length !== 2) continue\n    const bar = d.r, c1 = u.c, c2 = u.c + u.cs\n    // 막대: 두 칸 사이 가로선이 두 칸 폭에만 — 옆 칸까지 이어지면 가로선만 긋는 표의 행 구분이다\n    let ok = true\n    for (let c = c1; c < c2 && ok; c++) if (!H[bar][c]) ok = false\n    if (!ok || (c1 > 0 && H[bar][c1 - 1]) || (c2 < t.cols && H[bar][c2])) continue\n    // 두 칸의 나머지 변은 모두 안 보여야 한다 (위·아래·좌·우)\n    for (let c = c1; c < c2 && ok; c++) if (H[u.r][c] || H[d.r + d.rs][c]) ok = false\n    for (let r = u.r; r < d.r + d.rs && ok; r++) if (V[r][c1] || V[r][c2]) ok = false\n    if (!ok) continue\n    u.cell.text = `$\\\\frac{${toTex(u.cell.text)}}{${toTex(d.cell.text)}}$`\n    u.cell.rowSpan = u.rs + d.rs\n    t.cells[d.r][d.c] = { text: \"\", colSpan: 1, rowSpan: 1 }\n    at.delete(d.r * t.cols + d.c)\n    merged = true\n  }\n  return merged\n}\n\n/** 표 띠 행 — 세로선이 보이거나, 온 폭 가로선 사이에 칸이 둘 이상 */\nfunction ruledRows(t: IRTable, anchors: Anchor[], H: boolean[][], V: boolean[][]): boolean[] {\n  const inRow = new Array<number>(t.rows).fill(0)\n  for (const a of anchors) for (let r = a.r; r < a.r + a.rs; r++) inRow[r]++\n  return Array.from({ length: t.rows }, (_, r) =>\n    V[r].some(Boolean) || (inRow[r] >= 2 && H[r].every(Boolean) && H[r + 1].every(Boolean)))\n}\n\n/** 표 띠 [r0, r1] → 새 표. 띠 안에서 시작하는 칸만, 띠 밖으로 나가는 병합은 자른다. 선 밖 빈 칸·안 쓰는 경계는 접는다 */\nfunction bandTable(t: IRTable, anchors: Anchor[], V: boolean[][], H: boolean[][], r0: number, r1: number, keepEmptyCols: boolean): IRTable | null {\n  let list = anchors.filter(a => a.r >= r0 && a.r <= r1).map(a => ({ ...a, rs: Math.min(a.rs, r1 - a.r + 1) }))\n  // 선 없이 붙은 빈 여백 행 — 그 행에서 시작하는 칸이 모두 비었고 윗선이나 아랫선이 표 폭 어디에도 없으면 그림에서 이웃 행과\n  // 한 행이다. 접는다 (양곡관리법·에너지이용 합리화법 별표 여백 행, 근로기준법 [별표 6] 여백 행 10개 — 정답 그림 대조 42→48/50.\n  // 윗선·아랫선 둘 다 없을 때만 접으면 에너지이용 합리화법 두 표가 안 접힌다)\n  const blank = (a: Anchor): boolean => !a.cell.text.trim() && !a.cell.blocks?.length && !CONTENT_CELLS.has(a.cell)\n  const drop: number[] = []\n  for (let r = r0; r <= r1; r++) {\n    if ((!H[r].some(Boolean) || !H[r + 1].some(Boolean)) && list.filter(a => a.r === r).every(blank)) drop.push(r)\n  }\n  if (drop.length) {\n    const shift = (y: number): number => y - drop.filter(d => d < y).length\n    list = list.filter(a => !drop.includes(a.r))\n      .map(a => ({ ...a, r: shift(a.r), rs: shift(a.r + a.rs) - shift(a.r) }))\n      .filter(a => a.rs > 0)\n  }\n  // 선이 닿는 열 범위 — 그 밖에 놓인 빈 칸(들여쓰기 칸)은 버린다\n  let lo = Infinity, hi = -Infinity\n  for (let r = r0; r <= r1; r++) {\n    for (let c = 0; c <= t.cols; c++) if (V[r][c]) { lo = Math.min(lo, c); hi = Math.max(hi, c) }\n    for (const rr of [r, r + 1]) for (let c = 0; c < t.cols; c++) if (H[rr][c]) { lo = Math.min(lo, c); hi = Math.max(hi, c + 1) }\n  }\n  if (lo < hi) list = list.filter(a => a.c < hi && a.c + a.cs > lo || a.cell.text.trim() || a.cell.blocks?.length)\n  if (!list.length) return null\n  // 후행 빈 열 — 띠에서 오른쪽 끝 열이 비면 자른다. 원래 표를 만들 때 builder 가 하는 트림(마크다운 가독성)을 띠 표에도 똑같이:\n  // 표 전체로는 글이 있어 남은 열이 한 띠에서만 비는 경우다(결재문서 점검표 \"□ | ■ | (빈 칸)\" — 생성 → 재파싱 왕복이 어긋났다).\n  // keepTrailingEmptyCols(#47 서식 입력란)면 builder 처럼 두고\n  for (let right = keepEmptyCols ? 0 : Math.max(...list.map(a => a.c + a.cs)); right > 1;) {\n    const starts = list.filter(a => a.c === right - 1)\n    if (!starts.length || !starts.every(blank)) break\n    list = list.filter(a => a.c !== right - 1).map(a => (a.c + a.cs === right ? { ...a, cs: a.cs - 1 } : a))\n    right--\n  }\n  const colB = new Set<number>(), rowB = new Set<number>()\n  for (const a of list) { colB.add(a.c); colB.add(a.c + a.cs); rowB.add(a.r); rowB.add(a.r + a.rs) }\n  const cx = [...colB].sort((x, y) => x - y), rx = [...rowB].sort((x, y) => x - y)\n  const cols = cx.length - 1, rows = rx.length - 1\n  if (cols < 1 || rows < 1) return null\n  const cells: IRCell[][] = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ({ text: \"\", colSpan: 1, rowSpan: 1 })))\n  for (const a of list) {\n    const r = rx.indexOf(a.r), c = cx.indexOf(a.c)\n    a.cell.rowSpan = rx.indexOf(a.r + a.rs) - r\n    a.cell.colSpan = cx.indexOf(a.c + a.cs) - c\n    cells[r][c] = a.cell\n  }\n  return { rows, cols, cells, hasHeader: t.hasHeader }\n}\n\n/** 글 띠 행 → 문단. 칸이 하나면 칸 안 줄마다, 여럿이면 칸 글을 공백으로 이은 한 문단. 칸 블록은 재귀로 푼다 */\nfunction textRow(row: Anchor[], out: IRBlock[], pageNumber: number | undefined, keepEmptyCols: boolean): void {\n  const parts: string[] = []\n  const flush = (): void => {\n    if (!parts.length) return\n    if (parts.length === 1) {\n      for (const line of parts[0].split(\"\\n\")) if (line.trim()) out.push({ type: \"paragraph\", text: line.trim(), pageNumber })\n    } else {\n      const text = parts.map(p => p.replace(/\\s*\\n\\s*/g, \" \").trim()).filter(Boolean).join(\" \")\n      if (text) out.push({ type: \"paragraph\", text, pageNumber })\n    }\n    parts.length = 0\n  }\n  for (const a of row) {\n    if (a.cell.blocks?.length) {\n      flush()\n      out.push(...unframeLayoutTables(a.cell.blocks, keepEmptyCols))\n      continue\n    }\n    if (a.cell.text.trim()) parts.push(a.cell.text.trim())\n  }\n  flush()\n}\n\n/** 표 하나 → 풀어낸 블록. 바꿀 게 없으면 null (원래 표 그대로) */\nfunction unframeTable(t: IRTable, pageNumber: number | undefined, keepEmptyCols: boolean): IRBlock[] | null {\n  let anchors = anchorsOf(t)\n  if (!anchors.some(a => CELL_EDGES.has(a.cell))) return null\n  let { H, V } = ruleGrids(t, anchors)\n  if (mergeFractions(t, anchors, H, V)) {\n    anchors = anchorsOf(t)\n    ;({ H, V } = ruleGrids(t, anchors))\n  }\n  const ruled = ruledRows(t, anchors, H, V)\n  if (ruled.every(Boolean)) {\n    // 표 전체가 표 띠여도 안 쓰는 격자선·선 밖 빈 칸·빈 여백 행은 접는다(한글 편집기 격자에만 있는 선, 86712 규제영향분석서 10×8 → 10×5).\n    // 모양이 그대로면 원래 표 객체(sourceId·캡션·곁정보)를 둔다\n    const whole = bandTable(t, anchors, V, H, 0, t.rows - 1, keepEmptyCols)\n    if (!whole || (whole.rows === t.rows && whole.cols === t.cols)) return null\n    return [{ type: \"table\", table: { ...t, rows: whole.rows, cols: whole.cols, cells: whole.cells }, pageNumber }]\n  }\n  const out: IRBlock[] = []\n  if (t.caption) out.push({ type: \"paragraph\", text: t.caption, pageNumber })\n  for (let r = 0; r < t.rows;) {\n    if (ruled[r]) {\n      let r1 = r\n      while (r1 + 1 < t.rows && ruled[r1 + 1]) r1++\n      const sub = bandTable(t, anchors, V, H, r, r1, keepEmptyCols)\n      if (sub) out.push({ type: \"table\", table: sub, pageNumber })\n      r = r1 + 1\n      continue\n    }\n    textRow(anchors.filter(a => a.r === r).sort((x, y) => x.c - y.c), out, pageNumber, keepEmptyCols)\n    r++\n  }\n  return out\n}\n\n/** 블록 목록의 보이지 않는 틀 표를 푼다 (표 띠에 남은 칸 안 블록까지). 새 배열을 돌려준다.\n *  keepEmptyCols = ParseOptions.keepTrailingEmptyCols (띠 표의 후행 빈 열을 자르지 않는다) */\nexport function unframeLayoutTables(blocks: IRBlock[], keepEmptyCols = false): IRBlock[] {\n  const out: IRBlock[] = []\n  for (const b of blocks) {\n    if (b.type !== \"table\" || !b.table) { out.push(b); continue }\n    const flat = unframeTable(b.table, b.pageNumber, keepEmptyCols)\n    const kept = flat ?? [b]\n    for (const k of kept) {\n      if (k.type === \"table\" && k.table) {\n        for (const row of k.table.cells) for (const cell of row) if (cell.blocks?.length) cell.blocks = unframeLayoutTables(cell.blocks, keepEmptyCols)\n      }\n      out.push(k)\n    }\n  }\n  return out\n}\n","/** kordoc 공통 타입 정의 */\n\n// ─── 중간 표현 (Intermediate Representation) ─────────\n\nexport interface CellContext {\n  text: string\n  colSpan: number\n  rowSpan: number\n  /** HWP5 셀 열 주소 (0-based) — 병합 테이블 배치용 */\n  colAddr?: number\n  /** HWP5 셀 행 주소 (0-based) — 병합 테이블 배치용 */\n  rowAddr?: number\n}\n\n/** 블록 타입 — v2.0에서 heading, list, image, separator 추가 */\nexport type IRBlockType = \"paragraph\" | \"table\" | \"heading\" | \"list\" | \"image\" | \"separator\"\n\n/** 인라인 강조 run-span — 문단 텍스트를 서식 단위로 쪼갠 조각 (텍스트 연결 = block.text) */\nexport interface IRSpan {\n  text: string\n  bold?: boolean\n  italic?: boolean\n  strike?: boolean\n  /** 밑줄 — 개정문 추가·변경 표시 등. GFM 문법이 없어 <u>…</u> 인라인 HTML 로 방출 */\n  underline?: boolean\n  code?: boolean\n  /**\n   * 미기입 누름틀의 안내문(HWPX CLICK_HERE, 수정 안 됨). 한컴은 화면에만 흐리게 보이고 인쇄하지 않는다.\n   * 블록 `text` 에는 남기고(양식 채우기·패치가 원문 자리와 맞대도록) 마크다운에서는 뺀다 (v4.14.3)\n   */\n  placeholder?: boolean\n}\n\nexport interface IRBlock {\n  type: IRBlockType\n  /** 블록 글. HWPX·HWP5·HWP3 은 원문의 리터럴 `$` 를 `\\$` 로 담고 `$…$`·`$$…$$` 는 수식 스팬에만 쓴다 (v4.14.3) */\n  text?: string\n  table?: IRTable\n  /** 헤딩 레벨 (1-6), type=\"heading\"일 때 사용 */\n  level?: number\n  /** 원본 페이지 번호 (1-based) */\n  pageNumber?: number\n  /** 바운딩 박스 — PDF에서만 제공 */\n  bbox?: BoundingBox\n  /** 텍스트 스타일 정보 (선택) */\n  style?: InlineStyle\n  /** 리스트 타입, type=\"list\"일 때 사용 */\n  listType?: \"ordered\" | \"unordered\"\n  /** 중첩 리스트 아이템 */\n  children?: IRBlock[]\n  /** 하이퍼링크 URL */\n  href?: string\n  /** 각주/미주 텍스트 (인라인 삽입용) */\n  footnoteText?: string\n  /** 이미지 데이터 (type=\"image\"일 때) */\n  imageData?: ImageData\n  /** 인라인 강조 run-span (선택 — kordoc 생성 hwpx 왕복 채널 + 외래 실속성 볼드/이탤릭).\n   *  존재하면 마크다운 변환이 **·*·` 마커를 재방출한다 */\n  spans?: IRSpan[]\n  /** 인용문 문단 (선택 — kordoc 생성 hwpx 왕복 채널) — 마크다운 변환이 \"> \" 접두 재방출 */\n  quote?: boolean\n  /**\n   * 문단 들여쓰기(HWPUNIT, 선택) — HWPX paraPr `<hh:margin>` 자식요소형 hc:left\n   * (+양수 hc:intent 첫줄분). 마크다운 방출엔 쓰지 않는 관찰 슬롯 — gongmun 리스트\n   * depth 재유도·양식 분석 등 소비자 몫 (v4.0.4)\n   */\n  indent?: number\n  /**\n   * gongmun 리스트 단계(1~7, 선택) — indent를 levelIndent 단위로 역산한 소비 결과\n   * (v4.0.5). md 리스트 문법과 충돌하는 부호('- '·'1) ') 문단에만 채워지며,\n   * 마크다운 변환이 2칸/단계 선행 공백을 방출해 재생성 시 depth가 복원된다\n   */\n  listDepth?: number\n}\n\n/** 추출된 이미지 바이너리 데이터 */\nexport interface ImageData {\n  /** 이미지 바이너리 */\n  data: Uint8Array\n  /** MIME 타입 (image/png, image/jpeg, image/gif, image/bmp, image/wmf, image/emf) */\n  mimeType: string\n  /** 원본 파일명 (있는 경우) */\n  filename?: string\n}\n\n/** 바운딩 박스 — PDF 포인트 단위 (72pt = 1인치) */\nexport interface BoundingBox {\n  page: number\n  x: number\n  y: number\n  width: number\n  height: number\n}\n\n/** 인라인 텍스트 스타일 */\nexport interface InlineStyle {\n  bold?: boolean\n  italic?: boolean\n  /** 취소선 — 법령 개정문 등의 삭제 표시. 판정은 취소선 모양 whitelist (비트만 믿으면 오탐) */\n  strike?: boolean\n  /** 밑줄 — 판정은 밑줄 종류 BOTTOM 한정 (NONE 이 기본 잡음, 코퍼스 실측) */\n  underline?: boolean\n  fontSize?: number\n  fontName?: string\n}\n\n// ─── 표 분류 계약 (#76) — 분류기 내부 점수 구조(TableSignals)는 노출하지 않는다 ───\n\nexport type TableClassificationKind = \"semantic-table\" | \"non-tabular-layout\" | \"uncertain\"\n\nexport type TableClassificationReason =\n  | \"repeated-row-schema\"\n  | \"grid-regularity\"\n  | \"high-active-density\"\n  | \"column-type-consistency\"\n  | \"nested-structure-wrapper\"\n  | \"span-irregularity\"\n  | \"spacer-bands\"\n  | \"extreme-sparsity\"\n  | \"diagram-context-keyword\"\n  | \"low-evidence\"\n  | \"ambiguous-scores\"\n\n/** 휴리스틱 분류 결과 — confidence 는 확률이 아니라 두 점수의 격차 */\nexport interface TableClassificationSummary {\n  kind: TableClassificationKind\n  confidence: number\n  semanticScore: number\n  nonTabularScore: number\n  reasons: TableClassificationReason[]\n}\n\nexport interface IRTable {\n  rows: number\n  cols: number\n  cells: IRCell[][]\n  /** PDF에서 행 경계가 확인된 1열 데이터 표. 목록성 1열 틀의 평탄화와 구분한다. */\n  renderAsTable?: boolean\n  /** 첫 행을 헤더로 렌더링할지 여부 (현재: rows > 1이면 true — 의미적 감지가 아닌 레이아웃 힌트) */\n  hasHeader: boolean\n  /** opt-in 분류(`ParseOptions.classifyTables`) 결과 — #76 */\n  classification?: TableClassificationSummary\n  /** 원본 표 식별자(HWPX `hp:tbl id`) — 렌더 region(`RenderRegion.sourceId`)과의 조인 키 */\n  sourceId?: string\n  /** 렌더 인프라가 준 페이지 로컬 pt 조각(다중 페이지 표는 여럿) — extractTables 가 채운다 */\n  regions?: BoundingBox[]\n  /** 표 캡션 (예: \"표 1. 부서별 예산\") — v3.0 */\n  caption?: string\n  /**\n   * 캡션 내부 블록 콘텐츠 — v4.2.8 (#55).\n   * 캡션 안 중첩표·문단을 구조 그대로, 원문 순서대로 보존한다 (IRCell.blocks와 같은 계약).\n   * 표가 있을 때만 채워지며, caption은 하위 호환용 평탄화 문자열로 계속 제공된다.\n   */\n  captionBlocks?: IRBlock[]\n}\n\nexport interface IRCell {\n  text: string\n  colSpan: number\n  rowSpan: number\n  /**\n   * 셀 내부 블록 콘텐츠 — v3.0.\n   * 중첩 표·이미지 등 구조 콘텐츠(또는 왕복 채널 span 문단)가 있는 셀에만 채워지며,\n   * 그 안의 문단·표·이미지를 문서(원문) 순서대로 보존한다. 다중 문단뿐인 평문 셀은\n   * blocks 없이 text 평탄화(문단을 `\\n`으로 결합)로만 제공된다 (blocks 무게 억제, #57).\n   * 표와 텍스트가 한 줄에 번갈아 놓인 셀도 배치 순서를 따른다 (v4.2.3, #49).\n   * blocks가 있으면 text는 blocks의 평탄화 텍스트(하위 호환용)다.\n   */\n  blocks?: IRBlock[]\n  /** 제목 셀 여부 (HWP5 width_ref bit2 / HWPX header 속성) — v3.0 */\n  isHeader?: boolean\n}\n\n// ─── 메타데이터 ─────────────────────────────────────\n\n/** 문서 메타데이터 — 각 포맷에서 추출 가능한 필드만 채워짐 */\nexport interface DocumentMetadata {\n  /** 문서 제목 */\n  title?: string\n  /** 작성자 */\n  author?: string\n  /** 작성 프로그램 (예: \"한글 2020\", \"Adobe Acrobat\") */\n  creator?: string\n  /** 생성일시 (ISO 8601) */\n  createdAt?: string\n  /** 수정일시 (ISO 8601) */\n  modifiedAt?: string\n  /** 페이지/섹션 수 — pageMode=\"layout\"이면 실제 페이지 수, \"section\"이면 섹션 수 */\n  pageCount?: number\n  /**\n   * 페이지 경계 신뢰도 (#66) — \"layout\": 조판 정보 기반 실제 페이지\n   * (한컴 저장본 HWP/HWPX·PDF·COM), \"section\": 섹션 단위 근사\n   * (조판 캐시 없는 생성 파일). HWP/HWPX/PDF에서만 설정된다.\n   */\n  pageMode?: \"layout\" | \"section\"\n  /** 문서 포맷 버전 (예: HWP \"5.1.0.1\") */\n  version?: string\n  /** 설명 */\n  description?: string\n  /** 키워드 */\n  keywords?: string[]\n}\n\n// ─── 파싱 옵션 ──────────────────────────────────────\n\n/** 파싱 옵션 — parse() 함수에 전달 */\nexport interface ParseOptions {\n  /**\n   * 파싱할 페이지/섹션 범위 (1-based).\n   * - 배열: [1, 2, 3]\n   * - 문자열: \"1-3\", \"1,3,5-7\"\n   *\n   * PDF: 정확한 페이지 단위. HWP/HWPX: 섹션 단위 근사치.\n   */\n  pages?: number[] | string\n  /** 이미지 기반 PDF OCR (선택).\n   *  - 지정 안 함(기본): 내장 모델이 이미 캐시에 있으면(`kordoc models` 로 받았거나 앞서 `ocr: true` 로 받은 경우) 텍스트층이\n   *    없는 쪽(스캔·글자를 곡선으로 그린 쪽)과 글 없는 큰 그림(쪽 면적 5% 넘는) 속 글을 자동 인식한다. 모델이 없으면 다운로드하지\n   *    않고 NEEDS_OCR·SKIPPED_IMAGE 경고만.\n   *  - `false`: 끈다.\n   *  - `true`: 내장 엔진(PP-OCRv5 korean, ~18MB 자동 다운로드)으로 OCR 필요 판정\n   *    페이지만 인식 (스캔 페이지·글꼴 매핑 깨진 페이지). 정상 페이지는 파싱 결과 유지.\n   *  - `\"force\"`: 전 페이지를 내장 엔진으로 강제 OCR.\n   *  - 함수: 사용자 제공 OcrProvider (Claude Vision·Tesseract 등) — 판정은 `true`와 동일. */\n  ocr?: boolean | \"force\" | OcrProvider\n  /** 진행률 콜백 — current: 현재 페이지/섹션, total: 전체 수 */\n  onProgress?: (current: number, total: number) => void\n  /** PDF 머리글/바닥글 자동 제거 */\n  removeHeaderFooter?: boolean\n  /**\n   * 위·아래첨자를 인라인 HTML `<sup>`·`<sub>` 로 표기 — 평문으로 펴면 \"10⁴ m²\" 가 \"104 m2\", \"x_i\" 가 \"xi\" 로 값이 바뀐다.\n   * 기본: HWPX·HWP·DOCX 켬(글자 모양에 적힌 첨자), PDF 끔(글자 크기·기준선으로 추정 — 논문·수식 문서는 true 권장.\n   * 공개 벤치 ODL 정답이 첨자를 평문으로 적어 기본값을 두지 않는다). false 면 모든 형식에서 평문. OCR 로 읽은 글은 늘 평문\n   */\n  scriptTags?: boolean\n  /** 평문 Markdown — 그림 자리 표시·링크 URL·밑줄(`<u>`)·굵게(`**`) 표기를 빼고 글만 (제목·목록·표 구조는 유지).\n   *  첨자 `<sup>`·`<sub>` 는 값이 남게 `10^4`·`H_2O` 로 편다. 이미지 바이트를 따로 저장하지 않는 색인·RAG 용. 기본 false. `blocks` IR 은 그대로 */\n  plain?: boolean\n  /** 모든 표를 HTML 로 — 파이프 표도 HTML 표로 옮기고, 표마다 태그를 한 줄씩 들여써 낸다(BeautifulSoup prettify 모양, 첫 행 `<th>`).\n   *  HTML 표만 다루는 소비자·채점기용. 기본 false(병합·중첩 없는 표는 GFM 파이프 표) */\n  htmlTables?: boolean\n  /** 표 오른쪽 끝의 빈 열(서식 문서의 입력란) 보존 (#47).\n   *  기본 false: 마크다운 가독성을 위해 후행 빈 열을 트림.\n   *  양식 인식 경로(parse_form·fill)는 내부적으로 항상 켠다. */\n  keepTrailingEmptyCols?: boolean\n  /** 테두리가 안 보이는 틀 표 처리 (v4.17.0). 기본 `\"visual\"`: 보이는 대로 — 선이 없는 틀은 글로 풀고 선이 보이는 부분만 표로,\n   *  칸으로 조립한 분수는 `$\\frac{…}{…}$` 수식으로. `\"keep\"`: 종전대로 원본 표 구조 그대로(왕복 패치·양식 채우기처럼\n   *  원본 표 서수가 필요한 경로). HWPX·HWP5·PDF */\n  layoutTables?: \"visual\" | \"keep\"\n  /** 구조 파싱 뒤 표를 의미표/레이아웃/불확실로 분류해 `IRTable.classification` 에 붙인다 (#76).\n   *  기본 false — 기본 parse 출력 불변. 중첩표·셀 blocks·캡션 blocks 까지 재귀, 원문 순서는 바꾸지 않는다. */\n  classifyTables?: boolean\n  /** 빈 문단(텍스트 없는 hp:p) 보존 (#57). 기본 false: 종전대로 빈 문단 제거.\n   *  켜면 본문은 `text: \"\"` paragraph 블록으로, 표 셀은 빈 줄로 순서대로 보존해\n   *  \"원문 문단 수 = 줄 수\" 대응을 유지한다 (행 줄맞춤 서식 문서용).\n   *  개체(표·이미지·글상자)만 있는 문단은 개체 출력이 따로 있어 대상이 아니다.\n   *  현재 HWPX 경로 적용. */\n  keepEmptyParagraphs?: boolean\n  /** 미기입 누름틀 안내문도 마크다운에 낸다 (#92). 기본 false: 종전대로 뺀다(한컴은 화면에만 흐리게 보이고 인쇄하지 않는 글).\n   *  빈 서식 문서에서 \"이 칸에 무엇을 적나\"(예: \"학교명 기재 금지\")가 안내문뿐일 때 켠다. HWPX·HWP5 */\n  includeFieldPlaceholders?: boolean\n  /** 비밀번호로 보호된 문서의 열기 암호.\n   *  HWPX(ODF AES-256-CBC)·HWP3(DES) 지원. 한컴 DRM(문서 보안)은 별개라 해당 없음. */\n  password?: string\n  /** 원본 파일 경로 (DRM COM fallback에 필요, 내부 전용) */\n  filePath?: string\n  /**\n   * PDF 수식 OCR 활성화 (기본 false).\n   *\n   * 활성화 시 각 PDF 페이지를 이미지로 렌더링 → YOLOv8 기반 수식 영역 검출 →\n   * TrOCR 기반 LaTeX 인식. 감지된 수식은 `$...$` (inline) / `$$...$$` (display) 로\n   * 블록 텍스트에 삽입된다.\n   *\n   * 필수 optional 의존성: `onnxruntime-node`, `@huggingface/transformers`,\n   * `@hyzyla/pdfium`, `sharp`. 미설치 시 parse 에 실패하지 않고 **경고만** 남기고\n   * 수식 인식은 skip 한다 (일반 텍스트 추출은 정상 동작).\n   *\n   * 모델(~155MB) 은 첫 사용 시 HuggingFace 에서 자동 다운로드 되어\n   * `~/.cache/kordoc/models/pix2text/` 에 SHA-256 검증과 함께 저장된다.\n   */\n  formulaOcr?: boolean\n  /**\n   * 레이아웃 표 페이지 반복 헤더(러닝 헤더) 정리 휴리스틱 활성화 (기본 false).\n   *\n   * 구형 HWP5 문서가 페이지마다 재삽입한 짧은 번호매김 러닝 헤더\n   * (\"2. 과제 구축 내용\")를 최초 1회만 남기고 이후 중복을 제거한다.\n   * 다만 페이지 위치 정보가 없는 HWP5 특성상 이 휴리스틱은 정당하게 반복되는\n   * 번호매김 문단(예: 붙임/별지별 재번호 \"1. 목적\")도 삭제할 수 있어 opt-in 으로\n   * 둔다. 활성 시 제거가 발생하면 HIDDEN_TEXT_FILTERED 경고를 남긴다.\n   */\n  dedupeRunningHeaders?: boolean\n  /**\n   * 추출된 이미지를 마크다운에 base64 data URI 로 인라인 (기본 false).\n   *\n   * 활성화 시 `![image](image_001.bmp)` 참조를 `![image](data:image/png;base64,...)` 로\n   * 치환한다. 임베드된 BMP 는 PNG 로 무손실 압축 후 인라인하여 용량을 크게 줄인다.\n   * 별도 이미지 파일 없이 자체 완결형 마크다운이 되어 MCP/AI 에이전트 소비에 적합하다.\n   * (현재 HWP5 경로 지원)\n   */\n  inlineImages?: boolean\n  /**\n   * 이미지 바이트 추출 (기본 true). false 면 결과에 이미지 바이트를 싣지 않는다.\n   * `images` 는 비고, 블록의 `imageData` 도 떼며, HWP5 `inlineImages` 도 무시한다.\n   * 그림 자리 표시(`![image](…)`)는 마크다운·블록에 그대로 남아 위치는 알 수 있다.\n   * PDF 는 PNG 인코딩을 건너뛴다. 거르는 기준은 같되 메모리 보호용 128MB 누적 상한은 걸리지\n   * 않아, 그 상한 뒤의 그림도 자리 표시가 남는다. DOCX 는 그림 파트(`word/media`·`word/embeddings`)를\n   * 풀지 않고 ZIP 비압축 상한(100MB)에도 세지 않는다 (#108).\n   *\n   * 검색 색인처럼 글자만 필요한 호출자용이다. 그림이 많은 문서는 base64 로 불어난 이미지가\n   * JSON 출력의 대부분을 차지했다 (PDF 실측 200MB → 9.5MB, CPU 시간 30% 감소). 본문 글자와\n   * OCR 은 이 옵션과 무관하다.\n   */\n  images?: boolean\n  /**\n   * PDF 표 감지 활성화 (기본 true). false 면 선 기반 그리드·클러스터 표 감지를 모두 끄고\n   * 자연 읽기순 텍스트만 뽑는다 (#64).\n   *\n   * 시각적 테두리 박스(시험지 안내문·보기 상자)가 표로 잡히면 주변 본문이 셀 매핑으로\n   * 끌려 들어가 문항 순서가 뒤집히는데, 표가 애초에 필요 없는 텍스트 중심 사용처에는\n   * 우회 수단이 없었다. 표가 실제로 있는 문서에 켜면 표 구조가 문단으로 흩어지므로\n   * 문서 종류를 아는 호출자만 쓰는 opt-out 이다. PDF 전용 — 다른 포맷은 무시.\n   */\n  tables?: boolean\n}\n\n// ─── 파싱 경고 ──────────────────────────────────────\n\n/** 파싱 중 스킵/실패한 요소 보고 */\nexport interface ParseWarning {\n  /** 관련 페이지 번호 (알 수 있는 경우) */\n  page?: number\n  /** 경고 메시지 */\n  message: string\n  /** 구조화된 경고 코드 */\n  code: WarningCode\n}\n\nexport type WarningCode =\n  | \"SKIPPED_IMAGE\"\n  | \"SKIPPED_OLE\"\n  | \"TRUNCATED_TABLE\"\n  | \"OCR_FALLBACK\"\n  | \"UNSUPPORTED_ELEMENT\"\n  | \"BROKEN_ZIP_RECOVERY\"\n  | \"HIDDEN_TEXT_FILTERED\"\n  | \"MALFORMED_XML\"\n  | \"PARTIAL_PARSE\"\n  | \"LENIENT_CFB_RECOVERY\"\n  | \"NEEDS_OCR\"\n  | \"OCR_FAILED\"\n  | \"OCR_APPLIED\"\n  | \"OCR_LOW_CONF\"\n  | \"COM_EMPTY\"\n  | \"DRM_COM_FALLBACK\"\n  /** pages 옵션 요청됐으나 조판 캐시가 없어 섹션 단위 근사로 적용됨 (#66) */\n  | \"PAGE_BOUNDARY_APPROXIMATE\"\n\n/** 문서 구조 (헤딩 트리) */\nexport interface OutlineItem {\n  level: number\n  text: string\n  pageNumber?: number\n}\n\n// ─── 에러 코드 ──────────────────────────────────────\n\n/** 구조화된 에러 코드 — 프로그래밍적 에러 핸들링용 */\nexport type ErrorCode =\n  | \"EMPTY_INPUT\"\n  | \"UNSUPPORTED_FORMAT\"\n  | \"ENCRYPTED\"\n  | \"DRM_PROTECTED\"\n  | \"CORRUPTED\"\n  | \"DECOMPRESSION_BOMB\"\n  | \"ZIP_BOMB\"\n  | \"IMAGE_BASED_PDF\"\n  | \"NO_SECTIONS\"\n  | \"PARSE_ERROR\"\n  | \"MISSING_DEPENDENCY\"\n  /** 결과 직렬화가 런타임 문자열 한계를 넘음 — 이미지 다량 문서의 JSON 출력 (#65) */\n  | \"OUTPUT_TOO_LARGE\"\n  /** 입력 경로가 존재하지 않음(ENOENT) — 문서 파싱 이전 단계의 실패 */\n  | \"FILE_NOT_FOUND\"\n\n// ─── 파싱 결과 (discriminated union) ────────────────\n\n/** 감지된 파일 형식. pptx는 감지만 지원하며 파싱 시 UNSUPPORTED_FORMAT을 반환한다. */\nexport type FileType = \"hwpx\" | \"hwp\" | \"hwp3\" | \"hwpml\" | \"pdf\" | \"xlsx\" | \"xls\" | \"docx\" | \"pptx\" | \"image\" | \"unknown\"\n\ninterface ParseResultBase {\n  fileType: FileType\n  /** 페이지/섹션 수 — PDF: 실제 페이지 수, HWP/HWPX: 섹션 수, XLSX: 시트 수 */\n  pageCount?: number\n  /** 이미지 기반 PDF 여부 (텍스트 추출 불가) */\n  isImageBased?: boolean\n}\n\nexport interface ParseSuccess extends ParseResultBase {\n  success: true\n  /** 추출된 마크다운 텍스트 */\n  markdown: string\n  /**\n   * 중간 표현 블록 (구조화된 데이터 접근용).\n   * 블록은 문서(원문) 읽기 순서를 따른다 — 한 문단 안에 글자취급(treatAsChar)\n   * 표와 텍스트가 섞여 있어도 배치 순서대로 방출된다 (v4.2.3, #50).\n   */\n  blocks: IRBlock[]\n  /** 문서 메타데이터 */\n  metadata?: DocumentMetadata\n  /** 문서 구조 (헤딩 트리) — v2.0 */\n  outline?: OutlineItem[]\n  /** 파싱 중 발생한 경고 — v2.0 */\n  warnings?: ParseWarning[]\n  /** 추출된 이미지 목록 — 마크다운에서 파일명으로 참조됨 */\n  images?: ExtractedImage[]\n  /**\n   * 페이지별 마크다운 (#68) — `blocks` 의 `pageNumber` 로 갈라 페이지마다 다시\n   * 마크다운을 만든 것. 페이지 경계의 신뢰도는 `metadata.pageMode` 를 따른다\n   * (\"layout\" = 실제 페이지, \"section\" = 섹션 근사). `pages` 옵션으로 범위를\n   * 줄이면 그 범위만 담긴다. 페이지 번호를 매기지 않는 포맷(DOCX 등)에서는 없고,\n   * XLSX 는 `pageCount` 와 같은 의미로 시트 한 장이 한 쪽이다.\n   *\n   * 여러 페이지에 걸친 표는 시작 페이지 한 블록이라, 표가 이어지는 중간\n   * 페이지의 `markdown` 은 빈 문자열일 수 있다 (현 IR 구조의 한계).\n   */\n  pages?: PageMarkdown[]\n  /** 페이지별 텍스트 품질 신호 — PDF에서만 제공 */\n  pageQuality?: PageQuality[]\n  /** 문서 단위 품질 요약 — PDF에서만 제공 */\n  qualitySummary?: DocumentQualitySummary\n}\n\n/** 페이지 한 장의 마크다운 (#68). ParseSuccess.pages 항목. */\nexport interface PageMarkdown {\n  /** 원본 페이지 번호 (1-based) */\n  pageNumber: number\n  /** 그 페이지 블록만으로 만든 마크다운. 블록이 없으면 빈 문자열 */\n  markdown: string\n}\n\n/** 페이지별 텍스트 품질 신호 (PDF 전용). 자세한 설명은 src/pdf/quality.ts */\nexport interface PageQuality {\n  page: number\n  textChars: number\n  hangulRatio: number\n  controlCharRatio: number\n  replacementCharRatio: number\n  puaRatio: number\n  needsOcr: boolean\n  ocrReason?: \"vector_text\" | \"low_text\" | \"high_pua\" | \"high_control\" | \"high_replacement\" | \"garbled_hangul\"\n}\n\n/** 문서 단위 품질 요약 (PDF 전용). */\nexport interface DocumentQualitySummary {\n  totalPages: number\n  totalTextChars: number\n  avgHangulRatio: number\n  avgControlCharRatio: number\n  avgReplacementCharRatio: number\n  avgPuaRatio: number\n  lowTextPageCount: number\n  highPuaPageCount: number\n  needsOcr: boolean\n  ocrCandidatePages: number[]\n}\n\n/** 추출된 이미지 — ParseSuccess.images에 포함 */\nexport interface ExtractedImage {\n  /** 마크다운에서 참조되는 파일명 (예: image_001.png) */\n  filename: string\n  /** 이미지 바이너리 */\n  data: Uint8Array\n  /** MIME 타입 */\n  mimeType: string\n  /** 원본 컨테이너 내 항목명 (HWPX/DOCX ZIP 경로, HWP5 BinData 스토리지명 — PDF 등 합성 이미지는 없음, #70) */\n  source?: string\n}\n\nexport interface ParseFailure extends ParseResultBase {\n  success: false\n  /** 오류 메시지 */\n  error: string\n  /** 구조화된 에러 코드 */\n  code?: ErrorCode\n}\n\nexport type ParseResult = ParseSuccess | ParseFailure\n\n// ─── 문서 비교 (Diff) ───────────────────────────────\n\nexport type DiffChangeType = \"added\" | \"removed\" | \"modified\" | \"unchanged\"\n\nexport interface BlockDiff {\n  type: DiffChangeType\n  /** 원본 블록 (added이면 undefined) */\n  before?: IRBlock\n  /** 변경 후 블록 (removed이면 undefined) */\n  after?: IRBlock\n  /** modified 테이블의 셀 단위 diff */\n  cellDiffs?: CellDiff[][]\n  /** 유사도 (0-1) */\n  similarity?: number\n}\n\nexport interface CellDiff {\n  type: DiffChangeType\n  before?: string\n  after?: string\n}\n\nexport interface DiffResult {\n  stats: { added: number; removed: number; modified: number; unchanged: number }\n  diffs: BlockDiff[]\n}\n\n// ─── 라운드트립 패치 (v3.0) ─────────────────────────\n\n/** 패치 중 매핑 실패/미지원으로 건너뛴 항목 — silent 실패 금지 */\nexport interface PatchSkip {\n  /** 건너뛴 사유 */\n  reason: string\n  /** 원본 쪽 내용 요약 (최대 80자) */\n  before?: string\n  /** 편집 쪽 내용 요약 (최대 80자) */\n  after?: string\n  /**\n   * 부분 적용 표시 — 변경이 적용은 됐지만(applied 계상) 편집 원형 그대로는\n   * 아님 (예: 셀 내 줄 추가를 마지막 문단에 병합). 완전 미적용 skip과 구분.\n   */\n  partial?: boolean\n}\n\n/** patchHwpx 옵션 */\nexport interface PatchOptions {\n  /** 패치 후 재파싱 자동 검증 (기본 true) */\n  verify?: boolean\n}\n\n/** patchHwpx / patchBlocks 결과 */\nexport interface PatchResult {\n  success: boolean\n  /** 패치된 HWPX (success=true) */\n  data?: Uint8Array\n  /** 적용된 변경 수 */\n  applied: number\n  /** 매핑 실패 항목 (이유 포함) */\n  skipped: PatchSkip[]\n  /**\n   * 무손실 검증 (patchHwpx/patchHwp 전용): 패치본 재파싱 vs 편집 마크다운의\n   * 잔차 diff — modified/added/removed가 0이어야 의도가 전부 반영된 것.\n   * session.patchBlocks는 이 필드를 채우지 않는다 (changes 참조).\n   */\n  verification?: DiffResult\n  /**\n   * 변경 가시화 (session.patchBlocks 전용): 패치 전 → 후 문서 diff —\n   * 적용된 편집 수만큼 modified가 나오는 것이 정상. verification과 의미가\n   * 정반대이므로 혼용 금지.\n   */\n  changes?: DiffResult\n  /** 실패 사유 (success=false) */\n  error?: string\n}\n\n// ─── 양식 인식 ──────────────────────────────────────\n\nexport interface FormField {\n  label: string\n  value: string\n  /** 0-based 소스 행 */\n  row: number\n  /** 0-based 소스 열 */\n  col: number\n  /** 매칭된 입력 키(정규화) — 모호 라벨 거부 가드(fillWithUniqueGuard)의 집계 기준 */\n  key?: string\n  /** 매칭 근거. `clickhere`(누름틀 name 정확 일치)는 서식 제작자가 선언한 계약이라\n   *  여러 곳에 같은 이름이 있어도 \"모호\"가 아니다 — 모호 라벨 거부 집계에서 제외된다.\n   *  (머리말·본문에 같은 이름의 누름틀을 두는 서식이 실제로 있다) */\n  source?: \"clickhere\"\n}\n\nexport interface FormResult {\n  fields: FormField[]\n  /** 양식 확신도 (0-1) */\n  confidence: number\n}\n\n// ─── OCR 프로바이더 ─────────────────────────────────\n\n/** 사용자 제공 OCR 함수 — 페이지 이미지를 받아 텍스트 반환.\n *  PDF 경로는 항상 \"image/png\", 이미지 직접 입력 경로는 원본 mime 그대로 전달. */\nexport type OcrProvider = (\n  pageImage: Uint8Array,\n  pageNumber: number,\n  mimeType: \"image/png\" | \"image/jpeg\" | \"image/webp\"\n) => Promise<string>\n\n// ─── Watch 모드 ─────────────────────────────────────\n\nexport interface WatchOptions {\n  dir: string\n  outDir?: string\n  webhook?: string\n  format?: \"markdown\" | \"json\"\n  pages?: string\n  silent?: boolean\n}\n\n// ─── 헤딩 감지 공통 임계값 ──────────────────────────\n\n/** 폰트 크기 비율 → heading level (전 파서 공통) */\nexport const HEADING_RATIO_H1 = 1.5\nexport const HEADING_RATIO_H2 = 1.3\nexport const HEADING_RATIO_H3 = 1.15\n\n// ─── 내부 파서 반환 타입 ─────────────────────────────\n\n/** 내부 파서가 index.ts에 반환하는 공통 타입 (HWP5/HWPX/PDF/XLSX/DOCX) */\nexport interface InternalParseResult {\n  markdown: string\n  blocks: IRBlock[]\n  metadata?: DocumentMetadata\n  outline?: OutlineItem[]\n  warnings?: ParseWarning[]\n  images?: ExtractedImage[]\n  /** PDF 전용: 이미지 기반 PDF 여부 */\n  isImageBased?: boolean\n  /** PDF 전용: 페이지별 품질 신호 */\n  pageQuality?: PageQuality[]\n  /** PDF 전용: 문서 단위 품질 요약 */\n  qualitySummary?: DocumentQualitySummary\n  /** PDF 전용: 페이지별 마크다운 — 문서 마크다운과 같은 PDF 마무리(1×1 표 펴기·cleanPdfText)를 쪽마다 적용한 것 */\n  pages?: PageMarkdown[]\n}\n"]}

package/dist/chunks-EBWJR55V.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import {
-  blocksToChunks
-} from "./chunk-C4MVZXB5.js";
-import "./chunk-WJLICIYV.js";
-import "./chunk-A2W2JQ3S.js";
-export {
-  blocksToChunks
-};
-//# sourceMappingURL=chunks-EBWJR55V.js.map

package/dist/formula-5RETDCIC.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/mong-e/workspace/kordoc-quality-99/dist/formula-5RETDCIC.cjs","../src/pdf/formula/postprocess.ts","../src/pdf/formula/detector.ts","../src/pdf/formula/recognizer.ts","../src/pdf/formula/pipeline.ts"],"names":[],"mappings":"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","file":"/Users/mong-e/workspace/kordoc-quality-99/dist/formula-5RETDCIC.cjs","sourcesContent":[null,"/**\n * LaTeX 후처리 — Pix2Text `latex_ocr.py` 의 post_process 간소화 + 자체 필터\n *\n * 1) 후행 whitespace command 제거 (\\, \\: \\; \\! \\quad \\qquad \\enspace \\thinspace \\ )\n * 2) 연속 공백 → 1개\n * 3) 빈 그룹 반복 제거 (^{} _{} \\hat{} \\bar{} \\vec{} 등)\n * 4) \\cmd 뒤 영문자 공백 분리 (\\cdotd → \\cdot d, \\timesd → \\times d)\n * 5) isTrivialFormula — 다이어그램 단일 글자/반복/장식 오탐 제거\n */\n\nconst TRAILING_WHITESPACE_CMDS = [\n  \"\\\\,\",\n  \"\\\\:\",\n  \"\\\\;\",\n  \"\\\\!\",\n  \"\\\\ \",\n  \"\\\\quad\",\n  \"\\\\qquad\",\n  \"\\\\enspace\",\n  \"\\\\thinspace\",\n] as const\n\nexport function postProcessLatex(latex: string): string {\n  let s = stripTrailingWhitespace(latex)\n  s = collapseSpaces(s)\n  for (let i = 0; i < 10; i++) {\n    const next = stripEmptyGroups(s)\n    if (next === s) break\n    s = next\n  }\n  s = fixLatexSpacing(s)\n  s = normalizeFormulaSpacing(s)\n  s = s.trim()\n  // trivial 이면 빈 문자열 반환 — 상위(pipeline/parser) 에서 latex.trim() 비었을 때 skip.\n  if (isTrivialFormula(s)) return \"\"\n  return s\n}\n\nexport function stripTrailingWhitespace(s: string): string {\n  let t = s\n  // 바깥 loop: 한 번 제거 후 다시 체크 (중첩 \"\\\\, \\\\quad\" 같은 경우)\n  for (;;) {\n    const trimmed = t.replace(/[\\s]+$/, \"\")\n    let changed = false\n    for (const p of TRAILING_WHITESPACE_CMDS) {\n      if (trimmed.endsWith(p)) {\n        t = trimmed.slice(0, trimmed.length - p.length)\n        changed = true\n        break\n      }\n    }\n    if (!changed) return trimmed\n  }\n}\n\nexport function collapseSpaces(s: string): string {\n  let out = \"\"\n  let prevSpace = false\n  for (const c of s) {\n    if (/\\s/.test(c)) {\n      if (!prevSpace) {\n        out += \" \"\n        prevSpace = true\n      }\n    } else {\n      out += c\n      prevSpace = false\n    }\n  }\n  return out\n}\n\n/**\n * 빈 그룹 `{}` 또는 `{\\s+}` 를 찾아 선행하는 `^`, `_`, 또는 `\\cmd` 와 함께 제거.\n */\nexport function stripEmptyGroups(s: string): string {\n  let out = \"\"\n  let i = 0\n  const bytes = s\n  while (i < bytes.length) {\n    const ch = bytes[i]\n    if (ch === \"{\") {\n      // 빈 { \\s* } 스캔\n      let j = i + 1\n      while (j < bytes.length && /\\s/.test(bytes[j])) j++\n      if (j < bytes.length && bytes[j] === \"}\") {\n        // 앞쪽 공백 제거\n        while (out.endsWith(\" \") || out.endsWith(\"\\t\")) {\n          out = out.slice(0, -1)\n        }\n        if (out.endsWith(\"^\") || out.endsWith(\"_\")) {\n          out = out.slice(0, -1)\n        } else {\n          // \\cmd 형태인지 탐색\n          let k = out.length\n          while (k > 0 && /[A-Za-z]/.test(out[k - 1])) k--\n          if (k > 0 && out[k - 1] === \"\\\\\" && k < out.length) {\n            out = out.slice(0, k - 1)\n          }\n          // 아니면 아무것도 안 함 — 빈 {} 만 제거\n        }\n        i = j + 1\n        continue\n      }\n    }\n    out += ch\n    i++\n  }\n  return out\n}\n\n/**\n * LaTeX 명령어 화이트리스트 — 공백 누락 감지에 사용.\n * MFR 이 `\\cdot d` 를 `\\cdotd` 로 합쳐 출력할 때, 어느 지점에서 명령어가 끝나는지\n * 알려진 커맨드명으로 판단한다. 완전한 리스트는 아니며 OCR 에서 실제 관찰된 케이스 중심.\n */\nconst KNOWN_LATEX_CMDS: ReadonlySet<string> = new Set([\n  // 연산자\n  \"cdot\", \"cdots\", \"ldots\", \"dots\", \"vdots\", \"ddots\",\n  \"times\", \"div\", \"pm\", \"mp\", \"ast\", \"star\", \"circ\", \"bullet\",\n  \"oplus\", \"ominus\", \"otimes\", \"odot\",\n  // 관계\n  \"approx\", \"equiv\", \"neq\", \"ne\", \"sim\", \"simeq\", \"cong\",\n  \"leq\", \"geq\", \"le\", \"ge\", \"ll\", \"gg\", \"prec\", \"succ\", \"preceq\", \"succeq\",\n  \"propto\", \"parallel\", \"perp\",\n  // 집합/논리\n  \"in\", \"notin\", \"ni\", \"subset\", \"supset\", \"subseteq\", \"supseteq\",\n  \"cap\", \"cup\", \"bigcap\", \"bigcup\", \"emptyset\", \"varnothing\",\n  \"forall\", \"exists\", \"nexists\", \"neg\", \"lnot\", \"land\", \"lor\", \"vee\", \"wedge\",\n  // 그리스 소문자\n  \"alpha\", \"beta\", \"gamma\", \"delta\", \"epsilon\", \"varepsilon\",\n  \"zeta\", \"eta\", \"theta\", \"vartheta\", \"iota\", \"kappa\", \"lambda\",\n  \"mu\", \"nu\", \"xi\", \"omicron\", \"pi\", \"varpi\", \"rho\", \"varrho\",\n  \"sigma\", \"varsigma\", \"tau\", \"upsilon\", \"phi\", \"varphi\",\n  \"chi\", \"psi\", \"omega\",\n  // 그리스 대문자\n  \"Gamma\", \"Delta\", \"Theta\", \"Lambda\", \"Xi\", \"Pi\", \"Sigma\",\n  \"Upsilon\", \"Phi\", \"Psi\", \"Omega\",\n  // 화살표\n  \"to\", \"gets\", \"mapsto\", \"rightarrow\", \"leftarrow\", \"leftrightarrow\",\n  \"Rightarrow\", \"Leftarrow\", \"Leftrightarrow\", \"uparrow\", \"downarrow\",\n  \"longrightarrow\", \"longleftarrow\", \"longmapsto\",\n  // 큰 연산자\n  \"sum\", \"prod\", \"coprod\", \"int\", \"iint\", \"iiint\", \"oint\", \"bigoplus\", \"bigotimes\",\n  // 함수명\n  \"sin\", \"cos\", \"tan\", \"sec\", \"csc\", \"cot\",\n  \"arcsin\", \"arccos\", \"arctan\", \"sinh\", \"cosh\", \"tanh\",\n  \"log\", \"ln\", \"lg\", \"exp\", \"lim\", \"liminf\", \"limsup\",\n  \"sup\", \"inf\", \"max\", \"min\", \"arg\", \"det\", \"dim\", \"gcd\", \"deg\", \"hom\", \"ker\", \"mod\",\n  // 특수 기호/수식\n  \"infty\", \"partial\", \"nabla\", \"prime\", \"aleph\", \"ell\", \"hbar\", \"Re\", \"Im\",\n  \"top\", \"bot\", \"angle\", \"vdash\", \"dashv\",\n  // 기타\n  \"left\", \"right\", \"big\", \"Big\", \"bigg\", \"Bigg\",\n])\n\n/**\n * `\\cmd` 뒤에 영문자가 바로 붙으면 공백 분리 (e.g. `\\cdotd` → `\\cdot d`, `\\timesd_{k}` → `\\times d_{k}`).\n *\n * MFR 이 좁은 영역에서 가끔 `\\cdot` 과 다음 변수 사이 공백을 누락. 그대로 두면 LaTeX 파서가\n * `\\cdotd` 를 undefined command 로 처리 (KaTeX: 에러 / TeX: 정의되지 않은 제어 시퀀스).\n * 알려진 LaTeX 명령어 prefix 중 가장 긴 것을 찾아 분할하면 렌더 안정성 확보.\n *\n * `\\cmd{..}` (영문자 뒤 `{`) 는 인자 포함 형태로 간주해 분리하지 않음.\n */\nexport function fixLatexSpacing(s: string): string {\n  let out = \"\"\n  let i = 0\n  while (i < s.length) {\n    if (s[i] === \"\\\\\" && i + 1 < s.length && /[A-Za-z]/.test(s[i + 1])) {\n      // \\cmd 최장일치\n      let j = i + 1\n      while (j < s.length && /[A-Za-z]/.test(s[j])) j++\n      const full = s.slice(i + 1, j) // 명령어 이름 (앞 \\ 제거)\n      const nextChar = j < s.length ? s[j] : \"\"\n\n      // \\cmd{..} 형태 — 인자로 이어지므로 분리하지 않음\n      if (nextChar === \"{\") {\n        out += \"\\\\\" + full\n        i = j\n        continue\n      }\n\n      // 자체가 알려진 명령어이거나, 긴 prefix 가 없으면 그대로\n      let splitAt = full.length\n      if (!KNOWN_LATEX_CMDS.has(full) && full.length >= 3) {\n        // 뒤에서부터 prefix 길이를 줄이며 가장 긴 known cmd 찾기\n        for (let len = full.length - 1; len >= 2; len--) {\n          if (KNOWN_LATEX_CMDS.has(full.slice(0, len))) {\n            splitAt = len\n            break\n          }\n        }\n      }\n\n      out += \"\\\\\" + full.slice(0, splitAt)\n      if (splitAt < full.length) {\n        out += \" \" + full.slice(splitAt)\n      }\n      i = j\n    } else {\n      out += s[i]\n      i++\n    }\n  }\n  return out\n}\n\n/**\n * trivial(noise) 수식 판정.\n *\n * true 인 케이스 (MFD 오탐 주범):\n *   1) 공백/중괄호 제거 후 2자 이하 (e.g. `O`, `a`, `.`, `n`)\n *   2) 단일 `\\cmd` (e.g. `\\imath`, `\\pi`, `\\eta`, `\\sigma`, `\\theta`, `\\emptyset`, `\\varPi`)\n *   3) 단일 `\\mathrm{..}` / `\\textrm{..}` / `\\operatorname{..}` 류 + 짧은 내용 (e.g. `\\mathrm{fcloc}`)\n *   4) 동일 토큰이 3회 이상 + 전체의 50% 이상 (e.g. `\\pm \\pm \\pm \\pm`, `\\cap \\exists \\exists \\rceil`)\n *\n * false 유지 (의미 있는 수식):\n *   `O(1)`, `d_{k}=64`, `\\sqrt{d_{k}}`, `PE_{pos+k}`, 등\n */\nexport function isTrivialFormula(s: string): boolean {\n  const t = s.trim()\n  if (t.length === 0) return true\n\n  // 1) 공백/중괄호 제거 후 길이 ≤ 2\n  const stripped = t.replace(/[\\s{}]/g, \"\")\n  if (stripped.length <= 2) return true\n\n  // 2) 단일 \\cmd (e.g. \\imath, \\varPi, \\pi)\n  if (/^\\\\[A-Za-z]+$/.test(t)) return true\n\n  // 3) 단일 \\mathrm{..} / \\textrm{..} / \\operatorname{..} / \\mathit{..} / \\mathbf{..} / \\mathcal{..} + 짧은 내용\n  if (\n    /^\\\\(?:mathrm|textrm|text|operatorname|mathit|mathbf|mathcal|mathsf|mathtt)\\{[A-Za-z]{1,6}\\}$/.test(\n      t,\n    )\n  )\n    return true\n\n  const tokens = tokenizeLatex(t)\n\n  // 4) 반복 토큰 dominant (e.g. \"\\\\pm \\\\pm \\\\pm \\\\pm\")\n  if (tokens.length >= 3) {\n    const freq = new Map<string, number>()\n    for (const tok of tokens) freq.set(tok, (freq.get(tok) ?? 0) + 1)\n    let maxCount = 0\n    for (const c of freq.values()) if (c > maxCount) maxCount = c\n    if (maxCount >= 3 && maxCount / tokens.length >= 0.5) return true\n  }\n\n  // 5) 심볼만 구성된 짧은 식 — 토큰 2~4개이고 연산자/숫자 없음 (e.g. \"\\\\cap \\\\exists \\\\exists \\\\rceil\")\n  //    의미 있는 수식은 대개 `=` 또는 숫자가 포함됨. 허용되는 연산자: = + - / * < > 숫자\n  if (tokens.length >= 2 && tokens.length <= 4) {\n    const hasOpOrNum = tokens.some((tok) =>\n      /^[=+\\-/*<>]$/.test(tok) || /^[0-9]$/.test(tok),\n    )\n    if (!hasOpOrNum) return true\n  }\n\n  // 6) substring 반복 패턴 — 동일 5~15자 substring 이 3회 이상 + 커버리지 60%+\n  //    (e.g. \"\\\\alpha_{1}=\\\\alpha_{2}=\\\\alpha_{3}=...\" 의 `\\\\alpha_{` 반복,\n  //           \"c_{c}^{\\\\prime}\\\\phi_{c}^{\\\\prime}=c_{c}^{\\\\prime}...\" 의 `c_{c}^{\\\\prime}` 반복)\n  if (hasHighRepetition(t)) return true\n\n  // 7) MFR placeholder 인 `\\square` 포함 — 인식 실패 영역을 `\\square` 로 대체하는 특성\n  //    정당한 수식에 `\\square` 가 나오는 경우는 거의 없음 (대부분 `\\Box`, `\\blacksquare` 등 사용)\n  if (t.includes(\"\\\\square\")) return true\n\n  // 8) 단독 숫자/실수 (e.g. \"$1.0$\", \"$42$\", \"$-3.14$\")\n  //    공백/중괄호/백슬래시 제거 후 순수 숫자/부호/소수점만 남으면 trivial\n  if (/^[-+]?\\d+\\.?\\d*$/.test(t.replace(/[\\s{}\\\\]/g, \"\"))) return true\n\n  // 9) `(X)(X)` 또는 `{X}{X}` 연속 중복 — 동일 그룹 반복 (e.g. \"$C(T_{2})(T_{2})$\")\n  //    한 단계 중첩 허용: `{k_{c}}` 같이 내부에 `{...}` 하나 포함 가능.\n  if (/(\\([^()]{2,15}\\))\\s*\\1/.test(t)) return true\n  if (/(\\{(?:[^{}]|\\{[^{}]*\\})+\\})\\s*\\1/.test(t)) return true\n\n  // 10) 동일 인자 반복 — 괄호 인자 중 쉼표 구분 3개 중 2개 이상 동일 (e.g. `C(\\tau_{2},\\mu^{\\prime},\\mu^{\\prime})`)\n  //     완전 일치 인자가 2회+ 반복이면 OCR 반복 오류로 간주\n  const argMatch = t.match(/^[A-Za-z\\\\][A-Za-z]*\\(([^()]+)\\)$/)\n  if (argMatch) {\n    const args = argMatch[1].split(\",\").map((a) => a.trim())\n    if (args.length >= 2) {\n      const freq = new Map<string, number>()\n      for (const a of args) if (a) freq.set(a, (freq.get(a) ?? 0) + 1)\n      for (const [, c] of freq) {\n        if (c >= 2 && c / args.length >= 0.5) return true\n      }\n    }\n  }\n\n  // 11) X/X 또는 \\frac{X}{X} — 분자=분모 = 1, 의미 없는 수식\n  //     수식 **어디에나** 나타나면 trivial (e.g. \"$k<\\\\frac{\\\\eta}{\\\\eta}$\" 도 포함)\n  //     정당한 수식에서 $\\\\frac{a}{a}$ 를 쓰는 경우는 거의 없음 (대수적으로 1).\n  if (/\\\\frac\\{([^{}]+)\\}\\{\\1\\}/.test(t)) return true\n  // X/X 꼴 (단일 변수 또는 \\cmd)\n  if (/(\\\\[A-Za-z]+|\\b[A-Za-z])\\s*\\/\\s*\\1\\b/.test(t)) return true\n\n  // 12) `\\begin{matrix}` 내부 `\\cdots` 여러 번 — MFR 이 다이어그램/표를 matrix 로 오인식\n  //     본문 수식의 matrix 는 구체적 원소가 있어 `\\cdots` 가 2회 이상 나오는 경우 거의 없음\n  if (/\\\\begin\\{(?:matrix|pmatrix|bmatrix|vmatrix)\\}/.test(t)) {\n    const cdotsCount = (t.match(/\\\\cdots/g) ?? []).length\n    if (cdotsCount >= 2) return true\n  }\n\n  // 13) 다이어그램 텍스트 레이블 — `\\mathrm{word}` 가 2회+ 포함된 짧은 식 (토큰 수 ≤ 12)\n  //     또는 `[a-z]{1,3}_\\{\\mathrm{word}\\}` 꼴의 비정상 변수명 (e.g. `cl_{\\mathrm{model}}`)\n  if (tokens.length <= 12) {\n    const mathrmCount = (t.match(/\\\\mathrm\\{/g) ?? []).length\n    if (mathrmCount >= 2) {\n      // 연산자/등호/숫자가 거의 없어 \"단순 레이블\" 로 보이는지 추가 확인\n      const hasRealMath = /[=+\\-*/<>^]/.test(t) && /\\d/.test(t)\n      if (!hasRealMath) return true\n    }\n  }\n  // 비정상 변수명: 2-3자 영문 접두 + _{\\mathrm{긴단어}} 단독 (e.g. `cl_{\\mathrm{model}}`, `to_{\\mathrm{max}}`)\n  // 정상 변수명은 보통 단일 문자 (`d_{\\mathrm{model}}`, `W_{i}`) — 2자 이상이면 다이어그램 오인식\n  if (/^[a-zA-Z]{2,3}_\\{\\\\mathrm\\{[a-zA-Z]{3,}\\}\\}$/.test(t)) return true\n\n  // 14) `\\mathrm{word}` + 이항 연산자 + single 요소 꼴 — 다이어그램 \"word → value\" 레이블\n  //     (e.g. `\\mathrm{to}-\\infty`, `\\mathrm{to}+\\infty`)\n  if (/^\\\\mathrm\\{[a-z]{2,}\\}[-+][-+]?(?:\\\\[a-zA-Z]+|[a-zA-Z0-9])$/.test(t)) return true\n\n  // 15) `\\mathsf`, `\\mathtt`, `\\texttt` 는 본문 수식에 거의 쓰이지 않고 다이어그램 타이포그래피 오인식이 대부분\n  //     — 포함만으로 trivial (e.g. `\\mathtt{Welgnt}`, `\\mathsf{Tr}_{s}`, `\\texttt{wg}`)\n  if (/\\\\(?:mathsf|mathtt|texttt)\\{/.test(t)) return true\n\n  // 16) `\\begin{aligned}` 이지만 `=` 없음 — 정당한 aligned 는 항상 등호 포함 (여러 줄 equation)\n  //     등호 없으면 OCR garbage 조합\n  if (/\\\\begin\\{aligned\\}/.test(t) && !t.includes(\"=\")) return true\n\n  // 17) `\\begin{matrix}` + `\\downarrow` 2회+ — 네트워크 architecture 다이어그램 오인식\n  if (/\\\\begin\\{matrix\\}/.test(t) && (t.match(/\\\\downarrow/g) ?? []).length >= 2) return true\n\n  return false\n}\n\n/**\n * substring 반복 탐지 — 동일한 N자 substring 이 3회 이상 나타나고\n * 그 반복 총 길이가 전체의 60% 이상이면 true.\n *\n * 5~15자 범위만 검사 (짧으면 정상 수식의 `^{2}` 같은 패턴도 걸림, 길면 노이즈 거의 없음).\n * 영문자 포함 substring 만 검사 (구두점만 반복은 정상 수식에도 많음).\n *\n * 정당한 수식은 다양한 구조로 거의 겹치지 않아 false-positive 낮음.\n */\nexport function hasHighRepetition(s: string): boolean {\n  if (s.length < 15) return false\n\n  for (let len = 5; len <= 15; len++) {\n    // substring 길이 × 3회가 전체보다 길면 의미 없음\n    if (len * 3 > s.length) break\n    const seen = new Map<string, number>()\n    for (let i = 0; i <= s.length - len; i++) {\n      const sub = s.slice(i, i + len)\n      if (!/[a-zA-Z]/.test(sub)) continue\n      seen.set(sub, (seen.get(sub) ?? 0) + 1)\n    }\n    for (const [, count] of seen) {\n      if (count < 3) continue\n      // 겹치지 않는 점유율 추정: count*len (overlapping 포함이라 약간 과대)\n      // 보수적 판정 위해 최소 3회 + 60% 커버리지\n      if ((count * len) / s.length >= 0.6) return true\n    }\n  }\n  return false\n}\n\n/**\n * LaTeX 를 단순 토큰 배열로 분할 — `\\cmd` 는 하나의 토큰, 그 외는 non-space 단일 문자.\n * isTrivialFormula 의 반복 감지용.\n */\nfunction tokenizeLatex(s: string): string[] {\n  const result: string[] = []\n  let i = 0\n  while (i < s.length) {\n    const c = s[i]\n    if (c === \"\\\\\") {\n      let j = i + 1\n      while (j < s.length && /[A-Za-z]/.test(s[j])) j++\n      if (j === i + 1 && j < s.length) j++ // `\\\\` 또는 `\\{` 같은 단일 escape\n      result.push(s.slice(i, j))\n      i = j\n    } else if (/\\s/.test(c)) {\n      i++\n    } else {\n      result.push(c)\n      i++\n    }\n  }\n  return result\n}\n\n/**\n * MFR tokenizer 가 LaTeX 토큰 사이에 삽입하는 과도한 공백을 정리.\n *\n * 예: `\\mathrm { m o d d }` → `\\mathrm{modd}`, `6 4` → `64`, `( Q, K, V )` → `(Q,K,V)`\n *\n * 규칙: 공백을 앞뒤 토큰 기준으로 유지/제거 결정.\n *   - 직전이 `\\cmd` 이고 직후가 영문자 → **유지** (e.g. `\\cdot d`, `\\alpha b` — 공백 없으면 greedy 로 `\\cdotd` 가 명령어로 해석될 수 있음)\n *   - 그 외 → **제거** (숫자/괄호/중괄호/첨자/구두점 주변 공백은 LaTeX 의미를 바꾸지 않음)\n *\n * `fixLatexSpacing` 이후에 호출되는 것을 전제 — 먼저 공백 누락을 복원한 뒤 과도한 공백을 걷어냄.\n */\nexport function normalizeFormulaSpacing(s: string): string {\n  // `\\cmd`, 단일 escape, 공백, 일반 문자 단위로 토큰화 (공백도 토큰으로 유지)\n  const tokens: string[] = []\n  let i = 0\n  while (i < s.length) {\n    const c = s[i]\n    if (c === \"\\\\\") {\n      let j = i + 1\n      while (j < s.length && /[A-Za-z]/.test(s[j])) j++\n      if (j === i + 1 && j < s.length) j++ // 단일 escape (`\\\\`, `\\{` 등)\n      tokens.push(s.slice(i, j))\n      i = j\n    } else if (/\\s/.test(c)) {\n      tokens.push(\" \")\n      i++\n    } else {\n      tokens.push(c)\n      i++\n    }\n  }\n\n  const out: string[] = []\n  for (let k = 0; k < tokens.length; k++) {\n    if (tokens[k] !== \" \") {\n      out.push(tokens[k])\n      continue\n    }\n    // 공백 토큰 — 유지 여부 결정\n    // 연속 공백은 나중에 병합 (아래 로직은 앞뒤 non-space 토큰 기준)\n    let prev = \"\"\n    for (let p = k - 1; p >= 0; p--) {\n      if (tokens[p] !== \" \") {\n        prev = tokens[p]\n        break\n      }\n    }\n    let next = \"\"\n    for (let q = k + 1; q < tokens.length; q++) {\n      if (tokens[q] !== \" \") {\n        next = tokens[q]\n        break\n      }\n    }\n    const prevIsCmd = /^\\\\[A-Za-z]+$/.test(prev)\n    const nextIsAlpha = /^[A-Za-z]$/.test(next)\n    if (prevIsCmd && nextIsAlpha) {\n      // 앞 cmd 와 뒤 변수 분리용 공백 (연속 공백이더라도 하나만 남김)\n      if (out.length === 0 || out[out.length - 1] !== \" \") {\n        out.push(\" \")\n      }\n    }\n    // 그 외 공백은 drop\n  }\n\n  // 앞/뒤 공백 제거\n  while (out.length > 0 && out[0] === \" \") out.shift()\n  while (out.length > 0 && out[out.length - 1] === \" \") out.pop()\n\n  return out.join(\"\")\n}\n","/**\n * MFD (Mathematical Formula Detection) — YOLOv8 기반 수식 영역 검출\n *\n * 모델: breezedeus/pix2text-mfd (YOLOv8 small, imgsz=768, stride=32)\n * 출력: [1, 6, 12096] — (cx, cy, w, h, class0_score, class1_score) × anchors\n *   - class 0 = embedding (inline 수식)\n *   - class 1 = isolated (display 수식)\n *\n * 전처리: letterbox (긴 변 비율 유지 + 회색 패딩 114)\n * 후처리: conf ≥ 0.25 → class-per-class NMS (IoU ≥ 0.45)\n */\n\nimport type { InferenceSession, Tensor } from \"onnxruntime-node\"\nimport type { FormulaKind, PixelFrame, FormulaRegion } from \"./types.js\"\n\nconst MFD_IMG_SIZE = 768\nconst MFD_NUM_CLASSES = 2\nconst MFD_CHANNELS = 4 + MFD_NUM_CLASSES\n/** 기본 confidence 임계값 (Pix2Text 원본 0.25 — 누락은 적지만 noise 발생) */\nconst MFD_CONF_INLINE = 0.30\n/** display 수식 임계값 — diagram/figure 오탐 감소 목적으로 inline 보다 높게 */\nconst MFD_CONF_DISPLAY = 0.40\nconst MFD_IOU_THRESHOLD = 0.45\n/** 최소 bbox 면적 (px²) — 이보다 작으면 OCR noise 가능성 높음 */\nconst MFD_MIN_AREA = 80\nconst PAD_VALUE = 114 / 255\n\ninterface RawDetection {\n  x1: number\n  y1: number\n  x2: number\n  y2: number\n  kind: FormulaKind\n  score: number\n}\n\n/**\n * 단일 페이지 이미지에서 수식 영역 검출 (인식 없음 — recognizer 로 넘김).\n * bbox 는 원본 이미지 좌표계.\n */\nexport async function detectFormulaRegions(\n  session: InferenceSession,\n  frame: PixelFrame,\n  ort: typeof import(\"onnxruntime-node\"),\n): Promise<Omit<FormulaRegion, \"latex\">[]> {\n  const { scale, padX, padY, tensor } = letterbox(frame, MFD_IMG_SIZE)\n\n  const input = new ort.Tensor(\"float32\", tensor, [1, 3, MFD_IMG_SIZE, MFD_IMG_SIZE])\n  const feeds: Record<string, Tensor> = { images: input }\n  const outputs = await session.run(feeds)\n\n  const firstKey = Object.keys(outputs)[0]\n  const out = outputs[firstKey]\n  if (!out || out.type !== \"float32\") {\n    throw new Error(\"MFD 출력 없음 또는 dtype 불일치\")\n  }\n\n  const outDims = out.dims\n  if (outDims.length !== 3) {\n    throw new Error(`MFD 출력 차원 예상 3, 실제 ${outDims.length}: [${outDims.join(\",\")}]`)\n  }\n  const channels = outDims[1]\n  const anchors = outDims[2]\n  if (channels !== MFD_CHANNELS) {\n    throw new Error(`MFD 채널 수 예상 ${MFD_CHANNELS}, 실제 ${channels}`)\n  }\n  if (anchors <= 0) return []\n\n  const data = out.data as Float32Array\n  const candidates: RawDetection[] = []\n\n  for (let a = 0; a < anchors; a++) {\n    const cx = data[a]\n    const cy = data[anchors + a]\n    const w = data[2 * anchors + a]\n    const h = data[3 * anchors + a]\n\n    let bestCls = 0\n    let bestScore = 0\n    for (let c = 0; c < MFD_NUM_CLASSES; c++) {\n      const s = data[(4 + c) * anchors + a]\n      if (s > bestScore) {\n        bestScore = s\n        bestCls = c\n      }\n    }\n    // 클래스별 임계값 — display 쪽은 diagram/figure 오탐 감소 목적으로 inline 보다 엄격.\n    const threshold = bestCls === 1 ? MFD_CONF_DISPLAY : MFD_CONF_INLINE\n    if (bestScore < threshold) continue\n\n    // letterbox → 원본 좌표\n    let x1 = (cx - w / 2 - padX) / scale\n    let y1 = (cy - h / 2 - padY) / scale\n    let x2 = (cx + w / 2 - padX) / scale\n    let y2 = (cy + h / 2 - padY) / scale\n\n    x1 = clamp(x1, 0, frame.width - 1)\n    y1 = clamp(y1, 0, frame.height - 1)\n    x2 = clamp(x2, 0, frame.width - 1)\n    y2 = clamp(y2, 0, frame.height - 1)\n\n    if (x2 - x1 < 2 || y2 - y1 < 2) continue\n    // 너무 작은 bbox (픽셀 단위 noise 로 보이는 영역) 제외\n    if ((x2 - x1) * (y2 - y1) < MFD_MIN_AREA) continue\n\n    candidates.push({\n      x1,\n      y1,\n      x2,\n      y2,\n      kind: bestCls === 1 ? \"display\" : \"inline\",\n      score: bestScore,\n    })\n  }\n\n  // 클래스별 NMS (혼합 클래스 bbox 간 중복은 허용 — Pix2Text 원본 동작)\n  const kept: RawDetection[] = []\n  for (const kind of [\"inline\", \"display\"] as FormulaKind[]) {\n    const subset = candidates.filter((c) => c.kind === kind)\n    kept.push(...nms(subset, MFD_IOU_THRESHOLD))\n  }\n\n  // 읽기 순서 정렬 (위→아래, 왼→오른쪽)\n  kept.sort((a, b) => a.y1 - b.y1 || a.x1 - b.x1)\n\n  return kept.map((d) => ({\n    bbox: { x1: d.x1, y1: d.y1, x2: d.x2, y2: d.y2 },\n    kind: d.kind,\n    score: d.score,\n  }))\n}\n\n/**\n * YOLOv8 letterbox 전처리 — RGBA 프레임을 target×target float32 CHW tensor 로.\n *\n * - 긴 변 기준으로 비율 유지 리사이즈\n * - 가운데 패딩 (회색 114)\n * - /255 정규화\n * - CHW 레이아웃\n */\nexport function letterbox(\n  frame: PixelFrame,\n  target: number,\n): { scale: number; padX: number; padY: number; tensor: Float32Array } {\n  const w = frame.width\n  const h = frame.height\n  const scale = Math.min(target / w, target / h)\n  const newW = Math.max(1, Math.round(w * scale))\n  const newH = Math.max(1, Math.round(h * scale))\n  const padX = (target - newW) / 2\n  const padY = (target - newH) / 2\n  const offX = Math.floor(padX)\n  const offY = Math.floor(padY)\n\n  const ts = target\n  const tensor = new Float32Array(3 * ts * ts)\n  tensor.fill(PAD_VALUE)\n\n  // RGBA 원본 → 먼저 nearest-neighbor resize 한 뒤 복사.\n  // (sharp 로 정확한 bilinear 가능하지만, 여기선 이미 렌더링된 bitmap 이 충분히 해상도 높음 —\n  //  결과는 동일한 수준으로 수식 박스 위치 맞춤. Rust 구현도 Triangle 사용.)\n  const src = frame.data\n  const srcW = frame.width\n  const srcH = frame.height\n\n  for (let y = 0; y < newH; y++) {\n    const sy = Math.min(srcH - 1, Math.floor((y + 0.5) / newH * srcH))\n    for (let x = 0; x < newW; x++) {\n      const sx = Math.min(srcW - 1, Math.floor((x + 0.5) / newW * srcW))\n      const srcIdx = (sy * srcW + sx) * 4\n      const r = src[srcIdx]\n      const g = src[srcIdx + 1]\n      const b = src[srcIdx + 2]\n\n      const tx = x + offX\n      const ty = y + offY\n      const idx = ty * ts + tx\n      tensor[idx] = r / 255\n      tensor[ts * ts + idx] = g / 255\n      tensor[2 * ts * ts + idx] = b / 255\n    }\n  }\n\n  return { scale, padX, padY, tensor }\n}\n\nfunction nms(cands: RawDetection[], iouThreshold: number): RawDetection[] {\n  const sorted = [...cands].sort((a, b) => b.score - a.score)\n  const kept: RawDetection[] = []\n  for (const cand of sorted) {\n    let keep = true\n    for (const k of kept) {\n      if (iou(cand, k) > iouThreshold) {\n        keep = false\n        break\n      }\n    }\n    if (keep) kept.push(cand)\n  }\n  return kept\n}\n\nfunction iou(\n  a: { x1: number; y1: number; x2: number; y2: number },\n  b: { x1: number; y1: number; x2: number; y2: number },\n): number {\n  const x1 = Math.max(a.x1, b.x1)\n  const y1 = Math.max(a.y1, b.y1)\n  const x2 = Math.min(a.x2, b.x2)\n  const y2 = Math.min(a.y2, b.y2)\n  const interW = Math.max(0, x2 - x1)\n  const interH = Math.max(0, y2 - y1)\n  const inter = interW * interH\n  const areaA = Math.max(0, a.x2 - a.x1) * Math.max(0, a.y2 - a.y1)\n  const areaB = Math.max(0, b.x2 - b.x1) * Math.max(0, b.y2 - b.y1)\n  const union = areaA + areaB - inter\n  return union <= 0 ? 0 : inter / union\n}\n\nfunction clamp(v: number, lo: number, hi: number): number {\n  if (v < lo) return lo\n  if (v > hi) return hi\n  return v\n}\n\n// 테스트 용도로만 export\nexport const __internal = { nms, iou, letterbox }\n","/**\n * MFR (Mathematical Formula Recognition) — DeiT encoder + TrOCR decoder\n *\n * 모델: breezedeus/pix2text-mfr\n *   - encoder: DeiT distilled, input 384×384 → output [1, 578, 384]\n *   - decoder: TrOCR (no KV cache), vocab=1200, EOS=2\n *\n * 전처리 (DeiT): Catmull-Rom resize → /255 → (x - 0.5) / 0.5  == x*2 - 1\n *\n * 디코딩: greedy, start=[2], stop at 2 또는 max_new_tokens=256\n *         decoder 는 매 스텝 전체 시퀀스를 재계산 (no KV cache — 모델 고정)\n */\n\nimport type { InferenceSession, Tensor } from \"onnxruntime-node\"\nimport type { PreTrainedTokenizer } from \"@huggingface/transformers\"\nimport { postProcessLatex } from \"./postprocess.js\"\nimport type { PixelFrame } from \"./types.js\"\n\nconst MFR_IMG_SIZE = 384\nconst MFR_ENC_HIDDEN = 384\nconst MFR_MAX_NEW_TOKENS = 256\nconst MFR_EOS_ID = 2\nconst MFR_PAD_ID = 0\n\nexport interface RecognizeDeps {\n  encoder: InferenceSession\n  decoder: InferenceSession\n  tokenizer: PreTrainedTokenizer\n  ort: typeof import(\"onnxruntime-node\")\n}\n\n/**\n * 단일 수식 crop 을 LaTeX 로 인식.\n * 입력 frame 은 이미 해당 영역만 잘린 RGBA 이미지이어야 한다 (recognizer 가 resize 수행).\n */\nexport async function recognizeFormula(\n  deps: RecognizeDeps,\n  crop: PixelFrame,\n): Promise<string> {\n  const tensor = deitPreprocess(crop, MFR_IMG_SIZE)\n  const { ort, encoder, decoder, tokenizer } = deps\n\n  const pixelInput = new ort.Tensor(\"float32\", tensor, [1, 3, MFR_IMG_SIZE, MFR_IMG_SIZE])\n  const encOut = await encoder.run({ pixel_values: pixelInput })\n\n  const encKey =\n    Object.keys(encOut).find((k) => k.includes(\"hidden\")) ?? Object.keys(encOut)[0]\n  const encTensor = encOut[encKey]\n  if (!encTensor || encTensor.type !== \"float32\") {\n    throw new Error(\"MFR encoder 출력 없음\")\n  }\n  const encDims = encTensor.dims\n  if (encDims.length !== 3) {\n    throw new Error(`MFR encoder 차원 예상 3, 실제 ${encDims.length}`)\n  }\n  const encSeq = encDims[1]\n  const encHidden = encDims[2]\n  if (encHidden !== MFR_ENC_HIDDEN) {\n    throw new Error(`MFR encoder hidden 예상 ${MFR_ENC_HIDDEN}, 실제 ${encHidden}`)\n  }\n  const encData = encTensor.data as Float32Array\n\n  // greedy decode\n  const tokens: number[] = [MFR_EOS_ID] // decoder_start_token_id\n\n  for (let step = 0; step < MFR_MAX_NEW_TOKENS; step++) {\n    const seqLen = tokens.length\n    const idsArr = BigInt64Array.from(tokens.map((t) => BigInt(t)))\n    const idsTensor = new ort.Tensor(\"int64\", idsArr, [1, seqLen])\n\n    // encoder_hidden_states 는 매 스텝 동일 — 복사 필요 (Tensor 는 buffer 소유)\n    const hidCopy = new Float32Array(encData)\n    const hidTensor = new ort.Tensor(\"float32\", hidCopy, [1, encSeq, encHidden])\n\n    const decOut = await decoder.run({\n      input_ids: idsTensor,\n      encoder_hidden_states: hidTensor,\n    })\n\n    const logitKey =\n      Object.keys(decOut).find((k) => k.includes(\"logit\")) ?? Object.keys(decOut)[0]\n    const logitsTensor = decOut[logitKey]\n    if (!logitsTensor || logitsTensor.type !== \"float32\") {\n      throw new Error(\"MFR decoder logits 없음\")\n    }\n    const dims = logitsTensor.dims\n    if (dims.length !== 3) {\n      throw new Error(`MFR decoder 차원 예상 3, 실제 ${dims.length}`)\n    }\n    const decSeq = dims[1]\n    const vocab = dims[2]\n    const logitsData = logitsTensor.data as Float32Array\n\n    // 마지막 step logits 만\n    const lastOffset = (decSeq - 1) * vocab\n    let bestId = 0\n    let bestVal = -Infinity\n    for (let v = 0; v < vocab; v++) {\n      const val = logitsData[lastOffset + v]\n      if (val > bestVal) {\n        bestVal = val\n        bestId = v\n      }\n    }\n    tokens.push(bestId)\n    if (bestId === MFR_EOS_ID) break\n  }\n\n  // 첫 start 토큰 제외 + EOS/PAD 제거\n  const body: number[] = []\n  for (let i = 1; i < tokens.length; i++) {\n    const t = tokens[i]\n    if (t === MFR_EOS_ID) break\n    if (t === MFR_PAD_ID) continue\n    if (t < 0) continue\n    body.push(t)\n  }\n\n  // Transformers.js tokenizer.decode 는 skip_special_tokens=true 기본\n  const raw = tokenizer.decode(body, { skip_special_tokens: true })\n  return postProcessLatex(raw)\n}\n\n/**\n * DeiT preprocess:\n *   resize to 384×384 (bilinear)\n *   (pixel/255 - 0.5) / 0.5  ==  pixel/127.5 - 1\n *   CHW layout\n */\nexport function deitPreprocess(crop: PixelFrame, target: number): Float32Array {\n  const ts = target\n  const out = new Float32Array(3 * ts * ts)\n  const { data: src, width: srcW, height: srcH } = crop\n\n  // 단순 nearest (이미 수식 crop 은 300DPI 근방이라 충분). 필요시 sharp bilinear 로 교체.\n  for (let y = 0; y < ts; y++) {\n    const sy = Math.min(srcH - 1, Math.max(0, Math.floor(((y + 0.5) / ts) * srcH)))\n    for (let x = 0; x < ts; x++) {\n      const sx = Math.min(srcW - 1, Math.max(0, Math.floor(((x + 0.5) / ts) * srcW)))\n      const srcIdx = (sy * srcW + sx) * 4\n      const r = src[srcIdx]\n      const g = src[srcIdx + 1]\n      const b = src[srcIdx + 2]\n\n      const idx = y * ts + x\n      out[idx] = r / 127.5 - 1\n      out[ts * ts + idx] = g / 127.5 - 1\n      out[2 * ts * ts + idx] = b / 127.5 - 1\n    }\n  }\n  return out\n}\n","/**\n * 수식 OCR 파이프라인 — PDFium 렌더 + MFD + MFR 통합\n *\n * 한 번 생성된 FormulaPipeline 인스턴스는 ONNX 세션을 재사용해 여러 PDF 에 적용 가능.\n * Docufinder 는 CLI 프로세스 단위로 새로 띄우기 때문에 세션 재사용은 PDF 내부 페이지 루프에만 적용됨.\n */\n\nimport type { PDFiumLibrary, PDFiumDocument } from \"@hyzyla/pdfium\"\nimport type { InferenceSession } from \"onnxruntime-node\"\nimport type { PreTrainedTokenizer } from \"@huggingface/transformers\"\n\n/** sharp 은 CommonJS `export =` 형태라 타입을 직접 import 하기 까다로움. 함수형 시그니처만 사용. */\ntype SharpFactory = (\n  input: Uint8Array | Buffer,\n  options?: { raw?: { width: number; height: number; channels: number } },\n) => {\n  extract(region: { left: number; top: number; width: number; height: number }): {\n    raw(): { toBuffer(): Promise<Buffer> }\n  }\n}\n\nimport { detectFormulaRegions } from \"./detector.js\"\nimport { recognizeFormula } from \"./recognizer.js\"\nimport {\n  getFormulaModelsDir,\n  MFD_MODEL,\n  MFR_ENCODER_MODEL,\n  MFR_DECODER_MODEL,\n  MFR_TOKENIZER,\n} from \"./models.js\"\nimport type { FormulaRegion, PixelFrame } from \"./types.js\"\nimport { join } from \"path\"\n\n/** PDF 페이지 렌더 해상도 (scale=2 → 약 144 DPI). 수식 인식에는 이 이상은 과함. */\nconst RENDER_SCALE = 2\n\nexport interface FormulaPipelineOptions {\n  /** 수식 인식 페이지 스케일 (기본 2). 값을 올리면 작은 수식 인식률 ↑, 속도 ↓. */\n  scale?: number\n  /** 페이지별 최대 수식 수 (안전 상한). 기본 50. */\n  maxRegionsPerPage?: number\n  /** 페이지 하나당 타임아웃 (ms, 기본 60000 = 1분). 초과 시 해당 페이지 skip. */\n  pageTimeoutMs?: number\n}\n\nexport interface PageFormulaResult {\n  pageNumber: number\n  /** 페이지 전체 렌더 이미지의 가로/세로 (원본 좌표계, scale 반영됨) */\n  renderedWidth: number\n  renderedHeight: number\n  /** 원본 PDF 포인트 기준 너비/높이 (pdfjs 와 좌표 매핑용) */\n  pdfWidth: number\n  pdfHeight: number\n  regions: FormulaRegion[]\n}\n\n/**\n * 수식 OCR 실행 컨텍스트. 처음 호출 시 무겁게 초기화 (ONNX 세션 로드),\n * 이후 runOnBuffer / runOnPages 를 여러 번 호출해 재사용 가능.\n *\n * 모든 의존성(onnxruntime-node, @huggingface/transformers, @hyzyla/pdfium, sharp)은\n * optional 이므로 dynamic import. 미설치 시 초기화에서 명확한 에러 메시지 반환.\n */\nexport class FormulaPipeline {\n  private mfd: InferenceSession\n  private encoder: InferenceSession\n  private decoder: InferenceSession\n  private tokenizer: PreTrainedTokenizer\n  private ort: typeof import(\"onnxruntime-node\")\n  private sharp: SharpFactory\n  private pdfium: PDFiumLibrary\n  private opts: Required<FormulaPipelineOptions>\n\n  private constructor(parts: {\n    mfd: InferenceSession\n    encoder: InferenceSession\n    decoder: InferenceSession\n    tokenizer: PreTrainedTokenizer\n    ort: typeof import(\"onnxruntime-node\")\n    sharp: SharpFactory\n    pdfium: PDFiumLibrary\n    opts: Required<FormulaPipelineOptions>\n  }) {\n    this.mfd = parts.mfd\n    this.encoder = parts.encoder\n    this.decoder = parts.decoder\n    this.tokenizer = parts.tokenizer\n    this.ort = parts.ort\n    this.sharp = parts.sharp\n    this.pdfium = parts.pdfium\n    this.opts = parts.opts\n  }\n\n  /**\n   * 수식 OCR 엔진 초기화. 모델 파일이 로컬에 없으면 즉시 실패 — 호출자가\n   * `ensureFormulaModels()` 를 먼저 돌려야 한다.\n   */\n  static async create(options?: FormulaPipelineOptions): Promise<FormulaPipeline> {\n    const opts: Required<FormulaPipelineOptions> = {\n      scale: options?.scale ?? RENDER_SCALE,\n      maxRegionsPerPage: options?.maxRegionsPerPage ?? 50,\n      pageTimeoutMs: options?.pageTimeoutMs ?? 60_000,\n    }\n\n    const [ortMod, sharpModRaw, hfMod, pdfiumMod] = await Promise.all([\n      tryImport<typeof import(\"onnxruntime-node\")>(\n        \"onnxruntime-node\",\n        () => import(\"onnxruntime-node\"),\n      ),\n      tryImport<{ default?: SharpFactory } & SharpFactory>(\n        \"sharp\",\n        () => import(\"sharp\") as unknown as Promise<{ default?: SharpFactory } & SharpFactory>,\n      ),\n      tryImport<typeof import(\"@huggingface/transformers\")>(\n        \"@huggingface/transformers\",\n        () => import(\"@huggingface/transformers\"),\n      ),\n      tryImport<typeof import(\"@hyzyla/pdfium\")>(\n        \"@hyzyla/pdfium\",\n        () => import(\"@hyzyla/pdfium\"),\n      ),\n    ])\n    // CJS `export =` + ESM interop → default 속성에 래핑될 때도, 안 될 때도 있음.\n    const sharpAny = sharpModRaw as { default?: SharpFactory } | SharpFactory\n    const sharpMod: SharpFactory =\n      typeof sharpAny === \"function\"\n        ? sharpAny\n        : (sharpAny.default ?? (sharpAny as unknown as SharpFactory))\n\n    const modelsDir = getFormulaModelsDir()\n    const mfdPath = join(modelsDir, MFD_MODEL.filename)\n    const encPath = join(modelsDir, MFR_ENCODER_MODEL.filename)\n    const decPath = join(modelsDir, MFR_DECODER_MODEL.filename)\n    const tokPath = join(modelsDir, MFR_TOKENIZER.filename)\n\n    const sessionOpts: import(\"onnxruntime-node\").InferenceSession.SessionOptions = {\n      graphOptimizationLevel: \"all\",\n      executionProviders: [\"cpu\"],\n    }\n\n    // 각 세션은 I/O 바운드 아님 → 병렬 로드로 1~2초 단축\n    const [mfd, encoder, decoder] = await Promise.all([\n      ortMod.InferenceSession.create(mfdPath, sessionOpts),\n      ortMod.InferenceSession.create(encPath, sessionOpts),\n      ortMod.InferenceSession.create(decPath, sessionOpts),\n    ])\n\n    // Transformers.js 의 PreTrainedTokenizer 를 로컬 tokenizer.json 으로 로드.\n    // AutoTokenizer.from_pretrained 는 HF hub 접근을 시도하므로 우회.\n    const { readFile } = await import(\"fs/promises\")\n    const tokenizerJson = JSON.parse(await readFile(tokPath, \"utf-8\"))\n    const PretrainedCtor = hfMod.PreTrainedTokenizer as unknown as new (\n      json: unknown,\n      config: Record<string, unknown>,\n    ) => PreTrainedTokenizer\n    const tokenizer = new PretrainedCtor(tokenizerJson, {})\n\n    const pdfium = await pdfiumMod.PDFiumLibrary.init()\n\n    return new FormulaPipeline({\n      mfd,\n      encoder,\n      decoder,\n      tokenizer,\n      ort: ortMod,\n      sharp: sharpMod,\n      pdfium,\n      opts,\n    })\n  }\n\n  /** 리소스 해제 — 더 이상 사용하지 않을 때 호출. ONNX 세션은 onnxruntime-node 1.14+ release() 로 (구버전은 GC — ocr/engine.ts destroy 와 같은 방식) */\n  async destroy(): Promise<void> {\n    for (const s of [this.mfd, this.encoder, this.decoder]) {\n      const rel = (s as unknown as { release?: () => Promise<void> }).release\n      if (typeof rel === \"function\") {\n        try { await rel.call(s) } catch { /* ignore */ }\n      }\n    }\n    try {\n      this.pdfium.destroy()\n    } catch {\n      // ignore\n    }\n  }\n\n  /**\n   * PDF 버퍼를 열어 페이지별 수식 영역을 인식한다.\n   * 실패한 페이지는 skip (에러 전파 없음 — 로그만).\n   *\n   * @param pageFilter null 이면 전체 페이지. Set 이면 1-based 페이지 번호 일치만.\n   */\n  async runOnBuffer(\n    buffer: ArrayBuffer | Uint8Array,\n    pageFilter: Set<number> | null = null,\n    onPageProgress?: (pageNumber: number, total: number) => void,\n  ): Promise<PageFormulaResult[]> {\n    const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer)\n    const doc: PDFiumDocument = await this.pdfium.loadDocument(view)\n    try {\n      const pages: PageFormulaResult[] = []\n      // 대상 쪽만 연다 — doc.pages() 는 모든 쪽을 불러오고 render() 가 끝에서만 닫아, 필터 밖 쪽이 문서를 닫을 때까지 남았다\n      // (ocr/pdf-ocr.ts runPdfOcr 와 같은 수정). pdfium 쪽 번호는 0-based — pdfjs 블록/pageFilter 는 1-based.\n      // 환산 없이는 필터가 한 페이지 밀리고 수식이 이전 페이지 블록에 붙는다 (off-by-one).\n      const count = doc.getPageCount()\n      const pageNos = pageFilter\n        ? [...pageFilter].filter(p => p >= 1 && p <= count).sort((a, b) => a - b)\n        : Array.from({ length: count }, (_, i) => i + 1)\n      for (const pageNo of pageNos) {\n        const page = doc.getPage(pageNo - 1)\n        onPageProgress?.(pageNo, count)\n\n        try {\n          const result = await withTimeout(\n            this.processPage(pageNo, page),\n            this.opts.pageTimeoutMs,\n            `formula page ${pageNo} timed out after ${this.opts.pageTimeoutMs}ms`,\n          )\n          if (result) pages.push(result)\n        } catch (e) {\n          // 페이지 단위 실패는 조용히 넘어간다 — 전체 PDF 파싱 실패 방지.\n          process.stderr.write(\n            `[kordoc-formula] page ${pageNo} skipped: ${(e as Error).message}\\n`,\n          )\n        }\n      }\n      return pages\n    } finally {\n      doc.destroy()\n    }\n  }\n\n  private async processPage(\n    pageNumber: number,\n    page: import(\"@hyzyla/pdfium\").PDFiumPage,\n  ): Promise<PageFormulaResult | null> {\n    const { originalWidth: pdfWidth, originalHeight: pdfHeight } = page.getOriginalSize()\n\n    const sharpCtor = this.sharp\n    const rendered = await page.render({\n      scale: this.opts.scale,\n      render: async ({ data, width, height }) => {\n        // 임시로 PNG 로 인코딩하지 않고 raw 그대로 반환 — 바로 쓸 거라서.\n        return data\n      },\n    })\n    // rendered.data 는 BGRA — sharp 로 RGBA 로 변환\n    const { data: bgra, width: rw, height: rh } = rendered\n    const rgba = bgraToRgba(bgra)\n\n    const pageFrame: PixelFrame = { width: rw, height: rh, data: rgba }\n\n    // 1) 수식 영역 검출\n    const regions0 = await detectFormulaRegions(this.mfd, pageFrame, this.ort)\n    if (regions0.length === 0) {\n      return { pageNumber, renderedWidth: rw, renderedHeight: rh, pdfWidth, pdfHeight, regions: [] }\n    }\n\n    const capped = regions0.slice(0, this.opts.maxRegionsPerPage)\n    const regions: FormulaRegion[] = []\n\n    // 2) 각 영역 crop → 인식\n    for (const r of capped) {\n      const x1 = Math.floor(Math.max(0, r.bbox.x1))\n      const y1 = Math.floor(Math.max(0, r.bbox.y1))\n      const x2 = Math.ceil(Math.min(rw, r.bbox.x2))\n      const y2 = Math.ceil(Math.min(rh, r.bbox.y2))\n      const cw = x2 - x1\n      const ch = y2 - y1\n      if (cw < 4 || ch < 4) continue\n\n      // sharp 로 raw RGBA 에서 crop → raw RGBA 반환\n      const cropRgba = await sharpCtor(rgba, {\n        raw: { width: rw, height: rh, channels: 4 },\n      })\n        .extract({ left: x1, top: y1, width: cw, height: ch })\n        .raw()\n        .toBuffer()\n\n      const cropFrame: PixelFrame = { width: cw, height: ch, data: new Uint8Array(cropRgba) }\n\n      let latex = \"\"\n      try {\n        latex = await recognizeFormula(\n          {\n            encoder: this.encoder,\n            decoder: this.decoder,\n            tokenizer: this.tokenizer,\n            ort: this.ort,\n          },\n          cropFrame,\n        )\n      } catch (e) {\n        process.stderr.write(\n          `[kordoc-formula] recognize failed at page ${pageNumber} ${JSON.stringify(r.bbox)}: ${(e as Error).message}\\n`,\n        )\n        latex = \"\"\n      }\n\n      regions.push({ ...r, latex })\n    }\n\n    return {\n      pageNumber,\n      renderedWidth: rw,\n      renderedHeight: rh,\n      pdfWidth,\n      pdfHeight,\n      regions,\n    }\n  }\n}\n\nasync function tryImport<T>(name: string, loader: () => Promise<T>): Promise<T> {\n  try {\n    return await loader()\n  } catch (e) {\n    throw new Error(\n      `수식 OCR 을 사용하려면 optional dependency '${name}' 이 필요합니다. ` +\n        `\\`npm install ${name}\\` 후 다시 실행하세요. 원인: ${(e as Error).message}`,\n    )\n  }\n}\n\nasync function withTimeout<T>(promise: Promise<T>, ms: number, msg: string): Promise<T> {\n  // 타임아웃으로 race 가 끝난 뒤에도 원 promise 는 계속 실행된다 — 사후 reject 가\n  // unhandled rejection(Node 기본 정책: 프로세스 종료)이 되지 않게 흡수\n  promise.catch(() => {})\n  let timer: NodeJS.Timeout | undefined\n  try {\n    return await Promise.race([\n      promise,\n      new Promise<never>((_, reject) => {\n        timer = setTimeout(() => reject(new Error(msg)), ms)\n      }),\n    ])\n  } finally {\n    if (timer) clearTimeout(timer)\n  }\n}\n\n/** pdfium 의 BGRA 버퍼를 RGBA 로 변환 (Red ↔ Blue 스왑). */\nfunction bgraToRgba(bgra: Uint8Array): Uint8Array {\n  const out = new Uint8Array(bgra.length)\n  for (let i = 0; i < bgra.length; i += 4) {\n    out[i] = bgra[i + 2] // R ← B\n    out[i + 1] = bgra[i + 1] // G ← G\n    out[i + 2] = bgra[i] // B ← R\n    out[i + 3] = bgra[i + 3] // A ← A\n  }\n  return out\n}\n"]}

package/dist/image-ocr-PSPVRLB5.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/mong-e/workspace/kordoc-quality-99/dist/image-ocr-PSPVRLB5.cjs","../src/ocr/image-ocr.ts"],"names":[],"mappings":"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","file":"/Users/mong-e/workspace/kordoc-quality-99/dist/image-ocr-PSPVRLB5.cjs","sourcesContent":[null,"/**\n * 이미지 직접 입력 OCR — PNG/JPEG/WebP 를 PDF 래핑 없이 바로 파싱한다.\n *\n * 이미지는 텍스트층이 없으므로 OCR 이 항상 필요하다 — `--ocr` 플래그 없이도\n * 내장 엔진(PP-OCRv5 korean)을 기본 적용하고, OcrProvider 가 주어지면 위임한다.\n * 좌표는 이미지 해상도(imageScale — 메타데이터 DPI, 없으면 A4·Letter 판형 추정, 그것도\n * 아니면 216dpi)로 PDF pt 공간에 환산해 기존 블록 파이프라인\n * (괘선 감지 → 선 기반 표 → 클러스터 → xy-cut)을 그대로 태운다.\n *\n * 디코딩은 optional dependency `sharp` — 미설치면 MISSING_DEPENDENCY 안내.\n */\n\nimport type { IRBlock, ParseOptions, ParseWarning } from \"../types.js\"\nimport { KordocError, OPTIONAL_DEP_INSTALL_HINT } from \"../utils.js\"\nimport { getOcrEngine, type OcrPageStats } from \"./engine.js\"\nimport { ensureOcrModels } from \"./models.js\"\nimport { detectRulingLines, rulingToPdfLines } from \"./ruling-lines.js\"\nimport { MAX_OCR_PIXELS, ocrItemsToBlocks } from \"./pdf-ocr.js\"\nimport { deskewPage } from \"./deskew.js\"\n\n/** 좌표 환산 기본 스케일 (px/pt) — PDF OCR 렌더(216dpi)와 동일 기준 */\nconst IMAGE_SCALE = 3\n\n/**\n * 이미지 px/pt 스케일 추정. 블록 파이프라인의 문턱(줄 묶음 3pt·괘선 최소 길이 20pt·표 간격)은\n * pt 기준이라, 150dpi 스캔을 216dpi 로 가정하면 페이지가 0.69배로 쪼그라든 좌표가 된다.\n *  1) 메타데이터 DPI(JFIF·pHYs·EXIF) 100~1200 — 72/96 은 기본값·화면값이라 불신\n *  2) 판형: 긴 변/짧은 변이 √2(A판)·11/8.5(Letter) ±2% 면 전면 스캔 — A4 842pt·Letter 792pt 긴 변\n *  3) 그 밖: 216dpi 가정 (종전 동작)\n */\nexport function imageScale(width: number, height: number, densityDpi?: number): number {\n  if (densityDpi && densityDpi >= 100 && densityDpi <= 1200) return densityDpi / 72\n  const long = Math.max(width, height), short = Math.min(width, height)\n  if (short > 0) {\n    const r = long / short\n    if (Math.abs(r / Math.SQRT2 - 1) <= 0.02) return long / 842\n    if (Math.abs(r / (11 / 8.5) - 1) <= 0.02) return long / 792\n  }\n  return IMAGE_SCALE\n}\n\nexport interface ImageOcrResult {\n  blocks: IRBlock[]\n  warnings: ParseWarning[]\n}\n\n/** 이미지 버퍼 → OCR → IRBlock[] (표 괘선 감지 포함) */\nexport async function parseImageDocument(\n  buffer: ArrayBuffer,\n  options?: ParseOptions,\n): Promise<ImageOcrResult> {\n  const warnings: ParseWarning[] = []\n\n  // 사용자 OcrProvider — 원본 바이트 그대로 위임 (종전 PDF 경로와 같은 계약)\n  if (typeof options?.ocr === \"function\") {\n    const text = await options.ocr(new Uint8Array(buffer), 1, detectImageMime(buffer))\n    if (!text.trim()) {\n      warnings.push({ page: 1, message: \"OCR 결과 없음\", code: \"OCR_FAILED\" })\n      return { blocks: [], warnings }\n    }\n    return { blocks: [{ type: \"paragraph\", text: text.trim(), pageNumber: 1 }], warnings }\n  }\n\n  const { data: decoded, width, height, density, shrink } = await decodeToRgba(buffer)\n  if (shrink < 1) warnings.push({ page: 1, code: \"PARTIAL_PARSE\", message: \"OCR 래스터 픽셀 상한으로 이미지 해상도를 축소했습니다 (작은 글자 인식 결손 가능)\" })\n  // 픽셀 상한으로 줄인 이미지는 같은 지면을 낮은 해상도로 본 것 — px/pt 도 같은 비율로\n  const scale = imageScale(width / shrink, height / shrink, density) * shrink\n  // 스캔·사진 기울기 보정 — 인식과 괘선 감지가 같은(바로 선) 래스터를 본다\n  const { rgba: data } = deskewPage(decoded, width, height)\n\n  await ensureOcrModels(p => {\n    if (p.phase === \"download\" && p.downloaded === 0) {\n      process.stderr.write(`[kordoc-ocr] ${p.spec.name} 다운로드 중 (~${p.spec.sizeMb}MB)...\\n`)\n    }\n  })\n  const engine = await getOcrEngine()\n  const stats: OcrPageStats = { droppedLowConf: 0 }\n  const items = await engine.recognizePage(data, width, height, stats)\n  if (stats.droppedLowConf > 0) {\n    warnings.push({\n      page: 1,\n      message: `저신뢰 OCR 라인 ${stats.droppedLowConf}개 폐기 (인식 결손 가능)`,\n      code: \"OCR_LOW_CONF\",\n    })\n  }\n  if (stats.truncatedBoxes) {\n    warnings.push({ page: 1, message: `OCR 검출 상자가 너무 많아 ${stats.truncatedBoxes}개는 인식하지 않음 (일부 글 결손)`, code: \"PARTIAL_PARSE\" })\n  }\n  if (items.length === 0) {\n    warnings.push({ page: 1, message: \"이미지에서 텍스트를 인식하지 못했습니다\", code: \"OCR_FAILED\" })\n    return { blocks: [], warnings }\n  }\n\n  const pdfW = width / scale\n  const pdfH = height / scale\n  const ruling = detectRulingLines(data, width, height, scale)\n  const extraLines = rulingToPdfLines(ruling, scale, pdfH)\n  return { blocks: ocrItemsToBlocks(items, 1, pdfW, pdfH, scale, extraLines, options?.tables !== false), warnings }\n}\n\n/**\n * sharp 로 RGBA 디코딩 — 미설치는 MISSING_DEPENDENCY 로 분류되도록 안내 메시지 throw.\n * EXIF 방향대로 세운다(`rotate()`): 폰으로 세로 촬영한 JPEG 은 픽셀을 눕혀 저장하고 Orientation 6 으로 표시 방향만 적는다 —\n * 무시하면 누운 글을 읽어 한글 131자 쪽이 쓰레기 57자가 됐다. 픽셀이 MAX_OCR_PIXELS 를 넘으면 그 안으로 줄인다(shrink = 줄인 배율).\n * (테스트용 export)\n */\nexport async function decodeToRgba(\n  buffer: ArrayBuffer,\n): Promise<{ data: Uint8Array; width: number; height: number; density?: number; shrink: number }> {\n  type Chain = {\n    rotate(): Chain\n    resize(w: number, h: number, opts: { fit: \"fill\" }): Chain\n    ensureAlpha(): { raw(): { toBuffer(opts: { resolveWithObject: true }): Promise<{ data: Buffer; info: { width: number; height: number } }> } }\n    metadata(): Promise<{ density?: number; width?: number; height?: number; orientation?: number }>\n  }\n  type SharpFactory = (input: Buffer) => Chain\n  let sharp: SharpFactory\n  try {\n    const mod = (await import(\"sharp\")) as unknown as SharpFactory | { default?: SharpFactory }\n    sharp = typeof mod === \"function\" ? mod : (mod.default ?? (mod as unknown as SharpFactory))\n  } catch (e) {\n    // KordocError + \"optional dependency\" 문구 → sanitizeError 메시지 보존 + MISSING_DEPENDENCY 분류\n    throw new KordocError(\n      \"이미지 파싱에는 optional dependency 'sharp' 가 필요합니다. \" +\n        `\\`npm install sharp\\` 후 다시 실행하세요.${OPTIONAL_DEP_INSTALL_HINT} 원인: ${(e as Error).message}`,\n    )\n  }\n  const input = Buffer.from(buffer)\n  const meta: { density?: number; width?: number; height?: number; orientation?: number } = await sharp(input).metadata().catch(() => ({}))\n  // 5~8 은 90° 돌린 방향 — 세운 뒤 가로·세로가 바뀐다\n  const [w0, h0] = (meta.orientation ?? 1) >= 5 ? [meta.height ?? 0, meta.width ?? 0] : [meta.width ?? 0, meta.height ?? 0]\n  const shrink = w0 * h0 > MAX_OCR_PIXELS ? Math.sqrt(MAX_OCR_PIXELS / (w0 * h0)) : 1\n  let chain = sharp(input).rotate()\n  if (shrink < 1) chain = chain.resize(Math.max(1, Math.floor(w0 * shrink)), Math.max(1, Math.floor(h0 * shrink)), { fit: \"fill\" })\n  const { data, info } = await chain.ensureAlpha().raw().toBuffer({ resolveWithObject: true })\n  return {\n    data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength), width: info.width, height: info.height, density: meta.density,\n    shrink: w0 ? info.width / w0 : 1,\n  }\n}\n\n/** OcrProvider 계약용 mime 판별 */\nfunction detectImageMime(buffer: ArrayBuffer): \"image/png\" | \"image/jpeg\" | \"image/webp\" {\n  const b = new Uint8Array(buffer, 0, Math.min(12, buffer.byteLength))\n  if (b[0] === 0xff && b[1] === 0xd8) return \"image/jpeg\"\n  if (b[0] === 0x52 && b[1] === 0x49) return \"image/webp\"\n  return \"image/png\"\n}\n"]}