kordoc 4.1.0 → 4.2.0

package/dist/parser-RBZHA6SY.js

@@ -0,0 +1,804 @@
+#!/usr/bin/env node
+import {
+  collapseEvenSpacing,
+  computeMedianFontSizeFromFreq,
+  detectHeadings,
+  detectKoreanListBlocks,
+  detectMarkerHeadings,
+  detectTableCaptions,
+  extractImageRegions,
+  extractPageBlocksWithLines,
+  filterHiddenText,
+  mergeCrossPageTables,
+  normalizeItems,
+  removeHeaderFooterBlocks
+} from "./chunk-26AJJCFF.js";
+import {
+  encodePng
+} from "./chunk-7FCNOKOR.js";
+import "./chunk-4VNLZ2GZ.js";
+import {
+  parsePageRange
+} from "./chunk-MOL7MDBG.js";
+import {
+  blocksToMarkdown
+} from "./chunk-CMN3SYZ3.js";
+import {
+  KordocError
+} from "./chunk-FSXLSHCW.js";
+
+// src/pdf/image-extract.ts
+import { OPS, ImageKind } from "pdfjs-dist/legacy/build/pdf.mjs";
+var IMAGE_RESOLVE_TIMEOUT_MS = 5e3;
+function resolveImgData(page, objId) {
+  const store = objId.startsWith("g_") ? page.commonObjs : page.objs;
+  return new Promise((resolve) => {
+    let done = false;
+    const timer = setTimeout(() => {
+      if (!done) {
+        done = true;
+        resolve(null);
+      }
+    }, IMAGE_RESOLVE_TIMEOUT_MS);
+    try {
+      store.get(objId, (data) => {
+        if (!done) {
+          done = true;
+          clearTimeout(timer);
+          resolve(data ?? null);
+        }
+      });
+    } catch {
+      if (!done) {
+        done = true;
+        clearTimeout(timer);
+        resolve(null);
+      }
+    }
+  });
+}
+var MIN_DIM = 8;
+var MAX_PIXELS = 36e6;
+var MAX_IMAGES_PER_DOC = 200;
+var MAX_TOTAL_IMAGE_BYTES = 128 * 1024 * 1024;
+function createPdfImageState() {
+  return { imageIndex: 0, totalBytes: 0, seen: /* @__PURE__ */ new Map(), capWarned: false };
+}
+function fnv1a(data) {
+  let h = 2166136261;
+  for (let i = 0; i < data.length; i++) {
+    h ^= data[i];
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function toRgba(img) {
+  const { width: w, height: h, kind, data } = img;
+  if (!data || !w || !h) return null;
+  const rgba = new Uint8Array(w * h * 4);
+  if (kind === ImageKind.RGBA_32BPP) {
+    if (data.length < w * h * 4) return null;
+    rgba.set(data.subarray(0, w * h * 4));
+    return rgba;
+  }
+  if (kind === ImageKind.RGB_24BPP) {
+    if (data.length < w * h * 3) return null;
+    for (let i = 0, s = 0, d = 0; i < w * h; i++, s += 3, d += 4) {
+      rgba[d] = data[s];
+      rgba[d + 1] = data[s + 1];
+      rgba[d + 2] = data[s + 2];
+      rgba[d + 3] = 255;
+    }
+    return rgba;
+  }
+  if (kind === ImageKind.GRAYSCALE_1BPP) {
+    const stride = w + 7 >> 3;
+    if (data.length < stride * h) return null;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const bit = data[y * stride + (x >> 3)] >> 7 - (x & 7) & 1;
+        const v = bit ? 255 : 0;
+        const d = (y * w + x) * 4;
+        rgba[d] = v;
+        rgba[d + 1] = v;
+        rgba[d + 2] = v;
+        rgba[d + 3] = 255;
+      }
+    }
+    return rgba;
+  }
+  return null;
+}
+async function extractPageImages(page, fnArray, argsArray, pageNumber, state, warnings) {
+  const blocks = [];
+  const images = [];
+  const pageSeenIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    let imgData = null;
+    let dedupeId = null;
+    if (op === OPS.paintImageXObject || op === OPS.paintImageXObjectRepeat) {
+      const objId = argsArray[i]?.[0];
+      if (typeof objId !== "string" || pageSeenIds.has(objId)) continue;
+      pageSeenIds.add(objId);
+      dedupeId = objId;
+    } else if (op !== OPS.paintInlineImageXObject) {
+      continue;
+    }
+    if (state.imageIndex >= MAX_IMAGES_PER_DOC || state.totalBytes >= MAX_TOTAL_IMAGE_BYTES) {
+      if (!state.capWarned) {
+        state.capWarned = true;
+        warnings.push({ page: pageNumber, message: `\uC774\uBBF8\uC9C0 \uCD94\uCD9C \uC0C1\uD55C \uB3C4\uB2EC (${MAX_IMAGES_PER_DOC}\uAC1C/128MB) \u2014 \uC774\uD6C4 \uC774\uBBF8\uC9C0 \uC0DD\uB7B5`, code: "SKIPPED_IMAGE" });
+      }
+      continue;
+    }
+    if (dedupeId) {
+      imgData = await resolveImgData(page, dedupeId);
+    } else {
+      imgData = argsArray[i]?.[0];
+    }
+    if (!imgData?.data || !imgData.width || !imgData.height) continue;
+    const { width: w, height: h } = imgData;
+    if (w < MIN_DIM || h < MIN_DIM) continue;
+    if (w * h > MAX_PIXELS) {
+      warnings.push({ page: pageNumber, message: `\uC774\uBBF8\uC9C0 \uD06C\uAE30 \uCD08\uACFC\uB85C \uCD94\uCD9C \uC0DD\uB7B5 (${w}\xD7${h})`, code: "SKIPPED_IMAGE" });
+      continue;
+    }
+    const hash = `${w}x${h}k${imgData.kind ?? "?"}h${fnv1a(imgData.data)}${dedupeId ? "" : "inline"}`;
+    if (state.seen.has(hash)) continue;
+    const rgba = toRgba(imgData);
+    if (!rgba) continue;
+    const png = encodePng(w, h, rgba);
+    state.imageIndex++;
+    state.totalBytes += png.length;
+    const filename = `image_${String(state.imageIndex).padStart(3, "0")}.png`;
+    state.seen.set(hash, filename);
+    images.push({ filename, data: png, mimeType: "image/png" });
+    blocks.push({ type: "image", text: filename, pageNumber });
+  }
+  return { blocks, images };
+}
+function injectPageImageBlocks(blocks, pageImages) {
+  if (pageImages.size === 0) return;
+  const lastIndexForPage = /* @__PURE__ */ new Map();
+  for (let i = 0; i < blocks.length; i++) {
+    const p = blocks[i].pageNumber;
+    if (p !== void 0) lastIndexForPage.set(p, i);
+  }
+  const pageAtIndex = /* @__PURE__ */ new Map();
+  for (const [p, last] of lastIndexForPage) pageAtIndex.set(last, p);
+  const result = [];
+  const injected = /* @__PURE__ */ new Set();
+  for (let i = 0; i < blocks.length; i++) {
+    result.push(blocks[i]);
+    const p = pageAtIndex.get(i);
+    if (p !== void 0 && pageImages.has(p)) {
+      result.push(...pageImages.get(p));
+      injected.add(p);
+    }
+  }
+  for (const p of [...pageImages.keys()].sort((a, b) => a - b)) {
+    if (injected.has(p)) continue;
+    let at = result.length;
+    for (let i = 0; i < result.length; i++) {
+      const bp = result[i].pageNumber;
+      if (bp !== void 0 && bp > p) {
+        at = i;
+        break;
+      }
+    }
+    result.splice(at, 0, ...pageImages.get(p));
+  }
+  blocks.length = 0;
+  blocks.push(...result);
+}
+
+// src/pdf/quality.ts
+var RARE_JONG = /* @__PURE__ */ new Set([3, 5, 6, 9, 10, 11, 12, 13, 14, 15, 18, 24, 25, 26]);
+var MOJIBAKE_MIN_HANGUL = 30;
+var MOJIBAKE_MAX_NOBATCHIM = 0.15;
+var MOJIBAKE_MIN_RAREBATCHIM = 0.25;
+function computePageQuality(page, text) {
+  let total = 0;
+  let hangul = 0;
+  let hangulNoBatchim = 0;
+  let hangulRareBatchim = 0;
+  let control = 0;
+  let replacement = 0;
+  let pua = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 32 || code === 9 || code === 10 || code === 13) continue;
+    total++;
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) {
+      control++;
+      continue;
+    }
+    if (code === 65533) {
+      replacement++;
+      continue;
+    }
+    if (code >= 44032 && code <= 55203) {
+      hangul++;
+      const jong = (code - 44032) % 28;
+      if (jong === 0) hangulNoBatchim++;
+      else if (RARE_JONG.has(jong)) hangulRareBatchim++;
+      continue;
+    }
+    if (code >= 57344 && code <= 63743 || code >= 56192 && code <= 56319) {
+      pua++;
+      continue;
+    }
+  }
+  const denom = total || 1;
+  const puaRatio = pua / denom;
+  const controlCharRatio = control / denom;
+  const replacementCharRatio = replacement / denom;
+  const hangulNoBatchimRatio = hangul > 0 ? hangulNoBatchim / hangul : 0;
+  const hangulRareBatchimRatio = hangul > 0 ? hangulRareBatchim / hangul : 0;
+  const garbledHangul = hangul >= MOJIBAKE_MIN_HANGUL && hangulNoBatchimRatio < MOJIBAKE_MAX_NOBATCHIM && hangulRareBatchimRatio >= MOJIBAKE_MIN_RAREBATCHIM;
+  let needsOcr = false;
+  let ocrReason;
+  if (total < LOW_TEXT_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "low_text";
+  } else if (puaRatio >= HIGH_PUA_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_pua";
+  } else if (controlCharRatio >= HIGH_CONTROL_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_control";
+  } else if (replacementCharRatio >= HIGH_REPLACEMENT_THRESHOLD) {
+    needsOcr = true;
+    ocrReason = "high_replacement";
+  } else if (garbledHangul) {
+    needsOcr = true;
+    ocrReason = "garbled_hangul";
+  }
+  return {
+    page,
+    textChars: total,
+    hangulRatio: hangul / denom,
+    controlCharRatio,
+    replacementCharRatio,
+    puaRatio,
+    hangulNoBatchimRatio,
+    hangulRareBatchimRatio,
+    needsOcr,
+    ocrReason
+  };
+}
+var LOW_TEXT_THRESHOLD = 20;
+var HIGH_PUA_THRESHOLD = 0.2;
+var HIGH_CONTROL_THRESHOLD = 0.05;
+var HIGH_REPLACEMENT_THRESHOLD = 0.05;
+var DOC_NEEDS_OCR_PAGE_RATIO = 0.3;
+function stripControlChars(text) {
+  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\x80-\x9F]/g, "");
+}
+function summarizeDocumentQuality(pages) {
+  if (pages.length === 0) {
+    return {
+      totalPages: 0,
+      totalTextChars: 0,
+      avgHangulRatio: 0,
+      avgControlCharRatio: 0,
+      avgReplacementCharRatio: 0,
+      avgPuaRatio: 0,
+      lowTextPageCount: 0,
+      highPuaPageCount: 0,
+      needsOcr: false,
+      ocrCandidatePages: []
+    };
+  }
+  let textChars = 0;
+  let hangul = 0;
+  let control = 0;
+  let replacement = 0;
+  let pua = 0;
+  let lowText = 0;
+  let highPua = 0;
+  const ocrCandidatePages = [];
+  for (const p of pages) {
+    textChars += p.textChars;
+    hangul += p.hangulRatio;
+    control += p.controlCharRatio;
+    replacement += p.replacementCharRatio;
+    pua += p.puaRatio;
+    if (p.textChars < LOW_TEXT_THRESHOLD) lowText++;
+    if (p.puaRatio >= HIGH_PUA_THRESHOLD) highPua++;
+    if (p.needsOcr && !p.ocrApplied) ocrCandidatePages.push(p.page);
+  }
+  const n = pages.length;
+  return {
+    totalPages: n,
+    totalTextChars: textChars,
+    avgHangulRatio: hangul / n,
+    avgControlCharRatio: control / n,
+    avgReplacementCharRatio: replacement / n,
+    avgPuaRatio: pua / n,
+    lowTextPageCount: lowText,
+    highPuaPageCount: highPua,
+    needsOcr: ocrCandidatePages.length / n >= DOC_NEEDS_OCR_PAGE_RATIO,
+    ocrCandidatePages
+  };
+}
+
+// src/pdf/text-clean.ts
+function sanitizeBlockControlChars(blocks) {
+  for (const b of blocks) {
+    if (b.text) b.text = stripControlChars(b.text);
+    if (b.table) {
+      for (const row of b.table.cells) {
+        for (const cell of row) {
+          if (cell.text) cell.text = stripControlChars(cell.text);
+        }
+      }
+    }
+    if (b.children) sanitizeBlockControlChars(b.children);
+  }
+}
+function cleanPdfText(text) {
+  return mergeKoreanLines(
+    stripControlChars(text).replace(/^\d{1,4}\n/, "").replace(/^[\s]*[-–—]\s*[-–—]?\d+[-–—]?[\s]*[-–—]?[\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "").replace(/\n\d{1,4}\n/g, "\n").replace(/\n\d{1,4}$/, "").replace(/^#{1,6}\s*\d{1,4}\s*$/gm, "")
+  ).replace(/^(?!\| ---).*$/gm, (line) => {
+    if (/^\s*\${1,2}.+\${1,2}\s*$/.test(line)) return line;
+    return collapseEvenSpacing(line);
+  }).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\\~\\~/g, "~~").replace(/~~~~/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function startsWithMarker(line) {
+  const t = line.trimStart();
+  return /^[가-힣ㄱ-ㅎ][.)]/.test(t) || /^\d+[.)]/.test(t) || /^\([가-힣ㄱ-ㅎ\d]+\)/.test(t) || /^[○●※▶▷◆◇■□★☆\-·]\s/.test(t) || /^제\d+[조항호장절]/.test(t);
+}
+function isStandaloneHeader(line) {
+  return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(line.trim());
+}
+function mergeKoreanLines(text) {
+  if (!text) return "";
+  const lines = text.split("\n");
+  if (lines.length <= 1) return text;
+  const result = [lines[0]];
+  for (let i = 1; i < lines.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = lines[i];
+    const currTrimmed = curr.trim();
+    if (/^#{1,6}\s/.test(prev) || /^#{1,6}\s/.test(curr) || /^\|/.test(currTrimmed) || /^---/.test(currTrimmed)) {
+      result.push(curr);
+      continue;
+    }
+    if (/,$/.test(prev.trim()) && currTrimmed.length > 0) {
+      result[result.length - 1] = prev + "\n" + curr;
+      continue;
+    }
+    if (/^\(※/.test(currTrimmed)) {
+      result[result.length - 1] = prev + " " + currTrimmed;
+      continue;
+    }
+    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev) && !startsWithMarker(prev)) {
+      result[result.length - 1] = prev + " " + curr;
+    } else {
+      result.push(curr);
+    }
+  }
+  return result.join("\n");
+}
+
+// src/pdf/formula-ocr.ts
+async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
+  const formulaMod = await import("./formula-SXC6LRRC.js");
+  const { FormulaPipeline, ensureFormulaModels } = formulaMod;
+  await ensureFormulaModels((p) => {
+    if (p.phase === "download" && p.total) {
+      const pct = Math.floor(p.downloaded / p.total * 100);
+      process.stderr.write(`\r[kordoc-formula] ${p.spec.name} ${pct}% (${formatMb(p.downloaded)}/${formatMb(p.total)})`);
+      if (p.downloaded >= p.total) process.stderr.write("\n");
+    } else if (p.phase === "verify") {
+      process.stderr.write(`[kordoc-formula] ${p.spec.name} SHA-256 \uAC80\uC99D \uC911...
+`);
+    } else if (p.phase === "done") {
+      process.stderr.write(`[kordoc-formula] ${p.spec.name} \uC900\uBE44 \uC644\uB8CC
+`);
+    } else if (p.phase === "skip") {
+    }
+  });
+  const pipeline = await FormulaPipeline.create();
+  try {
+    const effectiveFilter = pageFilter ?? new Set(Array.from({ length: effectivePageCount }, (_, i) => i + 1));
+    const pagesResult = await pipeline.runOnBuffer(buffer, effectiveFilter);
+    if (pagesResult.length === 0) return;
+    let insertedCount = 0;
+    let removedDupCount = 0;
+    for (const page of pagesResult) {
+      const pageNumber = page.pageNumber;
+      const pdfHeight = page.pdfHeight;
+      const scaleX = page.renderedWidth > 0 ? page.pdfWidth / page.renderedWidth : 0.5;
+      const scaleY = page.renderedHeight > 0 ? page.pdfHeight / page.renderedHeight : 0.5;
+      const candidates = [];
+      for (const r of page.regions) {
+        if (!r.latex || !r.latex.trim()) continue;
+        const wrapped = r.kind === "display" ? `$$${r.latex}$$` : `$${r.latex}$`;
+        const x1 = r.bbox.x1 * scaleX;
+        const x2 = r.bbox.x2 * scaleX;
+        const yTop = pdfHeight - r.bbox.y1 * scaleY;
+        const yBottom = pdfHeight - r.bbox.y2 * scaleY;
+        const centerY = (yTop + yBottom) / 2;
+        const width = x2 - x1;
+        const height = yTop - yBottom;
+        candidates.push({
+          block: {
+            type: "paragraph",
+            text: wrapped,
+            pageNumber,
+            bbox: { page: pageNumber, x: x1, y: yBottom, width, height }
+          },
+          pdfBbox: { x1, x2, yTop, yBottom },
+          centerY
+        });
+      }
+      if (candidates.length === 0) continue;
+      const OVERLAP_THRESHOLD = 0.6;
+      const indicesToRemove = /* @__PURE__ */ new Set();
+      for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        if (b.pageNumber !== pageNumber) continue;
+        if (b.type === "table") continue;
+        if (!b.bbox || b.bbox.width <= 0 || b.bbox.height <= 0) continue;
+        const blockArea = b.bbox.width * b.bbox.height;
+        if (blockArea <= 0) continue;
+        for (const c of candidates) {
+          const ox1 = Math.max(b.bbox.x, c.pdfBbox.x1);
+          const ox2 = Math.min(b.bbox.x + b.bbox.width, c.pdfBbox.x2);
+          const oy1 = Math.max(b.bbox.y, c.pdfBbox.yBottom);
+          const oy2 = Math.min(b.bbox.y + b.bbox.height, c.pdfBbox.yTop);
+          const interArea = Math.max(0, ox2 - ox1) * Math.max(0, oy2 - oy1);
+          if (interArea / blockArea >= OVERLAP_THRESHOLD) {
+            indicesToRemove.add(i);
+            break;
+          }
+        }
+      }
+      if (indicesToRemove.size > 0) {
+        const sorted = [...indicesToRemove].sort((a, b) => b - a);
+        for (const idx of sorted) blocks.splice(idx, 1);
+        removedDupCount += indicesToRemove.size;
+      }
+      candidates.sort((a, b) => b.centerY - a.centerY);
+      for (const c of candidates) {
+        let insertIdx = -1;
+        let pageFirstIdx = -1;
+        let pageLastIdx = -1;
+        for (let i = 0; i < blocks.length; i++) {
+          const b = blocks[i];
+          if (b.pageNumber !== pageNumber) continue;
+          if (pageFirstIdx === -1) pageFirstIdx = i;
+          pageLastIdx = i;
+          if (!b.bbox) continue;
+          const blockCenter = b.bbox.y + b.bbox.height / 2;
+          if (blockCenter < c.centerY) {
+            insertIdx = i;
+            break;
+          }
+        }
+        if (insertIdx !== -1) {
+          blocks.splice(insertIdx, 0, c.block);
+        } else if (pageLastIdx !== -1) {
+          blocks.splice(pageLastIdx + 1, 0, c.block);
+        } else {
+          blocks.push(c.block);
+        }
+        insertedCount++;
+      }
+    }
+    if (insertedCount > 0 || removedDupCount > 0) {
+      process.stderr.write(
+        `[kordoc-formula] ${insertedCount}\uAC1C \uC218\uC2DD \uC0BD\uC785, ${removedDupCount}\uAC1C \uC911\uBCF5 block \uC81C\uAC70 (${pagesResult.length}\uAC1C \uD398\uC774\uC9C0)
+`
+      );
+    }
+  } finally {
+    await pipeline.destroy().catch(() => {
+    });
+  }
+}
+function formatMb(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+// src/pdf/polyfill.ts
+import * as pdfjsWorker from "pdfjs-dist/legacy/build/pdf.worker.mjs";
+var g = globalThis;
+if (typeof g.DOMMatrix === "undefined") {
+  g.DOMMatrix = class DOMMatrix {
+    m = [1, 0, 0, 1, 0, 0];
+    constructor(init) {
+      if (init) this.m = init;
+    }
+  };
+}
+if (typeof g.Path2D === "undefined") {
+  g.Path2D = class Path2D {
+  };
+}
+g.pdfjsWorker = pdfjsWorker;
+
+// src/pdf/parser.ts
+import { getDocument, GlobalWorkerOptions } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+GlobalWorkerOptions.workerSrc = "";
+var MAX_PAGES = 5e3;
+var MAX_TOTAL_TEXT = 100 * 1024 * 1024;
+var PDF_LOAD_TIMEOUT_MS = 3e4;
+var pdfjsAssets = {};
+try {
+  const _require = createRequire(import.meta.url);
+  const pkgDir = dirname(_require.resolve("pdfjs-dist/package.json"));
+  pdfjsAssets.cMapUrl = join(pkgDir, "cmaps") + "/";
+  pdfjsAssets.cMapPacked = true;
+  pdfjsAssets.standardFontDataUrl = join(pkgDir, "standard_fonts") + "/";
+} catch {
+}
+async function loadPdfWithTimeout(buffer) {
+  const loadingTask = getDocument({
+    data: new Uint8Array(buffer),
+    useSystemFonts: true,
+    disableFontFace: true,
+    isEvalSupported: false,
+    ...pdfjsAssets
+  });
+  let timer;
+  try {
+    return await Promise.race([
+      loadingTask.promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          loadingTask.destroy();
+          reject(new KordocError("PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (30\uCD08 \uCD08\uACFC)"));
+        }, PDF_LOAD_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function parsePdfDocument(buffer, options) {
+  const formulaBuffer = options?.formulaOcr ? buffer.slice(0) : null;
+  const ocrBuffer = options?.ocr ? buffer.slice(0) : null;
+  const doc = await loadPdfWithTimeout(buffer);
+  try {
+    const pageCount = doc.numPages;
+    if (pageCount === 0) throw new KordocError("PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    const metadata = { pageCount };
+    await extractPdfMetadata(doc, metadata);
+    const blocks = [];
+    const warnings = [];
+    const pageQuality = [];
+    let totalChars = 0;
+    let totalTextBytes = 0;
+    const effectivePageCount = Math.min(pageCount, MAX_PAGES);
+    const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
+    const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
+    const fontSizeFreq = /* @__PURE__ */ new Map();
+    const pageHeights = /* @__PURE__ */ new Map();
+    const pagesWithLargeImage = /* @__PURE__ */ new Set();
+    const skippedImagePages = /* @__PURE__ */ new Map();
+    const imageState = createPdfImageState();
+    const extractedImages = [];
+    const pageImageBlocks = /* @__PURE__ */ new Map();
+    let parsedPages = 0;
+    for (let i = 1; i <= effectivePageCount; i++) {
+      if (pageFilter && !pageFilter.has(i)) continue;
+      try {
+        const page = await doc.getPage(i);
+        const tc = await page.getTextContent();
+        const viewport = page.getViewport({ scale: 1 });
+        pageHeights.set(i, viewport.height);
+        const rawItems = tc.items;
+        const items = normalizeItems(rawItems);
+        const { visible, hiddenCount } = filterHiddenText(items, viewport.width, viewport.height);
+        if (hiddenCount > 0) {
+          warnings.push({ page: i, message: `${hiddenCount}\uAC1C \uC228\uACA8\uC9C4 \uD14D\uC2A4\uD2B8 \uC694\uC18C \uD544\uD130\uB9C1\uB428`, code: "HIDDEN_TEXT_FILTERED" });
+        }
+        for (const item of visible) {
+          if (item.fontSize > 0) fontSizeFreq.set(item.fontSize, (fontSizeFreq.get(item.fontSize) || 0) + 1);
+        }
+        const opList = await page.getOperatorList();
+        const pageArea = viewport.width * viewport.height;
+        if (pageArea > 0) {
+          const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray);
+          let uncovered = 0;
+          for (const r of imageRegions) {
+            const area = (r.x2 - r.x1) * (r.y2 - r.y1);
+            if (area < pageArea * 0.05) continue;
+            pagesWithLargeImage.add(i);
+            const hasText = visible.some((it) => {
+              const cx = it.x + it.w / 2;
+              const cy = it.y + (it.h || it.fontSize) / 2;
+              return cx >= r.x1 && cx <= r.x2 && cy >= r.y1 && cy <= r.y2;
+            });
+            if (!hasText) uncovered++;
+          }
+          if (uncovered > 0) skippedImagePages.set(i, uncovered);
+        }
+        const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
+        for (const b of pageBlocks) blocks.push(b);
+        try {
+          const { blocks: imgBlocks, images: pageImages } = await extractPageImages(page, opList.fnArray, opList.argsArray, i, imageState, warnings);
+          if (imgBlocks.length > 0) pageImageBlocks.set(i, imgBlocks);
+          extractedImages.push(...pageImages);
+        } catch {
+        }
+        let pageText = "";
+        for (const b of pageBlocks) {
+          let t = b.text || "";
+          if (b.type === "table" && b.table) {
+            const cellText = b.table.cells.map((row) => row.map((c) => c.text).join(" ")).join("\n");
+            t = t ? t + "\n" + cellText : cellText;
+          }
+          totalChars += t.replace(/\s/g, "").length;
+          totalTextBytes += t.length * 2;
+          pageText += pageText ? "\n" + t : t;
+        }
+        pageQuality.push(computePageQuality(i, pageText));
+        if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
+        parsedPages++;
+        options?.onProgress?.(parsedPages, totalTarget);
+      } catch (pageErr) {
+        if (pageErr instanceof KordocError) throw pageErr;
+        warnings.push({ page: i, message: `\uD398\uC774\uC9C0 ${i} \uD30C\uC2F1 \uC2E4\uD328: ${pageErr instanceof Error ? pageErr.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`, code: "PARTIAL_PARSE" });
+      }
+    }
+    const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
+    const isImageBased = totalChars / Math.max(parsedPageCount, 1) < 10;
+    const ocrDone = /* @__PURE__ */ new Set();
+    if (options?.ocr && ocrBuffer) {
+      const inScope = (p) => !pageFilter || pageFilter.has(p);
+      const targets = /* @__PURE__ */ new Set();
+      if (options.ocr === "force" || isImageBased) {
+        for (let i = 1; i <= effectivePageCount; i++) if (inScope(i)) targets.add(i);
+      } else {
+        for (const pq of pageQuality) {
+          if (!pq.needsOcr) continue;
+          if (pq.ocrReason === "low_text" && !pagesWithLargeImage.has(pq.page)) continue;
+          targets.add(pq.page);
+        }
+      }
+      if (targets.size > 0) {
+        try {
+          const { runPdfOcr } = await import("./pdf-ocr-VYE4DHD4.js");
+          const mode = typeof options.ocr === "function" ? options.ocr : "builtin";
+          const ocrPageBlocks = await runPdfOcr(ocrBuffer, targets, mode, warnings, options.onProgress);
+          if (ocrPageBlocks.size > 0) {
+            for (const p of ocrPageBlocks.keys()) ocrDone.add(p);
+            const merged = blocks.filter((b) => !(b.pageNumber && ocrDone.has(b.pageNumber)));
+            for (const obs of ocrPageBlocks.values()) merged.push(...obs);
+            merged.sort((a, b) => (a.pageNumber ?? 0) - (b.pageNumber ?? 0));
+            blocks.length = 0;
+            blocks.push(...merged);
+            for (const pq of pageQuality) if (ocrDone.has(pq.page)) pq.ocrApplied = true;
+            warnings.push({
+              message: `${ocrDone.size}\uAC1C \uD398\uC774\uC9C0\uC5D0 OCR \uC801\uC6A9 (${mode === "builtin" ? "\uB0B4\uC7A5 PP-OCRv5" : "\uC0AC\uC6A9\uC790 \uD504\uB85C\uBC14\uC774\uB354"})`,
+              code: "OCR_APPLIED"
+            });
+          }
+        } catch (e) {
+          warnings.push({
+            message: `OCR \uC2E4\uD589 \uBD88\uAC00: ${e instanceof Error ? e.message : String(e)}`,
+            code: "OCR_FAILED"
+          });
+        }
+      }
+    }
+    if (isImageBased && ocrDone.size === 0) {
+      warnings.push({
+        message: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, \uD14D\uC2A4\uD2B8 ${totalChars}\uC790) \u2014 \uD14D\uC2A4\uD2B8 \uB808\uC774\uC5B4\uAC00 \uC5C6\uC5B4 OCR\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+        code: "NEEDS_OCR"
+      });
+    }
+    if (!isImageBased) {
+      const OCR_REASON_MESSAGES = {
+        low_text: "\uD14D\uC2A4\uD2B8\uAC00 \uAC70\uC758 \uC5C6\uB294 \uD398\uC774\uC9C0 (\uC2A4\uCE94/\uC774\uBBF8\uC9C0 \uCD94\uC815)",
+        high_pua: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (PUA \uBE44\uC728 \uB192\uC74C) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_control: "\uC81C\uC5B4\uBB38\uC790 \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        high_replacement: "\uB300\uCCB4\uBB38\uC790(U+FFFD) \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
+        garbled_hangul: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (\uD55C\uAE00 \uC790\uC18C \uBD84\uD3EC \uC774\uC0C1) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8\uAC00 \uAE68\uC84C\uC744 \uC218 \uC788\uC74C"
+      };
+      for (const pq of pageQuality) {
+        if (!pq.needsOcr || !pq.ocrReason || pq.ocrApplied) continue;
+        if (pq.ocrReason === "low_text" && !pagesWithLargeImage.has(pq.page)) continue;
+        warnings.push({ page: pq.page, message: `${OCR_REASON_MESSAGES[pq.ocrReason]} \u2014 OCR \uAC80\uD1A0 \uD544\uC694`, code: "NEEDS_OCR" });
+      }
+    }
+    if (!isImageBased) {
+      for (const [page, count] of [...skippedImagePages.entries()].sort((a, b) => a[0] - b[0])) {
+        warnings.push({ page, message: `${count}\uAC1C \uC774\uBBF8\uC9C0 \uC601\uC5ED\uC5D0 \uCD94\uCD9C \uAC00\uB2A5\uD55C \uD14D\uC2A4\uD2B8 \uC5C6\uC74C (\uADF8\uB9BC/\uCC28\uD2B8/\uB3C4\uC7A5 \uB0B4\uC6A9 \uB204\uB77D \uAC00\uB2A5)`, code: "SKIPPED_IMAGE" });
+      }
+    }
+    if (options?.removeHeaderFooter !== false && parsedPageCount >= 3) {
+      const removed = removeHeaderFooterBlocks(blocks, pageHeights, warnings);
+      for (let ri = removed.length - 1; ri >= 0; ri--) {
+        blocks.splice(removed[ri], 1);
+      }
+    }
+    mergeCrossPageTables(blocks);
+    injectPageImageBlocks(blocks, pageImageBlocks);
+    if (options?.formulaOcr && formulaBuffer) {
+      try {
+        await applyFormulaOcr(formulaBuffer, blocks, pageFilter, effectivePageCount, warnings, options.onProgress);
+      } catch (e) {
+        warnings.push({
+          message: `\uC218\uC2DD OCR \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`,
+          code: "PARTIAL_PARSE"
+        });
+      }
+    }
+    const medianFontSize = computeMedianFontSizeFromFreq(fontSizeFreq);
+    if (medianFontSize > 0) {
+      detectHeadings(blocks, medianFontSize);
+    }
+    detectMarkerHeadings(blocks);
+    detectTableCaptions(blocks);
+    detectKoreanListBlocks(blocks);
+    const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
+    sanitizeBlockControlChars(blocks);
+    let markdown = cleanPdfText(blocksToMarkdown(blocks));
+    return {
+      markdown,
+      blocks,
+      metadata,
+      outline: outline.length > 0 ? outline : void 0,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      isImageBased: isImageBased || void 0,
+      pageQuality,
+      qualitySummary: summarizeDocumentQuality(pageQuality),
+      images: extractedImages.length > 0 ? extractedImages : void 0
+    };
+  } finally {
+    await doc.destroy().catch(() => {
+    });
+  }
+}
+async function extractPdfMetadata(doc, metadata) {
+  try {
+    const result = await doc.getMetadata();
+    if (!result?.info) return;
+    const info = result.info;
+    if (typeof info.Title === "string" && info.Title.trim()) metadata.title = info.Title.trim();
+    if (typeof info.Author === "string" && info.Author.trim()) metadata.author = info.Author.trim();
+    if (typeof info.Creator === "string" && info.Creator.trim()) metadata.creator = info.Creator.trim();
+    if (typeof info.Subject === "string" && info.Subject.trim()) metadata.description = info.Subject.trim();
+    if (typeof info.Keywords === "string" && info.Keywords.trim()) {
+      metadata.keywords = info.Keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean);
+    }
+    if (typeof info.CreationDate === "string") metadata.createdAt = parsePdfDate(info.CreationDate);
+    if (typeof info.ModDate === "string") metadata.modifiedAt = parsePdfDate(info.ModDate);
+  } catch {
+  }
+}
+function parsePdfDate(dateStr) {
+  const m = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
+  if (!m) return void 0;
+  const [, year, month = "01", day = "01", hour = "00", min = "00", sec = "00"] = m;
+  return `${year}-${month}-${day}T${hour}:${min}:${sec}`;
+}
+async function extractPdfMetadataOnly(buffer) {
+  const doc = await loadPdfWithTimeout(buffer);
+  try {
+    const metadata = { pageCount: doc.numPages };
+    await extractPdfMetadata(doc, metadata);
+    return metadata;
+  } finally {
+    await doc.destroy().catch(() => {
+    });
+  }
+}
+export {
+  cleanPdfText,
+  detectKoreanListBlocks,
+  detectTableCaptions,
+  extractPdfMetadataOnly,
+  mergeCrossPageTables,
+  parsePdfDocument,
+  removeHeaderFooterBlocks
+};
+//# sourceMappingURL=parser-RBZHA6SY.js.map