kordoc 1.4.0 → 1.5.0

package/dist/{chunk-BWZW234S.js → chunk-5SZWGBNL.js}

@@ -85,8 +85,29 @@ function blocksToMarkdown(blocks) {
   const lines = [];
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];
+    if (block.type === "heading" && block.text) {
+      const prefix = "#".repeat(Math.min(block.level || 2, 6));
+      lines.push("", `${prefix} ${block.text}`, "");
+      continue;
+    }
+    if (block.type === "separator") {
+      lines.push("", "---", "");
+      continue;
+    }
+    if (block.type === "list" && block.text) {
+      const alreadyNumbered = block.listType === "ordered" && /^\d+\.\s/.test(block.text);
+      const prefix = alreadyNumbered ? "" : block.listType === "ordered" ? "1. " : "- ";
+      lines.push(`${prefix}${block.text}`);
+      if (block.children) {
+        for (const child of block.children) {
+          const childPrefix = child.listType === "ordered" ? "1." : "-";
+          lines.push(`  ${childPrefix} ${child.text || ""}`);
+        }
+      }
+      continue;
+    }
     if (block.type === "paragraph" && block.text) {
-      const text = block.text;
+      let text = block.text;
       if (/^\[별표\s*\d+/.test(text)) {
         const nextBlock = blocks[i + 1];
         if (nextBlock?.type === "paragraph" && nextBlock.text && /관련\)?$/.test(nextBlock.text)) {
@@ -101,9 +122,19 @@ function blocksToMarkdown(blocks) {
         lines.push(`*${text}*`, "");
         continue;
       }
+      if (block.href) {
+        text = `[${text}](${block.href})`;
+      }
+      if (block.footnoteText) {
+        text += ` (\uC8FC: ${block.footnoteText})`;
+      }
       lines.push(text);
     } else if (block.type === "table" && block.table) {
+      if (lines.length > 0 && lines[lines.length - 1] !== "") {
+        lines.push("");
+      }
       lines.push(tableToMarkdown(block.table));
+      lines.push("");
     }
   }
   return lines.join("\n").trim();
@@ -154,7 +185,7 @@ function tableToMarkdown(table) {
 }
 
 // src/utils.ts
-var VERSION = true ? "1.4.0" : "0.0.0-dev";
+var VERSION = true ? "1.5.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -228,6 +259,75 @@ var MAX_ZIP_ENTRIES = 500;
 function clampSpan(val, max) {
   return Math.max(1, Math.min(val, max));
 }
+async function extractHwpxStyles(zip) {
+  const result = {
+    charProperties: /* @__PURE__ */ new Map(),
+    styles: /* @__PURE__ */ new Map()
+  };
+  const headerPaths = ["Contents/header.xml", "header.xml", "Contents/head.xml", "head.xml"];
+  for (const hp of headerPaths) {
+    const hpLower = hp.toLowerCase();
+    const file = zip.file(hp) || Object.values(zip.files).find((f) => f.name.toLowerCase() === hpLower) || null;
+    if (!file) continue;
+    try {
+      const xml = await file.async("text");
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(stripDtd(xml), "text/xml");
+      if (!doc.documentElement) continue;
+      parseCharProperties(doc, result.charProperties);
+      parseStyleElements(doc, result.styles);
+      break;
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+function parseCharProperties(doc, map) {
+  const tagNames = ["hh:charPr", "charPr", "hp:charPr"];
+  for (const tagName of tagNames) {
+    const elements = doc.getElementsByTagName(tagName);
+    for (let i = 0; i < elements.length; i++) {
+      const el = elements[i];
+      const id = el.getAttribute("id") || el.getAttribute("IDRef") || "";
+      if (!id) continue;
+      const prop = {};
+      const height = el.getAttribute("height");
+      if (height) prop.fontSize = parseInt(height, 10) / 100;
+      const bold = el.getAttribute("bold");
+      if (bold === "true" || bold === "1") prop.bold = true;
+      const italic = el.getAttribute("italic");
+      if (italic === "true" || italic === "1") prop.italic = true;
+      const fontFaces = el.getElementsByTagName("*");
+      for (let j = 0; j < fontFaces.length; j++) {
+        const ff = fontFaces[j];
+        const localTag = (ff.tagName || "").replace(/^[^:]+:/, "");
+        if (localTag === "fontface" || localTag === "fontRef") {
+          const face = ff.getAttribute("face") || ff.getAttribute("FontFace");
+          if (face) {
+            prop.fontName = face;
+            break;
+          }
+        }
+      }
+      map.set(id, prop);
+    }
+  }
+}
+function parseStyleElements(doc, map) {
+  const tagNames = ["hh:style", "style", "hp:style"];
+  for (const tagName of tagNames) {
+    const elements = doc.getElementsByTagName(tagName);
+    for (let i = 0; i < elements.length; i++) {
+      const el = elements[i];
+      const id = el.getAttribute("id") || el.getAttribute("IDRef") || String(i);
+      const name = el.getAttribute("name") || el.getAttribute("engName") || "";
+      const charPrId = el.getAttribute("charPrIDRef") || void 0;
+      const paraPrId = el.getAttribute("paraPrIDRef") || void 0;
+      map.set(id, { name, charPrId, paraPrId });
+    }
+  }
+}
 function stripDtd(xml) {
   return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
 }
@@ -251,6 +351,8 @@ async function parseHwpxDocument(buffer, options) {
   }
   const metadata = {};
   await extractHwpxMetadata(zip, metadata);
+  const styleMap = await extractHwpxStyles(zip);
+  const warnings = [];
   const sectionPaths = await resolveSectionPaths(zip);
   if (sectionPaths.length === 0) throw new KordocError("HWPX\uC5D0\uC11C \uC139\uC158 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
   metadata.pageCount = sectionPaths.length;
@@ -264,10 +366,12 @@ async function parseHwpxDocument(buffer, options) {
     const xml = await file.async("text");
     totalDecompressed += xml.length * 2;
     if (totalDecompressed > MAX_DECOMPRESS_SIZE) throw new KordocError("ZIP \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
-    blocks.push(...parseSectionXml(xml));
+    blocks.push(...parseSectionXml(xml, styleMap, warnings, si + 1));
   }
+  detectHwpxHeadings(blocks, styleMap);
+  const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
   const markdown = blocksToMarkdown(blocks);
-  return { markdown, blocks, metadata };
+  return { markdown, blocks, metadata, outline: outline.length > 0 ? outline : void 0, warnings: warnings.length > 0 ? warnings : void 0 };
 }
 async function extractHwpxMetadata(zip, metadata) {
   try {
@@ -446,15 +550,50 @@ function parseSectionPathsFromManifest(xml) {
   }
   return Array.from(idToHref.entries()).filter(([id]) => isSectionId(id)).sort((a, b) => a[0].localeCompare(b[0])).map(([, href]) => href);
 }
-function parseSectionXml(xml) {
+function detectHwpxHeadings(blocks, styleMap) {
+  let baseFontSize = 0;
+  const sizeFreq = /* @__PURE__ */ new Map();
+  for (const b of blocks) {
+    if (b.style?.fontSize) {
+      sizeFreq.set(b.style.fontSize, (sizeFreq.get(b.style.fontSize) || 0) + 1);
+    }
+  }
+  let maxCount = 0;
+  for (const [size, count] of sizeFreq) {
+    if (count > maxCount) {
+      maxCount = count;
+      baseFontSize = size;
+    }
+  }
+  for (const block of blocks) {
+    if (block.type !== "paragraph" || !block.text) continue;
+    const text = block.text.trim();
+    if (text.length === 0 || text.length > 200 || /^\d+$/.test(text)) continue;
+    let level = 0;
+    if (baseFontSize > 0 && block.style?.fontSize) {
+      const ratio = block.style.fontSize / baseFontSize;
+      if (ratio >= 1.5) level = 1;
+      else if (ratio >= 1.3) level = 2;
+      else if (ratio >= 1.15) level = 3;
+    }
+    if (/^제\d+[조장절편]/.test(text) && text.length <= 50) {
+      if (level === 0) level = 3;
+    }
+    if (level > 0) {
+      block.type = "heading";
+      block.level = level;
+    }
+  }
+}
+function parseSectionXml(xml, styleMap, warnings, sectionNum) {
   const parser = new DOMParser();
   const doc = parser.parseFromString(stripDtd(xml), "text/xml");
   if (!doc.documentElement) return [];
   const blocks = [];
-  walkSection(doc.documentElement, blocks, null, []);
+  walkSection(doc.documentElement, blocks, null, [], styleMap, warnings, sectionNum);
   return blocks;
 }
-function walkSection(node, blocks, tableCtx, tableStack) {
+function walkSection(node, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum) {
   const children = node.childNodes;
   if (!children) return;
   for (let i = 0; i < children.length; i++) {
@@ -466,7 +605,7 @@ function walkSection(node, blocks, tableCtx, tableStack) {
       case "tbl": {
         if (tableCtx) tableStack.push(tableCtx);
         const newTable = { rows: [], currentRow: [], cell: null };
-        walkSection(el, blocks, newTable, tableStack);
+        walkSection(el, blocks, newTable, tableStack, styleMap, warnings, sectionNum);
         if (newTable.rows.length > 0) {
           if (tableStack.length > 0) {
             const parentTable = tableStack.pop();
@@ -476,7 +615,7 @@ function walkSection(node, blocks, tableCtx, tableStack) {
             }
             tableCtx = parentTable;
           } else {
-            blocks.push({ type: "table", table: buildTable(newTable.rows) });
+            blocks.push({ type: "table", table: buildTable(newTable.rows), pageNumber: sectionNum });
             tableCtx = null;
           }
         } else {
@@ -487,7 +626,7 @@ function walkSection(node, blocks, tableCtx, tableStack) {
       case "tr":
         if (tableCtx) {
           tableCtx.currentRow = [];
-          walkSection(el, blocks, tableCtx, tableStack);
+          walkSection(el, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum);
           if (tableCtx.currentRow.length > 0) tableCtx.rows.push(tableCtx.currentRow);
           tableCtx.currentRow = [];
         }
@@ -495,7 +634,7 @@ function walkSection(node, blocks, tableCtx, tableStack) {
       case "tc":
         if (tableCtx) {
           tableCtx.cell = { text: "", colSpan: 1, rowSpan: 1 };
-          walkSection(el, blocks, tableCtx, tableStack);
+          walkSection(el, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum);
           if (tableCtx.cell) {
             tableCtx.currentRow.push(tableCtx.cell);
             tableCtx.cell = null;
@@ -511,25 +650,75 @@ function walkSection(node, blocks, tableCtx, tableStack) {
         }
         break;
       case "p": {
-        const text = extractParagraphText(el);
+        const { text, href, footnote, style } = extractParagraphInfo(el, styleMap);
         if (text) {
           if (tableCtx?.cell) {
             tableCtx.cell.text += (tableCtx.cell.text ? "\n" : "") + text;
           } else if (!tableCtx) {
-            blocks.push({ type: "paragraph", text });
+            const block = { type: "paragraph", text, pageNumber: sectionNum };
+            if (style) block.style = style;
+            if (href) block.href = href;
+            if (footnote) block.footnoteText = footnote;
+            blocks.push(block);
           }
         }
-        walkSection(el, blocks, tableCtx, tableStack);
+        tableCtx = walkParagraphChildren(el, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum);
         break;
       }
+      // 이미지/그림 — 경고 수집
+      case "pic":
+      case "shape":
+      case "drawingObject":
+        if (warnings && sectionNum) {
+          warnings.push({ page: sectionNum, message: `\uC2A4\uD0B5\uB41C \uC694\uC18C: ${localTag}`, code: "SKIPPED_IMAGE" });
+        }
+        break;
       default:
-        walkSection(el, blocks, tableCtx, tableStack);
+        walkSection(el, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum);
         break;
     }
   }
 }
-function extractParagraphText(para) {
+function walkParagraphChildren(node, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum) {
+  const children = node.childNodes;
+  if (!children) return tableCtx;
+  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(/^[^:]+:/, "");
+    if (localTag === "tbl") {
+      if (tableCtx) tableStack.push(tableCtx);
+      const newTable = { rows: [], currentRow: [], cell: null };
+      walkSection(el, blocks, newTable, tableStack, styleMap, warnings, sectionNum);
+      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), pageNumber: sectionNum });
+          tableCtx = null;
+        }
+      } else {
+        tableCtx = tableStack.length > 0 ? tableStack.pop() : null;
+      }
+    } else if (localTag === "pic" || localTag === "shape" || localTag === "drawingObject") {
+      if (warnings && sectionNum) {
+        warnings.push({ page: sectionNum, message: `\uC2A4\uD0B5\uB41C \uC694\uC18C: ${localTag}`, code: "SKIPPED_IMAGE" });
+      }
+    }
+  }
+  return tableCtx;
+}
+function extractParagraphInfo(para, styleMap) {
   let text = "";
+  let href;
+  let footnote;
+  let charPrId;
   const walk = (node) => {
     const children = node.childNodes;
     if (!children) return;
@@ -558,6 +747,29 @@ function extractParagraphText(para) {
         case "tbl":
           break;
         // 테이블은 walkSection에서 처리
+        // 하이퍼링크
+        case "hyperlink": {
+          const url = child.getAttribute("url") || child.getAttribute("href") || "";
+          if (url) href = url;
+          walk(child);
+          break;
+        }
+        // 각주/미주
+        case "footNote":
+        case "endNote":
+        case "fn":
+        case "en": {
+          const noteText = extractTextFromNode(child);
+          if (noteText) footnote = (footnote ? footnote + "; " : "") + noteText;
+          break;
+        }
+        // run 요소에서 charPrIDRef 추출
+        case "r": {
+          const runCharPr = child.getAttribute("charPrIDRef");
+          if (runCharPr && !charPrId) charPrId = runCharPr;
+          walk(child);
+          break;
+        }
         default:
           walk(child);
           break;
@@ -565,16 +777,43 @@ function extractParagraphText(para) {
     }
   };
   walk(para);
-  return text.replace(/[ \t]+/g, " ").trim();
+  const cleanText = text.replace(/[ \t]+/g, " ").trim();
+  let style;
+  if (styleMap && charPrId) {
+    const charProp = styleMap.charProperties.get(charPrId);
+    if (charProp) {
+      style = {};
+      if (charProp.fontSize) style.fontSize = charProp.fontSize;
+      if (charProp.bold) style.bold = true;
+      if (charProp.italic) style.italic = true;
+      if (charProp.fontName) style.fontName = charProp.fontName;
+      if (!style.fontSize && !style.bold && !style.italic) style = void 0;
+    }
+  }
+  return { text: cleanText, href, footnote, style };
+}
+function extractTextFromNode(node) {
+  let result = "";
+  const children = node.childNodes;
+  if (!children) return result;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (child.nodeType === 3) result += child.textContent || "";
+    else if (child.nodeType === 1) result += extractTextFromNode(child);
+  }
+  return result.trim();
 }
 
 // src/hwp5/record.ts
 import { inflateRawSync as inflateRawSync2, inflateSync } from "zlib";
 var TAG_PARA_HEADER = 66;
 var TAG_PARA_TEXT = 67;
+var TAG_CHAR_SHAPE = 68;
 var TAG_CTRL_HEADER = 71;
 var TAG_LIST_HEADER = 72;
 var TAG_TABLE = 77;
+var TAG_DOC_CHAR_SHAPE = 55;
+var TAG_DOC_STYLE = 58;
 var CHAR_LINE = 0;
 var CHAR_PARA = 13;
 var CHAR_TAB = 9;
@@ -625,6 +864,51 @@ function parseFileHeader(data) {
     flags: data.readUInt32LE(36)
   };
 }
+function parseDocInfo(records) {
+  const charShapes = [];
+  const styles = [];
+  for (const rec of records) {
+    if (rec.tagId === TAG_DOC_CHAR_SHAPE && rec.data.length >= 18) {
+      if (rec.data.length >= 50) {
+        const fontSize = rec.data.readUInt32LE(42);
+        const attrFlags = rec.data.readUInt32LE(46);
+        charShapes.push({ fontSize, attrFlags });
+      } else {
+        charShapes.push({ fontSize: 0, attrFlags: 0 });
+      }
+    }
+    if (rec.tagId === TAG_DOC_STYLE && rec.data.length >= 8) {
+      try {
+        let offset = 0;
+        const nameLen = rec.data.readUInt16LE(offset);
+        offset += 2;
+        const nameBytes = nameLen * 2;
+        const name = nameBytes > 0 && offset + nameBytes <= rec.data.length ? rec.data.subarray(offset, offset + nameBytes).toString("utf16le") : "";
+        offset += nameBytes;
+        let nameKo = "";
+        if (offset + 2 <= rec.data.length) {
+          const nameKoLen = rec.data.readUInt16LE(offset);
+          offset += 2;
+          const nameKoBytes = nameKoLen * 2;
+          if (nameKoBytes > 0 && offset + nameKoBytes <= rec.data.length) {
+            nameKo = rec.data.subarray(offset, offset + nameKoBytes).toString("utf16le");
+          }
+          offset += nameKoBytes;
+        }
+        const type = offset < rec.data.length ? rec.data.readUInt8(offset) : 0;
+        offset += 1;
+        offset += 2;
+        offset += 2;
+        const paraShapeId = offset + 2 <= rec.data.length ? rec.data.readUInt16LE(offset) : 0;
+        offset += 2;
+        const charShapeId = offset + 2 <= rec.data.length ? rec.data.readUInt16LE(offset) : 0;
+        styles.push({ name, nameKo, charShapeId, paraShapeId, type });
+      } catch {
+      }
+    }
+  }
+  return { charShapes, styles };
+}
 function extractText(data) {
   let result = "";
   let i = 0;
@@ -689,6 +973,8 @@ function parseHwp5Document(buffer, options) {
     version: `${header.versionMajor}.x`
   };
   extractHwp5Metadata(cfb, metadata);
+  const docInfo = parseDocInfoStream(cfb, compressed);
+  const warnings = [];
   const sections = findSections(cfb);
   if (sections.length === 0) throw new KordocError("\uC139\uC158 \uC2A4\uD2B8\uB9BC\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
   metadata.pageCount = sections.length;
@@ -702,10 +988,73 @@ function parseHwp5Document(buffer, options) {
     totalDecompressed += data.length;
     if (totalDecompressed > MAX_TOTAL_DECOMPRESS) throw new KordocError("\uCD1D \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (decompression bomb \uC758\uC2EC)");
     const records = readRecords(data);
-    blocks.push(...parseSection(records));
+    const sectionBlocks = parseSection(records, docInfo, warnings, si + 1);
+    blocks.push(...sectionBlocks);
   }
+  if (docInfo) {
+    detectHwp5Headings(blocks, docInfo);
+  }
+  const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
   const markdown = blocksToMarkdown(blocks);
-  return { markdown, blocks, metadata };
+  return { markdown, blocks, metadata, outline: outline.length > 0 ? outline : void 0, warnings: warnings.length > 0 ? warnings : void 0 };
+}
+function parseDocInfoStream(cfb, compressed) {
+  try {
+    const entry = CFB.find(cfb, "/DocInfo");
+    if (!entry?.content) return null;
+    const data = compressed ? decompressStream(Buffer.from(entry.content)) : Buffer.from(entry.content);
+    const records = readRecords(data);
+    return parseDocInfo(records);
+  } catch {
+    return null;
+  }
+}
+function detectHwp5Headings(blocks, docInfo) {
+  let baseFontSize = 0;
+  for (const style of docInfo.styles) {
+    const name = (style.nameKo || style.name).toLowerCase();
+    if (name.includes("\uBC14\uD0D5") || name.includes("\uBCF8\uBB38") || name === "normal" || name === "body") {
+      const cs = docInfo.charShapes[style.charShapeId];
+      if (cs?.fontSize > 0) {
+        baseFontSize = cs.fontSize / 10;
+        break;
+      }
+    }
+  }
+  if (baseFontSize === 0) {
+    const sizeFreq = /* @__PURE__ */ new Map();
+    for (const b of blocks) {
+      if (b.style?.fontSize) {
+        sizeFreq.set(b.style.fontSize, (sizeFreq.get(b.style.fontSize) || 0) + 1);
+      }
+    }
+    let maxCount = 0;
+    for (const [size, count] of sizeFreq) {
+      if (count > maxCount) {
+        maxCount = count;
+        baseFontSize = size;
+      }
+    }
+  }
+  if (baseFontSize <= 0) return;
+  for (const block of blocks) {
+    if (block.type !== "paragraph" || !block.text || !block.style?.fontSize) continue;
+    const text = block.text.trim();
+    if (text.length === 0 || text.length > 200) continue;
+    if (/^\d+$/.test(text)) continue;
+    const ratio = block.style.fontSize / baseFontSize;
+    let level = 0;
+    if (ratio >= 1.5) level = 1;
+    else if (ratio >= 1.3) level = 2;
+    else if (ratio >= 1.15) level = 3;
+    if (/^제\d+[조장절편]/.test(text) && text.length <= 50) {
+      if (level === 0) level = 3;
+    }
+    if (level > 0) {
+      block.type = "heading";
+      block.level = level;
+    }
+  }
 }
 function extractHwp5Metadata(cfb, metadata) {
   try {
@@ -771,15 +1120,22 @@ function findSections(cfb) {
   }
   return sections.sort((a, b) => a.idx - b.idx).map((s) => s.content);
 }
-function parseSection(records) {
+function parseSection(records, docInfo, warnings, sectionNum) {
   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 });
+      const { paragraph, tables, nextIdx, charShapeIds } = parseParagraphWithTables(records, i);
+      if (paragraph) {
+        const block = { type: "paragraph", text: paragraph, pageNumber: sectionNum };
+        if (docInfo && charShapeIds.length > 0) {
+          const style = resolveCharStyle(charShapeIds, docInfo);
+          if (style) block.style = style;
+        }
+        blocks.push(block);
+      }
+      for (const t of tables) blocks.push({ type: "table", table: t, pageNumber: sectionNum });
       i = nextIdx;
       continue;
     }
@@ -787,19 +1143,43 @@ function parseSection(records) {
       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 });
+        if (table) blocks.push({ type: "table", table, pageNumber: sectionNum });
         i = nextIdx;
         continue;
       }
+      if (ctrlId === "gso " || ctrlId === " osg" || ctrlId === " elo" || ctrlId === "ole ") {
+        warnings.push({ page: sectionNum, message: `\uC2A4\uD0B5\uB41C \uC81C\uC5B4 \uC694\uC18C: ${ctrlId.trim()}`, code: "SKIPPED_IMAGE" });
+      }
     }
     i++;
   }
   return blocks;
 }
+function resolveCharStyle(charShapeIds, docInfo) {
+  if (charShapeIds.length === 0 || docInfo.charShapes.length === 0) return void 0;
+  const freq = /* @__PURE__ */ new Map();
+  let maxCount = 0, dominantId = charShapeIds[0];
+  for (const id of charShapeIds) {
+    const count = (freq.get(id) || 0) + 1;
+    freq.set(id, count);
+    if (count > maxCount) {
+      maxCount = count;
+      dominantId = id;
+    }
+  }
+  const cs = docInfo.charShapes[dominantId];
+  if (!cs) return void 0;
+  const style = {};
+  if (cs.fontSize > 0) style.fontSize = cs.fontSize / 10;
+  if (cs.attrFlags & 1) style.italic = true;
+  if (cs.attrFlags & 2) style.bold = true;
+  return style.fontSize || style.bold || style.italic ? style : void 0;
+}
 function parseParagraphWithTables(records, startIdx) {
   const startLevel = records[startIdx].level;
   let text = "";
   const tables = [];
+  const charShapeIds = [];
   let i = startIdx + 1;
   while (i < records.length) {
     const rec = records[i];
@@ -807,6 +1187,11 @@ function parseParagraphWithTables(records, startIdx) {
     if (rec.tagId === TAG_PARA_TEXT) {
       text = extractText(rec.data);
     }
+    if (rec.tagId === TAG_CHAR_SHAPE && rec.data.length >= 8) {
+      for (let offset = 0; offset + 7 < rec.data.length; offset += 8) {
+        charShapeIds.push(rec.data.readUInt32LE(offset + 4));
+      }
+    }
     if (rec.tagId === TAG_CTRL_HEADER && rec.data.length >= 4) {
       const ctrlId = rec.data.subarray(0, 4).toString("ascii");
       if (ctrlId === " lbt" || ctrlId === "tbl ") {
@@ -819,7 +1204,7 @@ function parseParagraphWithTables(records, startIdx) {
     i++;
   }
   const trimmed = text.trim();
-  return { paragraph: trimmed || null, tables, nextIdx: i };
+  return { paragraph: trimmed || null, tables, nextIdx: i, charShapeIds };
 }
 function parseTableBlock(records, startIdx) {
   const tableLevel = records[startIdx].level;
@@ -891,6 +1276,355 @@ function arrangeCells(rows, cols, cells) {
   return grid.map((row) => row.map((c) => c || { text: "", colSpan: 1, rowSpan: 1 }));
 }
 
+// src/pdf/line-detector.ts
+import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
+var ORIENTATION_TOL = 2;
+var MIN_LINE_LENGTH = 10;
+var COORD_MERGE_TOL = 3;
+var CONNECT_TOL = 5;
+var CELL_PADDING = 2;
+function extractLines(fnArray, argsArray) {
+  const horizontals = [];
+  const verticals = [];
+  let lineWidth = 1;
+  let currentPath = [];
+  let pathStartX = 0, pathStartY = 0;
+  let curX = 0, curY = 0;
+  function flushPath(isStroke) {
+    if (!isStroke) {
+      currentPath = [];
+      return;
+    }
+    for (const seg of currentPath) {
+      classifyAndAdd(seg, lineWidth, horizontals, verticals);
+    }
+    currentPath = [];
+  }
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    const args = argsArray[i];
+    switch (op) {
+      case OPS.setLineWidth:
+        lineWidth = args[0] || 1;
+        break;
+      case OPS.constructPath: {
+        const subOps = args[0];
+        const coords = args[1];
+        let ci = 0;
+        for (const subOp of subOps) {
+          if (subOp === OPS.moveTo) {
+            curX = coords[ci++];
+            curY = coords[ci++];
+            pathStartX = curX;
+            pathStartY = curY;
+          } else if (subOp === OPS.lineTo) {
+            const x2 = coords[ci++], y2 = coords[ci++];
+            currentPath.push({ x1: curX, y1: curY, x2, y2 });
+            curX = x2;
+            curY = y2;
+          } else if (subOp === OPS.rectangle) {
+            const rx = coords[ci++], ry = coords[ci++];
+            const rw = coords[ci++], rh = coords[ci++];
+            if (Math.abs(rh) < ORIENTATION_TOL * 2) {
+              currentPath.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
+            } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
+              currentPath.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
+            } else {
+              currentPath.push(
+                { x1: rx, y1: ry, x2: rx + rw, y2: ry },
+                // bottom
+                { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
+                // right
+                { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
+                // top
+                { x1: rx, y1: ry + rh, x2: rx, y2: ry }
+                // left
+              );
+            }
+          } else if (subOp === OPS.closePath) {
+            if (curX !== pathStartX || curY !== pathStartY) {
+              currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+            }
+            curX = pathStartX;
+            curY = pathStartY;
+          } else if (subOp === OPS.curveTo) {
+            ci += 6;
+          } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
+            ci += 4;
+          }
+        }
+        break;
+      }
+      case OPS.stroke:
+      case OPS.closeStroke:
+        flushPath(true);
+        break;
+      case OPS.fill:
+      case OPS.eoFill:
+      case OPS.fillStroke:
+      case OPS.eoFillStroke:
+      case OPS.closeFillStroke:
+      case OPS.closeEOFillStroke:
+        flushPath(true);
+        break;
+      case OPS.endPath:
+        flushPath(false);
+        break;
+    }
+  }
+  return { horizontals, verticals };
+}
+function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
+  const dx = Math.abs(seg.x2 - seg.x1);
+  const dy = Math.abs(seg.y2 - seg.y1);
+  const length = Math.sqrt(dx * dx + dy * dy);
+  if (length < MIN_LINE_LENGTH) return;
+  if (dy <= ORIENTATION_TOL) {
+    const y = (seg.y1 + seg.y2) / 2;
+    const x1 = Math.min(seg.x1, seg.x2);
+    const x2 = Math.max(seg.x1, seg.x2);
+    horizontals.push({ x1, y1: y, x2, y2: y, lineWidth });
+  } else if (dx <= ORIENTATION_TOL) {
+    const x = (seg.x1 + seg.x2) / 2;
+    const y1 = Math.min(seg.y1, seg.y2);
+    const y2 = Math.max(seg.y1, seg.y2);
+    verticals.push({ x1: x, y1, x2: x, y2, lineWidth });
+  }
+}
+function filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight) {
+  const margin = 5;
+  return {
+    horizontals: horizontals.filter(
+      (l) => !(Math.abs(l.y1) < margin || Math.abs(l.y1 - pageHeight) < margin) || l.x2 - l.x1 < pageWidth * 0.9
+    ),
+    verticals: verticals.filter(
+      (l) => !(Math.abs(l.x1) < margin || Math.abs(l.x1 - pageWidth) < margin) || l.y2 - l.y1 < pageHeight * 0.9
+    )
+  };
+}
+function buildTableGrids(horizontals, verticals) {
+  if (horizontals.length < 2 || verticals.length < 2) return [];
+  const allLines = [
+    ...horizontals.map((l, i) => ({ ...l, type: "h", id: i })),
+    ...verticals.map((l, i) => ({ ...l, type: "v", id: i + horizontals.length }))
+  ];
+  const groups = groupConnectedLines(allLines);
+  const grids = [];
+  for (const group of groups) {
+    const hLines = group.filter((l) => l.type === "h");
+    const vLines = group.filter((l) => l.type === "v");
+    if (hLines.length < 2 || vLines.length < 2) continue;
+    const rawYs = hLines.map((l) => l.y1);
+    const rowYs = clusterCoordinates(rawYs).sort((a, b) => b - a);
+    const rawXs = vLines.map((l) => l.x1);
+    const colXs = clusterCoordinates(rawXs).sort((a, b) => a - b);
+    if (rowYs.length < 2 || colXs.length < 2) continue;
+    const bbox = {
+      x1: colXs[0],
+      y1: rowYs[rowYs.length - 1],
+      x2: colXs[colXs.length - 1],
+      y2: rowYs[0]
+    };
+    grids.push({ rowYs, colXs, bbox });
+  }
+  return grids;
+}
+function clusterCoordinates(values) {
+  if (values.length === 0) return [];
+  const sorted = [...values].sort((a, b) => a - b);
+  const clusters = [{ sum: sorted[0], count: 1 }];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = clusters[clusters.length - 1];
+    const avg = last.sum / last.count;
+    if (Math.abs(sorted[i] - avg) <= COORD_MERGE_TOL) {
+      last.sum += sorted[i];
+      last.count++;
+    } else {
+      clusters.push({ sum: sorted[i], count: 1 });
+    }
+  }
+  return clusters.map((c) => c.sum / c.count);
+}
+function groupConnectedLines(lines) {
+  const parent = lines.map((_, i) => i);
+  function find(x) {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  }
+  function union(a, b) {
+    const ra = find(a), rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    for (let j = i + 1; j < lines.length; j++) {
+      if (linesIntersect(lines[i], lines[j])) {
+        union(i, j);
+      }
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const root = find(i);
+    if (!groups.has(root)) groups.set(root, []);
+    groups.get(root).push(lines[i]);
+  }
+  return [...groups.values()];
+}
+function linesIntersect(a, b) {
+  if (a.type === b.type) {
+    if (a.type === "h") {
+      if (Math.abs(a.y1 - b.y1) > CONNECT_TOL) return false;
+      return Math.min(a.x2, b.x2) >= Math.max(a.x1, b.x1) - CONNECT_TOL;
+    } else {
+      if (Math.abs(a.x1 - b.x1) > CONNECT_TOL) return false;
+      return Math.min(a.y2, b.y2) >= Math.max(a.y1, b.y1) - CONNECT_TOL;
+    }
+  }
+  const h = a.type === "h" ? a : b;
+  const v = a.type === "h" ? b : a;
+  const tol = CONNECT_TOL;
+  return v.x1 >= h.x1 - tol && v.x1 <= h.x2 + tol && h.y1 >= v.y1 - tol && h.y1 <= v.y2 + tol;
+}
+function extractCells(grid, horizontals, verticals) {
+  const { rowYs, colXs } = grid;
+  const numRows = rowYs.length - 1;
+  const numCols = colXs.length - 1;
+  if (numRows <= 0 || numCols <= 0) return [];
+  const occupied = Array.from({ length: numRows }, () => Array(numCols).fill(false));
+  const cells = [];
+  for (let r = 0; r < numRows; r++) {
+    for (let c = 0; c < numCols; c++) {
+      if (occupied[r][c]) continue;
+      let colSpan = 1;
+      let rowSpan = 1;
+      while (c + colSpan < numCols) {
+        const borderX = colXs[c + colSpan];
+        const topY = rowYs[r];
+        const botY = rowYs[r + 1];
+        if (hasVerticalLine(verticals, borderX, topY, botY)) break;
+        colSpan++;
+      }
+      while (r + rowSpan < numRows) {
+        const borderY = rowYs[r + rowSpan];
+        const leftX = colXs[c];
+        const rightX = colXs[c + colSpan];
+        if (hasHorizontalLine(horizontals, borderY, leftX, rightX)) break;
+        rowSpan++;
+      }
+      for (let dr = 0; dr < rowSpan; dr++) {
+        for (let dc = 0; dc < colSpan; dc++) {
+          occupied[r + dr][c + dc] = true;
+        }
+      }
+      cells.push({
+        row: r,
+        col: c,
+        rowSpan,
+        colSpan,
+        bbox: {
+          x1: colXs[c],
+          y1: rowYs[r + rowSpan],
+          x2: colXs[c + colSpan],
+          y2: rowYs[r]
+        }
+      });
+    }
+  }
+  return cells;
+}
+function hasVerticalLine(verticals, x, topY, botY) {
+  const tol = COORD_MERGE_TOL + 1;
+  for (const v of verticals) {
+    if (Math.abs(v.x1 - x) <= tol) {
+      const cellH = Math.abs(topY - botY);
+      const overlapTop = Math.min(v.y2, topY);
+      const overlapBot = Math.max(v.y1, botY);
+      const overlap = overlapTop - overlapBot;
+      if (overlap >= cellH * 0.5) return true;
+    }
+  }
+  return false;
+}
+function hasHorizontalLine(horizontals, y, leftX, rightX) {
+  const tol = COORD_MERGE_TOL + 1;
+  for (const h of horizontals) {
+    if (Math.abs(h.y1 - y) <= tol) {
+      const cellW = Math.abs(rightX - leftX);
+      const overlapLeft = Math.max(h.x1, leftX);
+      const overlapRight = Math.min(h.x2, rightX);
+      const overlap = overlapRight - overlapLeft;
+      if (overlap >= cellW * 0.5) return true;
+    }
+  }
+  return false;
+}
+function mapTextToCells(items, cells) {
+  const result = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    result.set(cell, []);
+  }
+  for (const item of items) {
+    const cx = item.x + item.w / 2;
+    const cy = item.y;
+    const pad = CELL_PADDING;
+    let bestCell = null;
+    let bestDist = Infinity;
+    for (const cell of cells) {
+      if (cx >= cell.bbox.x1 - pad && cx <= cell.bbox.x2 + pad && cy >= cell.bbox.y1 - pad && cy <= cell.bbox.y2 + pad) {
+        const cellCx = (cell.bbox.x1 + cell.bbox.x2) / 2;
+        const cellCy = (cell.bbox.y1 + cell.bbox.y2) / 2;
+        const dist = Math.abs(cx - cellCx) + Math.abs(cy - cellCy);
+        if (dist < bestDist) {
+          bestDist = dist;
+          bestCell = cell;
+        }
+      }
+    }
+    if (bestCell) {
+      result.get(bestCell).push(item);
+    }
+  }
+  return result;
+}
+function cellTextToString(items) {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0].text;
+  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
+  const lines = [];
+  let curLine = [sorted[0]];
+  let curY = sorted[0].y;
+  for (let i = 1; i < sorted.length; i++) {
+    const tol = Math.max(3, Math.min(sorted[i].fontSize, curLine[0].fontSize) * 0.6);
+    if (Math.abs(sorted[i].y - curY) <= tol) {
+      curLine.push(sorted[i]);
+    } else {
+      lines.push(curLine);
+      curLine = [sorted[i]];
+      curY = sorted[i].y;
+    }
+  }
+  lines.push(curLine);
+  const textLines = lines.map((line) => {
+    const s = line.sort((a, b) => a.x - b.x);
+    return s.map((i) => i.text).join(" ");
+  });
+  if (textLines.length <= 1) return textLines[0] || "";
+  const merged = [textLines[0]];
+  for (let i = 1; i < textLines.length; i++) {
+    const prev = merged[merged.length - 1];
+    const curr = textLines[i];
+    if (/[가-힣]$/.test(prev) && /^[가-힣]+$/.test(curr) && curr.length <= 5 && !curr.includes(" ")) {
+      merged[merged.length - 1] = prev + curr;
+    } else {
+      merged.push(curr);
+    }
+  }
+  return merged.join("\n");
+}
+
 // src/pdf/polyfill.ts
 import * as pdfjsWorker from "pdfjs-dist/legacy/build/pdf.worker.mjs";
 var g = globalThis;
@@ -922,44 +1656,62 @@ async function parsePdfDocument(buffer, options) {
   }).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.", blocks: [] };
+    if (pageCount === 0) return { success: false, fileType: "pdf", pageCount: 0, error: "PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", code: "PARSE_ERROR" };
     const metadata = { pageCount };
     await extractPdfMetadata(doc, metadata);
-    const pageTexts = [];
     const blocks = [];
+    const warnings = [];
     let totalChars = 0;
     let totalTextBytes = 0;
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
     const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
+    const allFontSizes = [];
     for (let i = 1; i <= effectivePageCount; i++) {
       if (pageFilter && !pageFilter.has(i)) continue;
       const page = await doc.getPage(i);
       const tc = await page.getTextContent();
-      const pageText = extractPageContent(tc.items);
-      totalChars += pageText.replace(/\s/g, "").length;
-      totalTextBytes += pageText.length * 2;
+      const viewport = page.getViewport({ scale: 1 });
+      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) allFontSizes.push(item.fontSize);
+      }
+      const opList = await page.getOperatorList();
+      const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
+      for (const b of pageBlocks) blocks.push(b);
+      for (const b of pageBlocks) {
+        const t = b.text || "";
+        totalChars += t.replace(/\s/g, "").length;
+        totalTextBytes += t.length * 2;
+      }
       if (totalTextBytes > MAX_TOTAL_TEXT) throw new KordocError("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
-      pageTexts.push(pageText);
-      blocks.push({ type: "paragraph", text: pageText });
     }
     const parsedPageCount = pageFilter ? pageFilter.size : effectivePageCount;
     if (totalChars / Math.max(parsedPageCount, 1) < 10) {
       if (options?.ocr) {
         try {
-          const { ocrPages } = await import("./provider-JB7SY74K.js");
+          const { ocrPages } = await import("./provider-A4FHJSID.js");
           const ocrBlocks = await ocrPages(doc, options.ocr, pageFilter, effectivePageCount);
           if (ocrBlocks.length > 0) {
             const ocrMarkdown = ocrBlocks.map((b) => b.text || "").filter(Boolean).join("\n\n");
-            return { success: true, fileType: "pdf", markdown: ocrMarkdown, pageCount: parsedPageCount, blocks: ocrBlocks, metadata, isImageBased: true };
+            return { success: true, fileType: "pdf", markdown: ocrMarkdown, pageCount: parsedPageCount, blocks: ocrBlocks, metadata, isImageBased: true, warnings };
           }
         } catch {
         }
       }
       return { success: false, fileType: "pdf", pageCount, isImageBased: true, error: `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`, code: "IMAGE_BASED_PDF" };
     }
-    let markdown = pageTexts.filter((t) => t.trim()).join("\n\n");
-    markdown = cleanPdfText(markdown);
-    return { success: true, fileType: "pdf", markdown, pageCount: parsedPageCount, blocks, metadata };
+    const medianFontSize = computeMedianFontSize(allFontSizes);
+    if (medianFontSize > 0) {
+      detectHeadings(blocks, medianFontSize);
+    }
+    const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
+    let markdown = cleanPdfText(blocksToMarkdown(blocks));
+    return { success: true, fileType: "pdf", markdown, pageCount: parsedPageCount, blocks, metadata, outline: outline.length > 0 ? outline : void 0, warnings: warnings.length > 0 ? warnings : void 0 };
   } finally {
     await doc.destroy().catch(() => {
     });
@@ -1004,24 +1756,272 @@ async function extractPdfMetadataOnly(buffer) {
     });
   }
 }
-function extractPageContent(rawItems) {
-  const items = normalizeItems(rawItems);
-  if (items.length === 0) return "";
-  const yLines = groupByY(items);
-  const columns = detectColumns(yLines);
+function filterHiddenText(items, pageWidth, pageHeight) {
+  let hiddenCount = 0;
+  const visible = [];
+  for (const item of items) {
+    if (item.isHidden) {
+      hiddenCount++;
+      continue;
+    }
+    const margin = Math.max(pageWidth, pageHeight) * 0.1;
+    if (item.x < -margin || item.x > pageWidth + margin || item.y < -margin || item.y > pageHeight + margin) {
+      hiddenCount++;
+      continue;
+    }
+    visible.push(item);
+  }
+  return { visible, hiddenCount };
+}
+function computeMedianFontSize(sizes) {
+  if (sizes.length === 0) return 0;
+  const sorted = [...sizes].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function detectHeadings(blocks, medianFontSize) {
+  for (const block of blocks) {
+    if (block.type !== "paragraph" || !block.text || !block.style?.fontSize) continue;
+    const text = block.text.trim();
+    if (text.length === 0 || text.length > 200) continue;
+    if (/^\d+$/.test(text)) continue;
+    const ratio = block.style.fontSize / medianFontSize;
+    let level = 0;
+    if (ratio >= 1.5) level = 1;
+    else if (ratio >= 1.3) level = 2;
+    else if (ratio >= 1.15) level = 3;
+    if (level > 0) {
+      block.type = "heading";
+      block.level = level;
+    }
+  }
+}
+var MAX_XYCUT_DEPTH = 50;
+function xyCutOrder(items, gapThreshold, depth = 0) {
+  if (items.length === 0) return [];
+  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return [items];
+  const region = computeRegion(items);
+  const ySplit = findYSplit(items, region, gapThreshold);
+  if (ySplit !== null) {
+    const upper = items.filter((i) => i.y > ySplit);
+    const lower = items.filter((i) => i.y <= ySplit);
+    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
+      return [...xyCutOrder(upper, gapThreshold, depth + 1), ...xyCutOrder(lower, gapThreshold, depth + 1)];
+    }
+  }
+  const xSplit = findXSplit(items, region, gapThreshold);
+  if (xSplit !== null) {
+    const left = items.filter((i) => i.x + i.w / 2 < xSplit);
+    const right = items.filter((i) => i.x + i.w / 2 >= xSplit);
+    if (left.length > 0 && right.length > 0 && left.length < items.length) {
+      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
+    }
+  }
+  return [items];
+}
+function computeRegion(items) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const i of items) {
+    if (i.x < minX) minX = i.x;
+    if (i.y < minY) minY = i.y;
+    if (i.x + i.w > maxX) maxX = i.x + i.w;
+    if (i.y + i.h > maxY) maxY = i.y + i.h;
+  }
+  return { items, minX, minY, maxX, maxY };
+}
+function findYSplit(items, region, gapThreshold) {
+  const sorted = [...items].sort((a, b) => b.y - a.y);
+  let bestGap = gapThreshold;
+  let bestSplit = null;
+  for (let i = 1; i < sorted.length; i++) {
+    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
+    const currTop = sorted[i].y;
+    const gap = prevBottom - currTop;
+    if (gap > bestGap) {
+      bestGap = gap;
+      bestSplit = (prevBottom + currTop) / 2;
+    }
+  }
+  return bestSplit;
+}
+function findXSplit(items, region, gapThreshold) {
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  let bestGap = gapThreshold;
+  let bestSplit = null;
+  for (let i = 1; i < sorted.length; i++) {
+    const prevRight = sorted[i - 1].x + sorted[i - 1].w;
+    const currLeft = sorted[i].x;
+    const gap = currLeft - prevRight;
+    if (gap > bestGap) {
+      bestGap = gap;
+      bestSplit = (prevRight + currLeft) / 2;
+    }
+  }
+  return bestSplit;
+}
+function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight) {
+  if (items.length === 0) return [];
+  let { horizontals, verticals } = extractLines(opList.fnArray, opList.argsArray);
+  ({ horizontals, verticals } = filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight));
+  const grids = buildTableGrids(horizontals, verticals);
+  if (grids.length > 0) {
+    return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
+  }
+  return extractPageBlocksFallback(items, pageNum);
+}
+function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
+  const blocks = [];
+  const usedItems = /* @__PURE__ */ new Set();
+  const sortedGrids = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
+  for (const grid of sortedGrids) {
+    const tableItems = [];
+    const pad = 3;
+    for (const item of items) {
+      if (usedItems.has(item)) continue;
+      if (item.x >= grid.bbox.x1 - pad && item.x + item.w <= grid.bbox.x2 + pad && item.y >= grid.bbox.y1 - pad && item.y <= grid.bbox.y2 + pad) {
+        tableItems.push(item);
+        usedItems.add(item);
+      }
+    }
+    const cells = extractCells(grid, horizontals, verticals);
+    if (cells.length === 0) continue;
+    const textItems = tableItems.map((i) => ({
+      text: i.text,
+      x: i.x,
+      y: i.y,
+      w: i.w,
+      h: i.h,
+      fontSize: i.fontSize,
+      fontName: i.fontName
+    }));
+    const cellTextMap = mapTextToCells(textItems, cells);
+    const numRows = grid.rowYs.length - 1;
+    const numCols = grid.colXs.length - 1;
+    const irGrid = Array.from(
+      { length: numRows },
+      () => Array.from({ length: numCols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }))
+    );
+    for (const cell of cells) {
+      const textItems2 = cellTextMap.get(cell) || [];
+      const text = cellTextToString(textItems2);
+      irGrid[cell.row][cell.col] = {
+        text,
+        colSpan: cell.colSpan,
+        rowSpan: cell.rowSpan
+      };
+    }
+    const irTable = {
+      rows: numRows,
+      cols: numCols,
+      cells: irGrid,
+      hasHeader: numRows > 1
+    };
+    blocks.push({
+      type: "table",
+      table: irTable,
+      pageNumber: pageNum,
+      bbox: {
+        page: pageNum,
+        x: grid.bbox.x1,
+        y: grid.bbox.y1,
+        width: grid.bbox.x2 - grid.bbox.x1,
+        height: grid.bbox.y2 - grid.bbox.y1
+      }
+    });
+  }
+  const remaining = items.filter((i) => !usedItems.has(i));
+  if (remaining.length > 0) {
+    remaining.sort((a, b) => b.y - a.y || a.x - b.x);
+    const textBlocks = detectListBlocks(extractPageBlocksFallback(remaining, pageNum));
+    const allBlocks = [...blocks, ...textBlocks];
+    allBlocks.sort((a, b) => {
+      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
+      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
+      return by - ay;
+    });
+    return allBlocks;
+  }
+  return blocks;
+}
+function extractPageBlocksFallback(items, pageNum) {
+  if (items.length === 0) return [];
+  const blocks = [];
+  const allYLines = groupByY(items);
+  const columns = detectColumns(allYLines);
   if (columns && columns.length >= 3) {
-    return extractWithColumns(yLines, columns);
+    const tableText = extractWithColumns(allYLines, columns);
+    const bbox = computeBBox(items, pageNum);
+    blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(items) });
+  } else {
+    const allY = items.map((i) => i.y);
+    const pageHeight = Math.max(...allY) - Math.min(...allY);
+    const gapThreshold = Math.max(15, pageHeight * 0.03);
+    const orderedGroups = xyCutOrder(items, gapThreshold);
+    for (const group of orderedGroups) {
+      if (group.length === 0) continue;
+      const yLines = groupByY(group);
+      const groupColumns = detectColumns(yLines);
+      if (groupColumns && groupColumns.length >= 3) {
+        const tableText = extractWithColumns(yLines, groupColumns);
+        const bbox = computeBBox(group, pageNum);
+        blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(group) });
+      } else {
+        for (const line of yLines) {
+          const text = mergeLineSimple(line);
+          if (!text.trim()) continue;
+          const bbox = computeBBox(line, pageNum);
+          blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
+        }
+      }
+    }
+  }
+  return blocks;
+}
+function computeBBox(items, pageNum) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const i of items) {
+    if (i.x < minX) minX = i.x;
+    if (i.y < minY) minY = i.y;
+    if (i.x + i.w > maxX) maxX = i.x + i.w;
+    const effectiveH = i.h > 0 ? i.h : i.fontSize;
+    if (i.y + effectiveH > maxY) maxY = i.y + effectiveH;
+  }
+  return { page: pageNum, x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function dominantStyle(items) {
+  if (items.length === 0) return void 0;
+  const freq = /* @__PURE__ */ new Map();
+  let maxCount = 0, dominantSize = 0;
+  for (const i of items) {
+    if (i.fontSize <= 0) continue;
+    const count = (freq.get(i.fontSize) || 0) + 1;
+    freq.set(i.fontSize, count);
+    if (count > maxCount) {
+      maxCount = count;
+      dominantSize = i.fontSize;
+    }
   }
-  return yLines.map((line) => mergeLineSimple(line)).join("\n");
+  if (dominantSize === 0) return void 0;
+  const fontName = items.find((i) => i.fontSize === dominantSize)?.fontName || void 0;
+  return { fontSize: dominantSize, fontName };
 }
 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);
+  return rawItems.filter((i) => typeof i.str === "string" && i.str.trim() !== "").map((i) => {
+    const scaleY = Math.abs(i.transform[3]);
+    const scaleX = Math.abs(i.transform[0]);
+    const fontSize = Math.round(Math.max(scaleY, scaleX));
+    return {
+      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),
+      fontSize,
+      fontName: i.fontName || "",
+      // 0pt 폰트이거나 너비 0 → hidden text (prompt injection 의심)
+      isHidden: fontSize === 0 || i.width === 0 && i.str.trim().length > 0
+    };
+  }).sort((a, b) => b.y - a.y || a.x - b.x);
 }
 function groupByY(items) {
   if (items.length === 0) return [];
@@ -1259,6 +2259,27 @@ function startsWithMarker(line) {
 function isStandaloneHeader(line) {
   return /^제\d+[조항호장절](\([^)]*\))?(\s+\S+){0,7}$/.test(line.trim());
 }
+function detectListBlocks(blocks) {
+  const result = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type === "paragraph" && block.text) {
+      const match = block.text.match(/^(\d+)\.\s/);
+      if (match) {
+        result.push({
+          ...block,
+          type: "list",
+          listType: "ordered",
+          // 원래 번호를 text에 보존 (blocksToMarkdown에서 그대로 출력)
+          text: block.text
+        });
+        continue;
+      }
+    }
+    result.push(block);
+  }
+  return result;
+}
 function mergeKoreanLines(text) {
   if (!text) return "";
   const lines = text.split("\n");
@@ -1267,6 +2288,10 @@ function mergeKoreanLines(text) {
   for (let i = 1; i < lines.length; i++) {
     const prev = result[result.length - 1];
     const curr = lines[i];
+    if (/^#{1,6}\s/.test(prev) || /^#{1,6}\s/.test(curr)) {
+      result.push(curr);
+      continue;
+    }
     if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev)) {
       result[result.length - 1] = prev + " " + curr;
     } else {
@@ -1424,16 +2449,16 @@ async function parse(buffer, options) {
 }
 async function parseHwpx(buffer, options) {
   try {
-    const { markdown, blocks, metadata } = await parseHwpxDocument(buffer, options);
-    return { success: true, fileType: "hwpx", markdown, blocks, metadata };
+    const { markdown, blocks, metadata, outline, warnings } = await parseHwpxDocument(buffer, options);
+    return { success: true, fileType: "hwpx", markdown, blocks, metadata, outline, warnings };
   } catch (err) {
     return { success: false, fileType: "hwpx", error: err instanceof Error ? err.message : "HWPX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
 async function parseHwp(buffer, options) {
   try {
-    const { markdown, blocks, metadata } = parseHwp5Document(Buffer.from(buffer), options);
-    return { success: true, fileType: "hwp", markdown, blocks, metadata };
+    const { markdown, blocks, metadata, outline, warnings } = parseHwp5Document(Buffer.from(buffer), options);
+    return { success: true, fileType: "hwp", markdown, blocks, metadata, outline, warnings };
   } catch (err) {
     return { success: false, fileType: "hwp", error: err instanceof Error ? err.message : "HWP \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
@@ -1578,12 +2603,13 @@ function fallbackAlign(a, b) {
 }
 function blockSimilarity(a, b) {
   if (a.type !== b.type) return 0;
-  if (a.type === "paragraph") {
+  if (a.text !== void 0 && b.text !== void 0) {
     return normalizedSimilarity(a.text || "", b.text || "");
   }
   if (a.type === "table" && a.table && b.table) {
     return tableSimilarity(a.table, b.table);
   }
+  if (a.type === b.type) return 1;
   return 0;
 }
 function tableSimilarity(a, b) {
@@ -1628,4 +2654,4 @@ export {
   extractFormFields,
   parse
 };
-//# sourceMappingURL=chunk-BWZW234S.js.map
+//# sourceMappingURL=chunk-5SZWGBNL.js.map