kordoc 0.1.0

package/dist/chunk-P2BZDRLZ.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/detect.ts
+function isHwpxFile(buffer) {
+  const bytes = new Uint8Array(buffer.slice(0, 4));
+  return bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+}
+function isOldHwpFile(buffer) {
+  const bytes = new Uint8Array(buffer.slice(0, 4));
+  return bytes[0] === 208 && bytes[1] === 207 && bytes[2] === 17 && bytes[3] === 224;
+}
+function isPdfFile(buffer) {
+  const bytes = new Uint8Array(buffer.slice(0, 4));
+  return bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70;
+}
+function detectFormat(buffer) {
+  if (isHwpxFile(buffer)) return "hwpx";
+  if (isOldHwpFile(buffer)) return "hwp";
+  if (isPdfFile(buffer)) return "pdf";
+  return "unknown";
+}
+
+// src/hwpx/parser.ts
+import JSZip from "jszip";
+import { DOMParser } from "@xmldom/xmldom";
+
+// src/table/builder.ts
+function buildTable(rows) {
+  const numRows = rows.length;
+  const tempOccupied = Array.from({ length: numRows }, () => Array(100).fill(false));
+  let maxCols = 0;
+  for (let rowIdx = 0; rowIdx < numRows; rowIdx++) {
+    let colIdx = 0;
+    for (const cell of rows[rowIdx]) {
+      while (colIdx < 100 && tempOccupied[rowIdx][colIdx]) colIdx++;
+      if (colIdx >= 100) break;
+      for (let r = rowIdx; r < Math.min(rowIdx + cell.rowSpan, numRows); r++) {
+        for (let c = colIdx; c < Math.min(colIdx + cell.colSpan, 100); c++) {
+          tempOccupied[r][c] = true;
+        }
+      }
+      colIdx += cell.colSpan;
+      if (colIdx > maxCols) maxCols = colIdx;
+    }
+  }
+  if (maxCols === 0) return { rows: 0, cols: 0, cells: [], hasHeader: false };
+  const grid = Array.from(
+    { length: numRows },
+    () => Array.from({ length: maxCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
+  );
+  const occupied = Array.from({ length: numRows }, () => Array(maxCols).fill(false));
+  for (let rowIdx = 0; rowIdx < numRows; rowIdx++) {
+    let colIdx = 0;
+    let cellIdx = 0;
+    while (colIdx < maxCols && cellIdx < rows[rowIdx].length) {
+      while (colIdx < maxCols && occupied[rowIdx][colIdx]) colIdx++;
+      if (colIdx >= maxCols) break;
+      const cell = rows[rowIdx][cellIdx];
+      grid[rowIdx][colIdx] = {
+        text: cell.text.trim(),
+        colSpan: cell.colSpan,
+        rowSpan: cell.rowSpan
+      };
+      for (let r = rowIdx; r < Math.min(rowIdx + cell.rowSpan, numRows); r++) {
+        for (let c = colIdx; c < Math.min(colIdx + cell.colSpan, maxCols); c++) {
+          occupied[r][c] = true;
+        }
+      }
+      colIdx += cell.colSpan;
+      cellIdx++;
+    }
+  }
+  return { rows: numRows, cols: maxCols, cells: grid, hasHeader: numRows > 1 };
+}
+function convertTableToText(rows) {
+  return rows.map(
+    (row) => row.map((c) => c.text.trim().replace(/\n/g, " ")).filter(Boolean).join(" | ")
+  ).filter(Boolean).join("\n");
+}
+function blocksToMarkdown(blocks) {
+  const lines = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type === "paragraph" && block.text) {
+      const text = block.text;
+      if (/^\[별표\s*\d+/.test(text)) {
+        const nextBlock = blocks[i + 1];
+        if (nextBlock?.type === "paragraph" && nextBlock.text && /관련\)?$/.test(nextBlock.text)) {
+          lines.push("", `## ${text} ${nextBlock.text}`, "");
+          i++;
+        } else {
+          lines.push("", `## ${text}`, "");
+        }
+        continue;
+      }
+      if (/^\([^)]*조[^)]*관련\)$/.test(text)) {
+        lines.push(`*${text}*`, "");
+        continue;
+      }
+      lines.push(text);
+    } else if (block.type === "table" && block.table) {
+      lines.push(tableToMarkdown(block.table));
+    }
+  }
+  return lines.join("\n").trim();
+}
+function tableToMarkdown(table) {
+  if (table.rows === 0 || table.cols === 0) return "";
+  const { cells, rows: numRows, cols: numCols } = table;
+  if (numRows === 1 && numCols === 1) {
+    const content = cells[0][0].text;
+    return content.split(/\n/).map((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return "";
+      if (/^\d+\.\s/.test(trimmed)) return `**${trimmed}**`;
+      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${trimmed}`;
+      return trimmed;
+    }).filter(Boolean).join("\n");
+  }
+  const display = Array.from({ length: numRows }, () => Array(numCols).fill(""));
+  const skip = /* @__PURE__ */ new Set();
+  for (let r = 0; r < numRows; r++) {
+    for (let c = 0; c < numCols; c++) {
+      if (skip.has(`${r},${c}`)) continue;
+      const cell = cells[r][c];
+      display[r][c] = cell.text.replace(/\n/g, "<br>");
+      for (let dr = 0; dr < cell.rowSpan; dr++) {
+        for (let dc = 0; dc < cell.colSpan; dc++) {
+          if (dr === 0 && dc === 0) continue;
+          if (r + dr < numRows && c + dc < numCols) {
+            skip.add(`${r + dr},${c + dc}`);
+          }
+        }
+      }
+    }
+  }
+  const uniqueRows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of display) {
+    const key = row.join("||");
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueRows.push(row);
+    }
+  }
+  if (uniqueRows.length === 0) return "";
+  const md = [];
+  md.push("| " + uniqueRows[0].join(" | ") + " |");
+  md.push("| " + uniqueRows[0].map(() => "---").join(" | ") + " |");
+  for (let i = 1; i < uniqueRows.length; i++) {
+    md.push("| " + uniqueRows[i].join(" | ") + " |");
+  }
+  return md.join("\n");
+}
+
+// src/hwpx/parser.ts
+async function parseHwpxDocument(buffer) {
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(buffer);
+  } catch {
+    return extractFromBrokenZip(buffer);
+  }
+  const sectionPaths = await resolveSectionPaths(zip);
+  if (sectionPaths.length === 0) throw new Error("HWPX\uC5D0\uC11C \uC139\uC158 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  const blocks = [];
+  for (const path of sectionPaths) {
+    const file = zip.file(path);
+    if (!file) continue;
+    const xml = await file.async("text");
+    blocks.push(...parseSectionXml(xml));
+  }
+  return blocksToMarkdown(blocks);
+}
+function extractFromBrokenZip(buffer) {
+  const data = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  let pos = 0;
+  const texts = [];
+  while (pos < data.length - 30) {
+    if (data[pos] !== 80 || data[pos + 1] !== 75 || data[pos + 2] !== 3 || data[pos + 3] !== 4) break;
+    const method = view.getUint16(pos + 8, true);
+    const compSize = view.getUint32(pos + 18, true);
+    const nameLen = view.getUint16(pos + 26, true);
+    const extraLen = view.getUint16(pos + 28, true);
+    const nameBytes = data.slice(pos + 30, pos + 30 + nameLen);
+    const name = new TextDecoder().decode(nameBytes);
+    const fileStart = pos + 30 + nameLen + extraLen;
+    const fileData = data.slice(fileStart, fileStart + compSize);
+    pos = fileStart + compSize;
+    if (!name.toLowerCase().includes("section") || !name.endsWith(".xml")) continue;
+    try {
+      let content;
+      if (method === 0) {
+        content = new TextDecoder().decode(fileData);
+      } else if (method === 8) {
+        const { inflateRawSync: inflateRawSync2 } = __require("zlib");
+        content = new TextDecoder().decode(inflateRawSync2(Buffer.from(fileData)));
+      } else {
+        continue;
+      }
+      const sectionText = blocksToMarkdown(parseSectionXml(content));
+      if (sectionText) texts.push(sectionText);
+    } catch {
+      continue;
+    }
+  }
+  if (texts.length === 0) throw new Error("\uC190\uC0C1\uB41C HWPX\uC5D0\uC11C \uC139\uC158 \uB370\uC774\uD130\uB97C \uBCF5\uAD6C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  return texts.join("\n\n");
+}
+async function resolveSectionPaths(zip) {
+  const manifestPaths = ["Contents/content.hpf", "content.hpf"];
+  for (const mp of manifestPaths) {
+    const file = zip.file(new RegExp(`^${mp.replace(/\./g, "\\.")}$`, "i"))[0];
+    if (!file) continue;
+    const xml = await file.async("text");
+    const paths = parseSectionPathsFromManifest(xml);
+    if (paths.length > 0) return paths;
+  }
+  const sectionFiles = zip.file(/[Ss]ection\d+\.xml$/);
+  return sectionFiles.map((f) => f.name).sort();
+}
+function parseSectionPathsFromManifest(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, "text/xml");
+  const items = doc.getElementsByTagName("opf:item");
+  const spine = doc.getElementsByTagName("opf:itemref");
+  const isSectionId = (id) => /^s/i.test(id) || id.toLowerCase().includes("section");
+  const idToHref = /* @__PURE__ */ new Map();
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const id = item.getAttribute("id") || "";
+    let href = item.getAttribute("href") || "";
+    const mediaType = item.getAttribute("media-type") || "";
+    if (!isSectionId(id) && !mediaType.includes("xml")) continue;
+    if (!href.startsWith("/") && !href.startsWith("Contents/") && isSectionId(id))
+      href = "Contents/" + href;
+    idToHref.set(id, href);
+  }
+  if (spine.length > 0) {
+    const ordered = [];
+    for (let i = 0; i < spine.length; i++) {
+      const href = idToHref.get(spine[i].getAttribute("idref") || "");
+      if (href) ordered.push(href);
+    }
+    if (ordered.length > 0) return ordered;
+  }
+  return Array.from(idToHref.entries()).filter(([id]) => isSectionId(id)).sort((a, b) => a[0].localeCompare(b[0])).map(([, href]) => href);
+}
+function parseSectionXml(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, "text/xml");
+  if (!doc.documentElement) return [];
+  const blocks = [];
+  walkSection(doc.documentElement, blocks, null, []);
+  return blocks;
+}
+function walkSection(node, blocks, tableCtx, tableStack) {
+  const children = node.childNodes;
+  if (!children) return;
+  for (let i = 0; i < children.length; i++) {
+    const el = children[i];
+    if (el.nodeType !== 1) continue;
+    const tag = el.tagName || el.localName || "";
+    const localTag = tag.replace(/^[^:]+:/, "");
+    switch (localTag) {
+      case "tbl": {
+        if (tableCtx) tableStack.push(tableCtx);
+        const newTable = { rows: [], currentRow: [], cell: null };
+        walkSection(el, blocks, newTable, tableStack);
+        if (newTable.rows.length > 0) {
+          if (tableStack.length > 0) {
+            const parentTable = tableStack.pop();
+            const nestedText = convertTableToText(newTable.rows);
+            if (parentTable.cell) {
+              parentTable.cell.text += (parentTable.cell.text ? "\n" : "") + nestedText;
+            }
+            tableCtx = parentTable;
+          } else {
+            blocks.push({ type: "table", table: buildTable(newTable.rows) });
+            tableCtx = null;
+          }
+        } else {
+          tableCtx = tableStack.length > 0 ? tableStack.pop() : null;
+        }
+        break;
+      }
+      case "tr":
+        if (tableCtx) {
+          tableCtx.currentRow = [];
+          walkSection(el, blocks, tableCtx, tableStack);
+          if (tableCtx.currentRow.length > 0) tableCtx.rows.push(tableCtx.currentRow);
+          tableCtx.currentRow = [];
+        }
+        break;
+      case "tc":
+        if (tableCtx) {
+          tableCtx.cell = { text: "", colSpan: 1, rowSpan: 1 };
+          walkSection(el, blocks, tableCtx, tableStack);
+          if (tableCtx.cell) {
+            tableCtx.currentRow.push(tableCtx.cell);
+            tableCtx.cell = null;
+          }
+        }
+        break;
+      case "cellSpan":
+        if (tableCtx?.cell) {
+          const cs = parseInt(el.getAttribute("colSpan") || "1", 10);
+          const rs = parseInt(el.getAttribute("rowSpan") || "1", 10);
+          if (cs > 0) tableCtx.cell.colSpan = cs;
+          if (rs > 0) tableCtx.cell.rowSpan = rs;
+        }
+        break;
+      case "p": {
+        const text = extractParagraphText(el);
+        if (text) {
+          if (tableCtx?.cell) {
+            tableCtx.cell.text += (tableCtx.cell.text ? "\n" : "") + text;
+          } else if (!tableCtx) {
+            blocks.push({ type: "paragraph", text });
+          }
+        }
+        walkSection(el, blocks, tableCtx, tableStack);
+        break;
+      }
+      default:
+        walkSection(el, blocks, tableCtx, tableStack);
+        break;
+    }
+  }
+}
+function extractParagraphText(para) {
+  let text = "";
+  const walk = (node) => {
+    const children = node.childNodes;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType === 3) {
+        text += child.textContent || "";
+        continue;
+      }
+      if (child.nodeType !== 1) continue;
+      const tag = (child.tagName || child.localName || "").replace(/^[^:]+:/, "");
+      switch (tag) {
+        case "t":
+          text += child.textContent || "";
+          break;
+        case "tab":
+          text += "	";
+          break;
+        case "br":
+          if ((child.getAttribute("type") || "line") === "line") text += "\n";
+          break;
+        case "fwSpace":
+        case "hwSpace":
+          text += " ";
+          break;
+        case "tbl":
+          break;
+        // 테이블은 walkSection에서 처리
+        default:
+          walk(child);
+          break;
+      }
+    }
+  };
+  walk(para);
+  return text.replace(/[ \t]+/g, " ").trim();
+}
+
+// src/hwp5/record.ts
+import { inflateRawSync, inflateSync } from "zlib";
+var TAG_PARA_HEADER = 66;
+var TAG_PARA_TEXT = 67;
+var TAG_CTRL_HEADER = 71;
+var TAG_LIST_HEADER = 72;
+var TAG_TABLE = 77;
+var CHAR_LINE = 0;
+var CHAR_PARA = 13;
+var CHAR_TAB = 9;
+var CHAR_HYPHEN = 30;
+var CHAR_NBSP = 31;
+var CHAR_FIXED_NBSP = 24;
+var FLAG_COMPRESSED = 1 << 0;
+var FLAG_ENCRYPTED = 1 << 1;
+var FLAG_DRM = 1 << 4;
+function readRecords(data) {
+  const records = [];
+  let offset = 0;
+  while (offset + 4 <= data.length) {
+    const header = data.readUInt32LE(offset);
+    offset += 4;
+    const tagId = header & 1023;
+    const level = header >> 10 & 1023;
+    let size = header >> 20 & 4095;
+    if (size === 4095) {
+      if (offset + 4 > data.length) break;
+      size = data.readUInt32LE(offset);
+      offset += 4;
+    }
+    if (offset + size > data.length) break;
+    records.push({ tagId, level, size, data: data.subarray(offset, offset + size) });
+    offset += size;
+  }
+  return records;
+}
+function decompressStream(data) {
+  if (data.length >= 2 && data[0] === 120) {
+    try {
+      return inflateSync(data);
+    } catch {
+    }
+  }
+  return inflateRawSync(data);
+}
+function parseFileHeader(data) {
+  const sig = data.subarray(0, 32).toString("utf8").replace(/\0+$/, "");
+  return {
+    signature: sig,
+    versionMajor: data[35],
+    flags: data.readUInt32LE(36)
+  };
+}
+function extractText(data) {
+  let result = "";
+  let i = 0;
+  while (i + 1 < data.length) {
+    const ch = data.readUInt16LE(i);
+    i += 2;
+    switch (ch) {
+      case CHAR_LINE:
+        result += "\n";
+        break;
+      case CHAR_PARA:
+        break;
+      case CHAR_TAB:
+        result += "	";
+        break;
+      case CHAR_HYPHEN:
+        result += "-";
+        break;
+      case CHAR_NBSP:
+      case CHAR_FIXED_NBSP:
+        result += " ";
+        break;
+      default:
+        if (ch >= 1 && ch <= 31) {
+          const isExt = ch >= 1 && ch <= 3 || ch >= 11 && ch <= 18 || ch >= 21 && ch <= 23;
+          const isInline = ch >= 4 && ch <= 9 || ch >= 19 && ch <= 20;
+          if ((isExt || isInline) && i + 14 <= data.length) i += 14;
+        } else if (ch >= 32) {
+          result += String.fromCharCode(ch);
+        }
+        break;
+    }
+  }
+  return result;
+}
+
+// src/hwp5/parser.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var CFB = require2("cfb");
+function parseHwp5Document(buffer) {
+  const cfb = CFB.parse(buffer);
+  const headerEntry = CFB.find(cfb, "/FileHeader");
+  if (!headerEntry?.content) throw new Error("FileHeader \uC2A4\uD2B8\uB9BC \uC5C6\uC74C");
+  const header = parseFileHeader(Buffer.from(headerEntry.content));
+  if (header.signature !== "HWP Document File") throw new Error("HWP \uC2DC\uADF8\uB2C8\uCC98 \uBD88\uC77C\uCE58");
+  if (header.flags & FLAG_ENCRYPTED) throw new Error("\uC554\uD638\uD654\uB41C HWP\uB294 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+  if (header.flags & FLAG_DRM) throw new Error("DRM \uBCF4\uD638\uB41C HWP\uB294 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+  const compressed = (header.flags & FLAG_COMPRESSED) !== 0;
+  const sections = findSections(cfb);
+  if (sections.length === 0) throw new Error("\uC139\uC158 \uC2A4\uD2B8\uB9BC\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  const blocks = [];
+  for (const sectionData of sections) {
+    const data = compressed ? decompressStream(Buffer.from(sectionData)) : Buffer.from(sectionData);
+    const records = readRecords(data);
+    blocks.push(...parseSection(records));
+  }
+  return blocksToMarkdown(blocks);
+}
+function findSections(cfb) {
+  const sections = [];
+  for (let i = 0; ; i++) {
+    const entry = CFB.find(cfb, `/BodyText/Section${i}`);
+    if (!entry?.content) break;
+    sections.push({ idx: i, content: Buffer.from(entry.content) });
+  }
+  if (sections.length === 0 && cfb.FileIndex) {
+    for (const entry of cfb.FileIndex) {
+      if (entry.name?.startsWith("Section") && entry.content) {
+        const idx = parseInt(entry.name.replace("Section", ""), 10) || 0;
+        sections.push({ idx, content: Buffer.from(entry.content) });
+      }
+    }
+  }
+  return sections.sort((a, b) => a.idx - b.idx).map((s) => s.content);
+}
+function parseSection(records) {
+  const blocks = [];
+  let i = 0;
+  while (i < records.length) {
+    const rec = records[i];
+    if (rec.tagId === TAG_PARA_HEADER && rec.level === 0) {
+      const { paragraph, tables, nextIdx } = parseParagraphWithTables(records, i);
+      if (paragraph) blocks.push({ type: "paragraph", text: paragraph });
+      for (const t of tables) blocks.push({ type: "table", table: t });
+      i = nextIdx;
+      continue;
+    }
+    if (rec.tagId === TAG_CTRL_HEADER && rec.level <= 1 && rec.data.length >= 4) {
+      const ctrlId = rec.data.subarray(0, 4).toString("ascii");
+      if (ctrlId === " lbt" || ctrlId === "tbl ") {
+        const { table, nextIdx } = parseTableBlock(records, i);
+        if (table) blocks.push({ type: "table", table });
+        i = nextIdx;
+        continue;
+      }
+    }
+    i++;
+  }
+  return blocks;
+}
+function parseParagraphWithTables(records, startIdx) {
+  const startLevel = records[startIdx].level;
+  let text = "";
+  const tables = [];
+  let i = startIdx + 1;
+  while (i < records.length) {
+    const rec = records[i];
+    if (rec.tagId === TAG_PARA_HEADER && rec.level <= startLevel) break;
+    if (rec.tagId === TAG_PARA_TEXT) {
+      text = extractText(rec.data);
+    }
+    if (rec.tagId === TAG_CTRL_HEADER && rec.data.length >= 4) {
+      const ctrlId = rec.data.subarray(0, 4).toString("ascii");
+      if (ctrlId === " lbt" || ctrlId === "tbl ") {
+        const { table, nextIdx } = parseTableBlock(records, i);
+        if (table) tables.push(table);
+        i = nextIdx;
+        continue;
+      }
+    }
+    i++;
+  }
+  const trimmed = text.trim();
+  return { paragraph: trimmed || null, tables, nextIdx: i };
+}
+function parseTableBlock(records, startIdx) {
+  const tableLevel = records[startIdx].level;
+  let i = startIdx + 1;
+  let rows = 0, cols = 0;
+  const cells = [];
+  while (i < records.length) {
+    const rec = records[i];
+    if (rec.tagId === TAG_PARA_HEADER && rec.level <= tableLevel) break;
+    if (rec.tagId === TAG_CTRL_HEADER && rec.level <= tableLevel) break;
+    if (rec.tagId === TAG_TABLE && rec.data.length >= 8) {
+      rows = rec.data.readUInt16LE(4);
+      cols = rec.data.readUInt16LE(6);
+    }
+    if (rec.tagId === TAG_LIST_HEADER) {
+      const { cell, nextIdx } = parseCellBlock(records, i, tableLevel);
+      if (cell) cells.push(cell);
+      i = nextIdx;
+      continue;
+    }
+    i++;
+  }
+  if (rows === 0 || cols === 0 || cells.length === 0) return { table: null, nextIdx: i };
+  const cellRows = arrangeCells(rows, cols, cells);
+  return { table: buildTable(cellRows), nextIdx: i };
+}
+function parseCellBlock(records, startIdx, tableLevel) {
+  const cellLevel = records[startIdx].level;
+  const texts = [];
+  let i = startIdx + 1;
+  while (i < records.length) {
+    const rec = records[i];
+    if (rec.tagId === TAG_LIST_HEADER && rec.level <= cellLevel) break;
+    if (rec.level <= tableLevel && (rec.tagId === TAG_PARA_HEADER || rec.tagId === TAG_CTRL_HEADER)) break;
+    if (rec.tagId === TAG_PARA_TEXT) {
+      const t = extractText(rec.data).trim();
+      if (t) texts.push(t);
+    }
+    i++;
+  }
+  return { cell: { text: texts.join("\n"), colSpan: 1, rowSpan: 1 }, nextIdx: i };
+}
+function arrangeCells(rows, cols, cells) {
+  const grid = Array.from({ length: rows }, () => Array(cols).fill(null));
+  let cellIdx = 0;
+  for (let r = 0; r < rows && cellIdx < cells.length; r++) {
+    for (let c = 0; c < cols && cellIdx < cells.length; c++) {
+      if (grid[r][c] !== null) continue;
+      const cell = cells[cellIdx++];
+      grid[r][c] = cell;
+      for (let dr = 0; dr < cell.rowSpan; dr++) {
+        for (let dc = 0; dc < cell.colSpan; dc++) {
+          if (dr === 0 && dc === 0) continue;
+          if (r + dr < rows && c + dc < cols)
+            grid[r + dr][c + dc] = { text: "", colSpan: 1, rowSpan: 1 };
+        }
+      }
+    }
+  }
+  return grid.map((row) => row.map((c) => c || { text: "", colSpan: 1, rowSpan: 1 }));
+}
+
+// src/pdf/parser.ts
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL } from "url";
+var pdfjsModule = null;
+async function loadPdfjs() {
+  if (pdfjsModule) return pdfjsModule;
+  try {
+    pdfjsModule = 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");
+    pdfjsModule.GlobalWorkerOptions.workerSrc = pathToFileURL(workerPath).href;
+    return pdfjsModule;
+  } catch {
+    return null;
+  }
+}
+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"
+    };
+  }
+  try {
+    const data = new Uint8Array(buffer);
+    const doc = await pdfjs.getDocument({
+      data,
+      useSystemFonts: true,
+      disableFontFace: true,
+      isEvalSupported: false,
+      workerSrc: ""
+    }).promise;
+    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." };
+    }
+    const pageTexts = [];
+    let totalChars = 0;
+    for (let i = 1; i <= pageCount; i++) {
+      const page = await doc.getPage(i);
+      const textContent = await page.getTextContent();
+      const lines = groupTextItemsByLine(textContent.items);
+      const pageText = lines.join("\n");
+      totalChars += pageText.replace(/\s/g, "").length;
+      pageTexts.push(pageText);
+    }
+    const avgCharsPerPage = totalChars / pageCount;
+    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;
+      }
+    }
+    markdown = reconstructTables(markdown);
+    return { success: true, fileType: "pdf", markdown, pageCount, isImageBased: false };
+  } catch (err) {
+    return {
+      success: false,
+      fileType: "pdf",
+      pageCount: 0,
+      error: err instanceof Error ? err.message : "PDF \uD30C\uC2F1 \uC2E4\uD328"
+    };
+  }
+}
+function groupTextItemsByLine(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));
+  return lines;
+}
+function mergeLineItems(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);
+    if (gap > 15) result += "	";
+    else if (gap > 3) result += " ";
+    result += items[i].text;
+  }
+  return result;
+}
+function cleanPdfText(text) {
+  return text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "").replace(/([가-힣·,\-])\n([가-힣(])/g, "$1 $2").replace(/\n{3,}/g, "\n\n").trim();
+}
+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) => {
+    while (r.length < maxCols) r.push("");
+    return r;
+  });
+  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) {
+  const format = detectFormat(buffer);
+  switch (format) {
+    case "hwpx":
+      return parseHwpx(buffer);
+    case "hwp":
+      return parseHwp(buffer);
+    case "pdf":
+      return parsePdf(buffer);
+    default:
+      return { success: false, fileType: "unknown", error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4." };
+  }
+}
+async function parseHwpx(buffer) {
+  try {
+    const markdown = await parseHwpxDocument(buffer);
+    return { success: true, fileType: "hwpx", markdown };
+  } catch (err) {
+    return { success: false, fileType: "hwpx", error: err instanceof Error ? err.message : "HWPX \uD30C\uC2F1 \uC2E4\uD328" };
+  }
+}
+async function parseHwp(buffer) {
+  try {
+    const markdown = parseHwp5Document(Buffer.from(buffer));
+    return { success: true, fileType: "hwp", markdown };
+  } catch (err) {
+    return { success: false, fileType: "hwp", error: err instanceof Error ? err.message : "HWP \uD30C\uC2F1 \uC2E4\uD328" };
+  }
+}
+async function parsePdf(buffer) {
+  return parsePdfDocument(buffer);
+}
+
+export {
+  __export,
+  detectFormat,
+  parse
+};