kordoc 1.1.2 → 1.3.0

package/dist/{chunk-LHETZ3IN.js → chunk-KCGDEP7Q.js}

@@ -25,7 +25,7 @@ function detectFormat(buffer) {
 }
 
 // src/utils.ts
-var VERSION = true ? "1.1.2" : "0.0.0-dev";
+var VERSION = true ? "1.3.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -739,143 +739,316 @@ function arrangeCells(rows, cols, cells) {
   return grid.map((row) => row.map((c) => c || { text: "", colSpan: 1, rowSpan: 1 }));
 }
 
+// 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 { createRequire as createRequire2 } from "module";
-import { pathToFileURL } from "url";
+import { getDocument, GlobalWorkerOptions } from "pdfjs-dist/legacy/build/pdf.mjs";
+GlobalWorkerOptions.workerSrc = "";
 var MAX_PAGES = 5e3;
 var MAX_TOTAL_TEXT = 100 * 1024 * 1024;
-var pdfjsModule = null;
-async function loadPdfjs() {
-  if (pdfjsModule) return pdfjsModule;
-  try {
-    const mod = await import("pdfjs-dist/legacy/build/pdf.mjs");
-    const req = createRequire2(import.meta.url);
-    const workerPath = req.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
-    mod.GlobalWorkerOptions.workerSrc = pathToFileURL(workerPath).href;
-    pdfjsModule = mod;
-    return mod;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("Cannot find") || msg.includes("MODULE_NOT_FOUND")) {
-      return null;
-    }
-    throw new KordocError(`pdfjs-dist \uB85C\uB529 \uC2E4\uD328: ${msg}`);
-  }
-}
 async function parsePdfDocument(buffer) {
-  const pdfjs = await loadPdfjs();
-  if (!pdfjs) {
-    return {
-      success: false,
-      fileType: "pdf",
-      pageCount: 0,
-      error: "pdfjs-dist\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. npm install pdfjs-dist"
-    };
-  }
-  const data = new Uint8Array(buffer);
-  const doc = await pdfjs.getDocument({
-    data,
+  const doc = await getDocument({
+    data: new Uint8Array(buffer),
     useSystemFonts: true,
     disableFontFace: true,
     isEvalSupported: false
   }).promise;
   try {
     const pageCount = doc.numPages;
-    if (pageCount === 0) {
-      return { success: false, fileType: "pdf", pageCount: 0, error: "PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." };
-    }
+    if (pageCount === 0) return { success: false, fileType: "pdf", pageCount: 0, error: "PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." };
     const pageTexts = [];
     let totalChars = 0;
     let totalTextBytes = 0;
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
     for (let i = 1; i <= effectivePageCount; i++) {
       const page = await doc.getPage(i);
-      const textContent = await page.getTextContent();
-      const lines = groupTextItemsByLine(textContent.items);
-      const pageText = lines.join("\n");
+      const tc = await page.getTextContent();
+      const pageText = extractPageContent(tc.items);
       totalChars += pageText.replace(/\s/g, "").length;
       totalTextBytes += pageText.length * 2;
-      if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError(`\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC (${MAX_TOTAL_TEXT / 1024 / 1024}MB \uC81C\uD55C)`);
+      if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
       pageTexts.push(pageText);
     }
-    const avgCharsPerPage = totalChars / effectivePageCount;
-    if (avgCharsPerPage < 10) {
-      return {
-        success: false,
-        fileType: "pdf",
-        pageCount,
-        isImageBased: true,
-        error: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF\uB85C \uCD94\uC815\uB429\uB2C8\uB2E4 (${pageCount}\uD398\uC774\uC9C0, \uCD94\uCD9C \uD14D\uC2A4\uD2B8 ${totalChars}\uC790).`
-      };
-    }
-    let markdown = "";
-    for (let i = 0; i < pageTexts.length; i++) {
-      const cleaned = cleanPdfText(pageTexts[i]);
-      if (cleaned.trim()) {
-        if (i > 0 && markdown) markdown += "\n\n";
-        markdown += cleaned;
-      }
+    if (totalChars / effectivePageCount < 10) {
+      return { success: false, fileType: "pdf", pageCount, isImageBased: true, error: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)` };
     }
-    markdown = reconstructTables(markdown);
-    const truncated = pageCount > MAX_PAGES;
-    return { success: true, fileType: "pdf", markdown, pageCount: effectivePageCount, isImageBased: false, ...truncated && { warning: `PDF\uAC00 ${pageCount}\uD398\uC774\uC9C0\uC774\uC9C0\uB9CC ${MAX_PAGES}\uD398\uC774\uC9C0\uAE4C\uC9C0\uB9CC \uCC98\uB9AC\uD588\uC2B5\uB2C8\uB2E4` } };
+    let markdown = pageTexts.filter((t) => t.trim()).join("\n\n");
+    markdown = cleanPdfText(markdown);
+    return { success: true, fileType: "pdf", markdown, pageCount: effectivePageCount };
   } finally {
     await doc.destroy().catch(() => {
     });
   }
 }
-function groupTextItemsByLine(items) {
+function extractPageContent(rawItems) {
+  const items = normalizeItems(rawItems);
+  if (items.length === 0) return "";
+  const yLines = groupByY(items);
+  const columns = detectColumns(yLines);
+  if (columns && columns.length >= 3) {
+    return extractWithColumns(yLines, columns);
+  }
+  return yLines.map((line) => mergeLineSimple(line)).join("\n");
+}
+function normalizeItems(rawItems) {
+  return rawItems.filter((i) => typeof i.str === "string" && i.str.trim() !== "").map((i) => ({
+    text: i.str.trim(),
+    x: Math.round(i.transform[4]),
+    y: Math.round(i.transform[5]),
+    w: Math.round(i.width),
+    h: Math.round(i.height)
+  })).sort((a, b) => b.y - a.y || a.x - b.x);
+}
+function groupByY(items) {
   if (items.length === 0) return [];
-  const textItems = items.filter((item) => typeof item.str === "string" && item.str.trim() !== "");
-  if (textItems.length === 0) return [];
-  textItems.sort((a, b) => {
-    const yDiff = b.transform[5] - a.transform[5];
-    if (Math.abs(yDiff) < 2) return a.transform[4] - b.transform[4];
-    return yDiff;
-  });
   const lines = [];
-  let currentY = textItems[0].transform[5];
-  let currentLine = [];
-  for (const item of textItems) {
-    const y = item.transform[5];
-    if (Math.abs(currentY - y) > Math.max(item.height * 0.5, 2)) {
-      if (currentLine.length > 0) lines.push(mergeLineItems(currentLine));
-      currentLine = [];
-      currentY = y;
-    }
-    currentLine.push({ text: item.str, x: item.transform[4], width: item.width });
-  }
-  if (currentLine.length > 0) lines.push(mergeLineItems(currentLine));
+  let curY = items[0].y;
+  let curLine = [items[0]];
+  for (let i = 1; i < items.length; i++) {
+    if (Math.abs(items[i].y - curY) > 3) {
+      lines.push(curLine);
+      curLine = [];
+      curY = items[i].y;
+    }
+    curLine.push(items[i]);
+  }
+  if (curLine.length > 0) lines.push(curLine);
   return lines;
 }
-function mergeLineItems(items) {
+function isProseSpread(items) {
+  if (items.length < 4) return false;
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  const gaps = [];
+  for (let i = 1; i < sorted.length; i++) {
+    gaps.push(sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w));
+  }
+  const maxGap = Math.max(...gaps);
+  const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
+  return maxGap < 40 && avgLen < 5;
+}
+function detectColumns(yLines) {
+  const allItems = yLines.flat();
+  if (allItems.length === 0) return null;
+  const pageWidth = Math.max(...allItems.map((i) => i.x + i.w)) - Math.min(...allItems.map((i) => i.x));
+  if (pageWidth < 100) return null;
+  let bigoLineIdx = -1;
+  for (let i = 0; i < yLines.length; i++) {
+    if (yLines[i].length <= 2 && yLines[i].some((item) => item.text === "\uBE44\uACE0")) {
+      bigoLineIdx = i;
+      break;
+    }
+  }
+  const tableYLines = bigoLineIdx >= 0 ? yLines.slice(0, bigoLineIdx) : yLines;
+  const CLUSTER_TOL = 22;
+  const xClusters = [];
+  for (const line of tableYLines) {
+    if (isProseSpread(line)) continue;
+    for (const item of line) {
+      let found = false;
+      for (const c of xClusters) {
+        if (Math.abs(item.x - c.center) <= CLUSTER_TOL) {
+          c.center = Math.round((c.center * c.count + item.x) / (c.count + 1));
+          c.minX = Math.min(c.minX, item.x);
+          c.count++;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        xClusters.push({ center: item.x, count: 1, minX: item.x });
+      }
+    }
+  }
+  const peaks = xClusters.filter((c) => c.count >= 3).sort((a, b) => a.minX - b.minX);
+  if (peaks.length < 3) return null;
+  const MERGE_TOL = 30;
+  const merged = [peaks[0]];
+  for (let i = 1; i < peaks.length; i++) {
+    const prev = merged[merged.length - 1];
+    if (peaks[i].minX - prev.minX < MERGE_TOL) {
+      if (peaks[i].count > prev.count) {
+        prev.center = peaks[i].center;
+      }
+      prev.count += peaks[i].count;
+      prev.minX = Math.min(prev.minX, peaks[i].minX);
+    } else {
+      merged.push({ ...peaks[i] });
+    }
+  }
+  const columns = merged.filter((c) => c.count >= 3).map((c) => c.minX);
+  return columns.length >= 3 ? columns : null;
+}
+function findColumn(x, columns) {
+  for (let i = columns.length - 1; i >= 0; i--) {
+    if (x >= columns[i] - 10) return i;
+  }
+  return 0;
+}
+function extractWithColumns(yLines, columns) {
+  const result = [];
+  const colMin = columns[0];
+  const colMax = columns[columns.length - 1];
+  let bigoIdx = -1;
+  for (let i = 0; i < yLines.length; i++) {
+    if (yLines[i].length <= 2 && yLines[i].some((item) => item.text === "\uBE44\uACE0")) {
+      bigoIdx = i;
+      break;
+    }
+  }
+  let tableStart = -1;
+  for (let i = 0; i < (bigoIdx >= 0 ? bigoIdx : yLines.length); i++) {
+    const usedCols = new Set(yLines[i].map((item) => findColumn(item.x, columns)));
+    if (usedCols.size >= 3) {
+      tableStart = i;
+      break;
+    }
+  }
+  const tableEnd = bigoIdx >= 0 ? bigoIdx : yLines.length;
+  for (let i = 0; i < (tableStart >= 0 ? tableStart : tableEnd); i++) {
+    result.push(mergeLineSimple(yLines[i]));
+  }
+  if (tableStart >= 0) {
+    const tableLines = yLines.slice(tableStart, tableEnd);
+    const gridLines = [];
+    for (const line of tableLines) {
+      const inRange = line.some(
+        (item) => item.x >= colMin - 20 && item.x <= colMax + 200
+      );
+      if (inRange && !isProseSpread(line)) {
+        gridLines.push(line);
+      } else {
+        if (gridLines.length > 0) {
+          result.push(buildGridTable(gridLines.splice(0), columns));
+        }
+        result.push(mergeLineSimple(line));
+      }
+    }
+    if (gridLines.length > 0) {
+      result.push(buildGridTable(gridLines, columns));
+    }
+  }
+  if (bigoIdx >= 0) {
+    result.push("");
+    for (let i = bigoIdx; i < yLines.length; i++) {
+      result.push(mergeLineSimple(yLines[i]));
+    }
+  }
+  return result.join("\n");
+}
+function buildGridTable(lines, columns) {
+  const numCols = columns.length;
+  const yRows = lines.map((items) => {
+    const row = Array(numCols).fill("");
+    for (const item of items) {
+      const col = findColumn(item.x, columns);
+      row[col] = row[col] ? row[col] + " " + item.text : item.text;
+    }
+    return row;
+  });
+  const dataColStart = Math.max(2, Math.floor(numCols / 2));
+  const merged = [];
+  for (const row of yRows) {
+    if (row.every((c) => c === "")) continue;
+    if (merged.length === 0) {
+      merged.push([...row]);
+      continue;
+    }
+    const prev = merged[merged.length - 1];
+    const filledCols = row.map((c, i) => c ? i : -1).filter((i) => i >= 0);
+    const filledCount = filledCols.length;
+    let isNewRow = false;
+    if (row[0] && row[0].length >= 3) {
+      isNewRow = true;
+    }
+    if (!isNewRow && numCols > 1 && row[1]) {
+      isNewRow = true;
+    }
+    if (!isNewRow) {
+      const hasData = row.slice(dataColStart).some((c) => c !== "");
+      const prevHasData = prev.slice(dataColStart).some((c) => c !== "");
+      if (hasData && prevHasData) {
+        isNewRow = true;
+      }
+    }
+    if (isNewRow && filledCount === 1 && row[0] && row[0].length <= 2) {
+      isNewRow = false;
+    }
+    if (isNewRow) {
+      merged.push([...row]);
+    } else {
+      for (let c = 0; c < numCols; c++) {
+        if (row[c]) {
+          prev[c] = prev[c] ? prev[c] + " " + row[c] : row[c];
+        }
+      }
+    }
+  }
+  if (merged.length < 2) {
+    return merged.map((r) => r.filter((c) => c).join(" ")).join("\n");
+  }
+  let headerEnd = 0;
+  for (let r = 0; r < merged.length; r++) {
+    const hasDataValues = merged[r].slice(dataColStart).some((c) => c && /\d/.test(c));
+    if (hasDataValues) break;
+    headerEnd = r + 1;
+  }
+  if (headerEnd > 1) {
+    const headerRow = Array(numCols).fill("");
+    for (let r = 0; r < headerEnd; r++) {
+      for (let c = 0; c < numCols; c++) {
+        if (merged[r][c]) {
+          headerRow[c] = headerRow[c] ? headerRow[c] + " " + merged[r][c] : merged[r][c];
+        }
+      }
+    }
+    merged.splice(0, headerEnd, headerRow);
+  }
+  const md = [];
+  md.push("| " + merged[0].join(" | ") + " |");
+  md.push("| " + merged[0].map(() => "---").join(" | ") + " |");
+  for (let r = 1; r < merged.length; r++) {
+    md.push("| " + merged[r].join(" | ") + " |");
+  }
+  return md.join("\n");
+}
+function mergeLineSimple(items) {
   if (items.length <= 1) return items[0]?.text || "";
-  items.sort((a, b) => a.x - b.x);
-  let result = items[0].text;
-  for (let i = 1; i < items.length; i++) {
-    const gap = items[i].x - (items[i - 1].x + items[i - 1].width);
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  let result = sorted[0].text;
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
     if (gap > 15) result += "	";
     else if (gap > 3) result += " ";
-    result += items[i].text;
+    result += sorted[i].text;
   }
   return result;
 }
 function cleanPdfText(text) {
-  const stripped = text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "");
-  return mergeKoreanLines(stripped).replace(/\n{3,}/g, "\n\n").trim();
+  return mergeKoreanLines(
+    text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "")
+  ).replace(/\n{3,}/g, "\n\n").trim();
 }
 function startsWithMarker(line) {
   const t = line.trimStart();
-  if (/^[가-힣ㄱ-ㅎ][.)]/.test(t)) return true;
-  if (/^\d+[.)]/.test(t)) return true;
-  if (/^\([가-힣ㄱ-ㅎ\d]+\)/.test(t)) return true;
-  if (/^[○●※▶▷◆◇■□★☆\-·]\s/.test(t)) return true;
-  if (/^제\d+[조항호장절]/.test(t)) return true;
-  return false;
+  return /^[가-힣ㄱ-ㅎ][.)]/.test(t) || /^\d+[.)]/.test(t) || /^\([가-힣ㄱ-ㅎ\d]+\)/.test(t) || /^[○●※▶▷◆◇■□★☆\-·]\s/.test(t) || /^제\d+[조항호장절]/.test(t);
 }
 function isStandaloneHeader(line) {
-  const t = line.trim();
-  return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(t);
+  return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(line.trim());
 }
 function mergeKoreanLines(text) {
   if (!text) return "";
@@ -885,8 +1058,7 @@ function mergeKoreanLines(text) {
   for (let i = 1; i < lines.length; i++) {
     const prev = result[result.length - 1];
     const curr = lines[i];
-    const shouldMerge = /[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev);
-    if (shouldMerge) {
+    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev)) {
       result[result.length - 1] = prev + " " + curr;
     } else {
       result.push(curr);
@@ -894,39 +1066,6 @@ function mergeKoreanLines(text) {
   }
   return result.join("\n");
 }
-function reconstructTables(text) {
-  const lines = text.split("\n");
-  const result = [];
-  let tableBuffer = [];
-  for (const line of lines) {
-    if (line.includes("	")) {
-      tableBuffer.push(line.split("	").map((c) => c.trim()));
-    } else {
-      if (tableBuffer.length >= 2) result.push(formatAsMarkdownTable(tableBuffer));
-      else if (tableBuffer.length === 1) result.push(tableBuffer[0].join(" | "));
-      tableBuffer = [];
-      result.push(line);
-    }
-  }
-  if (tableBuffer.length >= 2) result.push(formatAsMarkdownTable(tableBuffer));
-  else if (tableBuffer.length === 1) result.push(tableBuffer[0].join(" | "));
-  return result.join("\n");
-}
-function formatAsMarkdownTable(rows) {
-  const maxCols = Math.max(...rows.map((r) => r.length));
-  const normalized = rows.map((r) => {
-    const copy = [...r];
-    while (copy.length < maxCols) copy.push("");
-    return copy;
-  });
-  const lines = [];
-  lines.push("| " + normalized[0].join(" | ") + " |");
-  lines.push("| " + normalized[0].map(() => "---").join(" | ") + " |");
-  for (let i = 1; i < normalized.length; i++) {
-    lines.push("| " + normalized[i].join(" | ") + " |");
-  }
-  return lines.join("\n");
-}
 
 // src/index.ts
 async function parse(buffer) {
@@ -977,4 +1116,4 @@ export {
   sanitizeError,
   parse
 };
-//# sourceMappingURL=chunk-LHETZ3IN.js.map
+//# sourceMappingURL=chunk-KCGDEP7Q.js.map