kordoc 2.2.4 → 2.2.6

package/README.md

@@ -23,15 +23,27 @@ HWP, HWPX, PDF, XLSX, DOCX — 관공서에서 쏟아지는 모든 문서를 파
 *   **📊 복잡한 표(Table) 완벽 재현**: 선이 없는 PDF나 복잡하게 병합된 HWP 표도 구조를 분석하여 정확한 마크다운 테이블로 복원합니다.
 *   **🔍 신구대조표 자동 생성**: 두 문서의 차이점을 분석하여 무엇이 바뀌었는지 한눈에 보여줍니다. (HWP와 HWPX 간의 비교도 가능!)
 *   **📝 마크다운을 다시 HWPX로**: AI가 작성한 내용을 다시 보고서 양식(`HWPX`)으로 되돌려줍니다. 이제 복사-붙여넣기 노가다에서 해방되세요.
+*   **✏️ 양식 자동 채우기**: 공문서 양식 템플릿(신청서, 보고서)에 값을 넣으면 자동으로 빈칸을 채웁니다. 원본 서식(글꼴, 크기, 정렬)을 100% 보존합니다.
 *   **🤖 AI 에이전트 연동 (MCP)**: `Claude`, `Cursor`와 같은 도구에서 직접 `kordoc`을 호출해 문서를 읽고 코딩할 수 있습니다.
 
 ---
 
-## v2.2.1 변경사항
+## v2.2.4 변경사항
+
+- **📝 양식 자동 채우기 (Form Filler)** — 공문서 양식 템플릿에 값을 자동으로 채워넣습니다. 라벨-값 셀 패턴, 체크박스(`□`→`☑`), 괄호 빈칸(`일반(  )통`→`일반(3)통`), 어노테이션(`(한자：)`→`(한자：金)`) 지원.
+- **🏛️ HWPX 원본 서식 보존 모드** — `fillHwpx()`로 HWPX XML을 직접 조작하여 글꼴, 크기, 정렬 등 원본 서식 100% 유지한 채 값만 교체.
+- **📊 병합 셀 HTML 테이블 출력** — `colspan`/`rowspan`이 있는 복잡한 표를 GFM 대신 HTML `<table>`로 출력하여 구조 보존.
+- **🔧 markdownToHwpx 서식 강화** — 역변환 시 heading/bold/italic/table 등 서식 지원 대폭 개선.
+- **🤖 MCP fill_form 도구** — AI 에이전트가 양식을 직접 채울 수 있는 새 MCP 도구 추가 (총 8개).
+
+<details>
+<summary>v2.2.1 변경사항</summary>
 
 - **🔧 마크다운 렌더링 개선** — GFM 특수문자(`~`) 이스케이프로 취소선 오해석 방지, 테이블 셀 내 `|` 문자 이스케이프, 중첩 테이블 텍스트 구분자 `|` → `/` 변경으로 GFM 파서 충돌 방지.
 - **📝 문단 간격 정상화** — paragraph 블록 사이 빈 줄 삽입으로 마크다운에서 별도 문단으로 렌더링.
 
+</details>
+
 <details>
 <summary>v2.2.0 변경사항</summary>
 
@@ -186,6 +198,26 @@ if (result.success) {
 }
 ```
 
+### 양식 자동 채우기
+
+```typescript
+import { fillForm } from "kordoc"
+import { readFileSync, writeFileSync } from "fs"
+
+const template = readFileSync("신청서.hwpx")
+
+// HWPX 원본 서식 보존 모드 — 글꼴, 크기, 정렬 100% 유지
+const result = await fillForm(template.buffer, {
+  성명: "홍길동",
+  주민등록번호: "900101-1234567",
+  주소: "서울특별시 광진구 능동로 120",
+}, { format: "hwpx-preserve" })
+
+writeFileSync("신청서_작성완료.hwpx", Buffer.from(result.buffer!))
+// result.filled → [{ label: "성명", value: "홍길동" }, ...]
+// result.unmatched → 매칭 실패한 키 목록
+```
+
 ### HWPX 생성 (역변환)
 
 ```typescript
@@ -220,6 +252,9 @@ npx kordoc 보고서.hwp -o 보고서.md                  # 파일 저장
 npx kordoc *.pdf -d ./변환결과/                     # 일괄 변환
 npx kordoc 검토서.hwpx --format json               # JSON (blocks + metadata 포함)
 npx kordoc 보고서.hwpx --pages 1-3                  # 페이지 범위
+npx kordoc fill 신청서.hwpx -f '성명=홍길동,주소=서울' -o 결과.hwpx  # 양식 채우기
+npx kordoc fill 신청서.hwpx -j values.json -o 결과.hwpx             # JSON 파일로 채우기
+npx kordoc fill 신청서.hwpx --dry-run                               # 필드 목록만 확인
 npx kordoc watch ./수신함 -d ./변환결과              # 폴더 감시 모드
 npx kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
 ```
@@ -231,13 +266,13 @@ npx kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
   "mcpServers": {
     "kordoc": {
       "command": "npx",
-      "args": ["-y", "kordoc-mcp"]
+      "args": ["-y", "kordoc", "mcp"]
     }
   }
 }
 ```
 
-**7개 도구:**
+**8개 도구:**
 
 | 도구 | 설명 |
 |------|------|
@@ -248,6 +283,7 @@ npx kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
 | `parse_table` | N번째 테이블만 추출 |
 | `compare_documents` | 두 문서 비교 (크로스 포맷) |
 | `parse_form` | 양식 필드를 JSON으로 추출 |
+| `fill_form` | 양식 템플릿에 값 채우기 (HWPX 원본 서식 보존) |
 
 ## API
 
@@ -269,6 +305,9 @@ npx kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
 |------|------|
 | `compare(bufferA, bufferB, options?)` | IR 레벨 문서 비교 |
 | `extractFormFields(blocks)` | IRBlock[]에서 양식 필드 인식 |
+| `fillForm(buffer, values, options?)` | 양식 템플릿에 값 채우기 (markdown/hwpx/hwpx-preserve) |
+| `fillFormFields(blocks, values)` | IRBlock[] 기반 필드 값 교체 |
+| `fillHwpx(buffer, values)` | HWPX XML 직접 조작 (원본 서식 보존) |
 | `markdownToHwpx(markdown)` | Markdown → HWPX 역변환 |
 | `blocksToMarkdown(blocks)` | IRBlock[] → Markdown 문자열 |
 
@@ -280,7 +319,7 @@ import type {
   IRBlock, IRTable, IRCell, CellContext,
   DocumentMetadata, ParseOptions, ErrorCode,
   DiffResult, BlockDiff, CellDiff, DiffChangeType,
-  FormField, FormResult,
+  FormField, FormResult, FillResult, HwpxFillResult, FillOutputFormat,
   OcrProvider, WatchOptions,
 } from "kordoc"
 ```

package/dist/chunk-FCQEF2ZM.js

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+
+// src/utils.ts
+var VERSION = true ? "2.2.6" : "0.0.0-dev";
+function toArrayBuffer(buf) {
+  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+var KordocError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KordocError";
+  }
+};
+function sanitizeError(err) {
+  if (err instanceof KordocError) return err.message;
+  return "\uBB38\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4";
+}
+function isPathTraversal(name) {
+  if (name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  return segments.some((s) => s === "..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
+}
+function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
+  try {
+    const data = new DataView(buffer);
+    const len = buffer.byteLength;
+    let eocdOffset = -1;
+    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
+      if (data.getUint32(i, true) === 101010256) {
+        eocdOffset = i;
+        break;
+      }
+    }
+    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
+    const entryCount = data.getUint16(eocdOffset + 10, true);
+    if (entryCount > maxEntries) {
+      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
+    }
+    const cdSize = data.getUint32(eocdOffset + 12, true);
+    const cdOffset = data.getUint32(eocdOffset + 16, true);
+    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
+    let totalUncompressed = 0;
+    let pos = cdOffset;
+    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
+      if (data.getUint32(pos, true) !== 33639248) break;
+      totalUncompressed += data.getUint32(pos + 24, true);
+      const nameLen = data.getUint16(pos + 28, true);
+      const extraLen = data.getUint16(pos + 30, true);
+      const commentLen = data.getUint16(pos + 32, true);
+      pos += 46 + nameLen + extraLen + commentLen;
+    }
+    if (totalUncompressed > maxUncompressedSize) {
+      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
+    }
+    return { totalUncompressed, entryCount };
+  } catch (err) {
+    if (err instanceof KordocError) throw err;
+    return { totalUncompressed: 0, entryCount: 0 };
+  }
+}
+function stripDtd(xml) {
+  return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
+}
+var SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
+function sanitizeHref(href) {
+  const trimmed = href.trim();
+  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
+  return trimmed;
+}
+function safeMin(arr) {
+  let min = Infinity;
+  for (let i = 0; i < arr.length; i++) if (arr[i] < min) min = arr[i];
+  return min;
+}
+function safeMax(arr) {
+  let max = -Infinity;
+  for (let i = 0; i < arr.length; i++) if (arr[i] > max) max = arr[i];
+  return max;
+}
+function classifyError(err) {
+  if (!(err instanceof Error)) return "PARSE_ERROR";
+  const msg = err.message;
+  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
+  if (msg.includes("DRM")) return "DRM_PROTECTED";
+  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
+  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
+  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
+  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
+  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
+  return "PARSE_ERROR";
+}
+
+// src/table/builder.ts
+var MAX_COLS = 200;
+var MAX_ROWS = 1e4;
+function buildTable(rows) {
+  if (rows.length > MAX_ROWS) rows = rows.slice(0, MAX_ROWS);
+  const numRows = rows.length;
+  const hasAddr = rows.some((row) => row.some((c) => c.colAddr !== void 0 && c.rowAddr !== void 0));
+  if (hasAddr) return buildTableDirect(rows, numRows);
+  let maxCols = 0;
+  const tempOccupied = Array.from({ length: numRows }, () => []);
+  for (let rowIdx = 0; rowIdx < numRows; rowIdx++) {
+    let colIdx = 0;
+    for (const cell of rows[rowIdx]) {
+      while (colIdx < MAX_COLS && tempOccupied[rowIdx][colIdx]) colIdx++;
+      if (colIdx >= MAX_COLS) break;
+      for (let r = rowIdx; r < Math.min(rowIdx + cell.rowSpan, numRows); r++) {
+        for (let c = colIdx; c < Math.min(colIdx + cell.colSpan, MAX_COLS); 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 trimAndReturn(grid, numRows, maxCols);
+}
+function buildTableDirect(rows, numRows) {
+  let maxCols = 0;
+  for (const row of rows) {
+    for (const cell of row) {
+      const end = (cell.colAddr ?? 0) + cell.colSpan;
+      if (end > maxCols) maxCols = end;
+    }
+  }
+  if (maxCols > MAX_COLS) maxCols = MAX_COLS;
+  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 }))
+  );
+  for (const row of rows) {
+    for (const cell of row) {
+      const r = cell.rowAddr ?? 0;
+      const c = cell.colAddr ?? 0;
+      if (r >= numRows || c >= maxCols || r < 0 || c < 0) continue;
+      grid[r][c] = { text: cell.text.trim(), colSpan: cell.colSpan, rowSpan: cell.rowSpan };
+      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 < maxCols) {
+            grid[r + dr][c + dc] = { text: "", colSpan: 1, rowSpan: 1 };
+          }
+        }
+      }
+    }
+  }
+  return trimAndReturn(grid, numRows, maxCols);
+}
+function trimAndReturn(grid, numRows, maxCols) {
+  let effectiveCols = maxCols;
+  while (effectiveCols > 0) {
+    const colEmpty = grid.every((row) => !row[effectiveCols - 1]?.text?.trim());
+    if (!colEmpty) break;
+    effectiveCols--;
+  }
+  if (effectiveCols < maxCols && effectiveCols > 0) {
+    const trimmed = grid.map((row) => row.slice(0, effectiveCols));
+    return { rows: numRows, cols: effectiveCols, cells: trimmed, hasHeader: numRows > 1 };
+  }
+  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, " ").replace(/\|/g, "\\|")).filter(Boolean).join(" / ")
+  ).filter(Boolean).join("\n");
+}
+function escapeGfm(text) {
+  return text.replace(/~/g, "\\~");
+}
+var HWP_SHAPE_ALT_TEXT_RE = /(?:모서리가 둥근 |둥근 )?(?:사각형|직사각형|정사각형|원|타원|삼각형|이등변 삼각형|직각 삼각형|선|직선|곡선|화살표|굵은 화살표|이중 화살표|오각형|육각형|팔각형|별|[4-8]점별|십자|십자형|구름|구름형|마름모|도넛|평행사변형|사다리꼴|부채꼴|호|반원|물결|번개|하트|빗금|블록 화살표|수식|표|그림|개체|그리기\s?개체|묶음\s?개체|글상자|수식\s?개체|OLE\s?개체)\s?입니다\.?/g;
+function sanitizeText(text) {
+  let result = text.replace(/[\u{F0000}-\u{FFFFD}]/gu, "").replace(HWP_SHAPE_ALT_TEXT_RE, "").replace(/  +/g, " ").trim();
+  if (result.length <= 30 && result.includes(" ")) {
+    const tokens = result.split(" ");
+    const koreanSingleCharCount = tokens.filter((t) => t.length === 1 && /[\uAC00-\uD7AF\u3131-\u318E]/.test(t)).length;
+    if (tokens.length >= 3 && koreanSingleCharCount / tokens.length >= 0.7) {
+      result = tokens.join("");
+    }
+  }
+  return result;
+}
+function flattenLayoutTables(blocks) {
+  const result = [];
+  for (const block of blocks) {
+    if (block.type !== "table" || !block.table) {
+      result.push(block);
+      continue;
+    }
+    const { rows: numRows, cols: numCols, cells } = block.table;
+    if (numRows === 1 && numCols === 1) {
+      result.push(block);
+      continue;
+    }
+    if (numRows <= 3) {
+      let totalNewlines = 0;
+      let totalTextLen = 0;
+      for (let r = 0; r < numRows; r++) {
+        for (let c = 0; c < numCols; c++) {
+          const t = cells[r]?.[c]?.text || "";
+          totalNewlines += (t.match(/\n/g) || []).length;
+          totalTextLen += t.length;
+        }
+      }
+      if (totalNewlines > 5 || numRows <= 2 && totalTextLen > 300) {
+        for (let r = 0; r < numRows; r++) {
+          for (let c = 0; c < numCols; c++) {
+            const cellText = cells[r]?.[c]?.text?.trim();
+            if (!cellText) continue;
+            for (const line of cellText.split("\n")) {
+              const trimmed = line.trim();
+              if (!trimmed) continue;
+              result.push({ type: "paragraph", text: trimmed, pageNumber: block.pageNumber });
+            }
+          }
+        }
+        continue;
+      }
+    }
+    result.push(block);
+  }
+  return result;
+}
+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));
+      const headingText = sanitizeText(block.text);
+      if (headingText) lines.push("", `${prefix} ${headingText}`, "");
+      continue;
+    }
+    if (block.type === "image" && block.text) {
+      lines.push("", `![image](${block.text})`, "");
+      continue;
+    }
+    if (block.type === "separator") {
+      lines.push("", "---", "");
+      continue;
+    }
+    if (block.type === "list" && block.text) {
+      const listText = sanitizeText(block.text);
+      if (!listText) continue;
+      const alreadyNumbered = block.listType === "ordered" && /^\d+\.\s/.test(listText);
+      const prefix = alreadyNumbered ? "" : block.listType === "ordered" ? "1. " : "- ";
+      lines.push(`${prefix}${listText}`);
+      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) {
+      let text = sanitizeText(block.text);
+      if (!text) continue;
+      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;
+      }
+      if (block.href) {
+        const href = sanitizeHref(block.href);
+        if (href) text = `[${text}](${href})`;
+      }
+      if (block.footnoteText) {
+        text += ` (\uC8FC: ${block.footnoteText})`;
+      }
+      lines.push(escapeGfm(text), "");
+    } else if (block.type === "table" && block.table) {
+      if (lines.length > 0 && lines[lines.length - 1] !== "") {
+        lines.push("");
+      }
+      const tableMd = tableToMarkdown(block.table);
+      if (tableMd) {
+        lines.push(tableMd);
+        lines.push("");
+      }
+    }
+  }
+  return lines.join("\n").trim();
+}
+function hasMergedCells(table) {
+  for (const row of table.cells) {
+    for (const cell of row) {
+      if (cell.colSpan > 1 || cell.rowSpan > 1) return true;
+    }
+  }
+  return false;
+}
+function tableToHtml(table) {
+  const { cells, rows: numRows, cols: numCols } = table;
+  const skip = /* @__PURE__ */ new Set();
+  const lines = ["<table>"];
+  for (let r = 0; r < numRows; r++) {
+    const tag = r === 0 ? "th" : "td";
+    const rowHtml = [];
+    for (let c = 0; c < numCols; c++) {
+      if (skip.has(`${r},${c}`)) continue;
+      const cell = cells[r]?.[c];
+      if (!cell) continue;
+      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 text = sanitizeText(cell.text).replace(/\n/g, "<br>");
+      const attrs = [];
+      if (cell.colSpan > 1) attrs.push(`colspan="${cell.colSpan}"`);
+      if (cell.rowSpan > 1) attrs.push(`rowspan="${cell.rowSpan}"`);
+      const attrStr = attrs.length ? " " + attrs.join(" ") : "";
+      rowHtml.push(`<${tag}${attrStr}>${text}</${tag}>`);
+    }
+    if (rowHtml.length) lines.push(`<tr>${rowHtml.join("")}</tr>`);
+  }
+  lines.push("</table>");
+  return lines.join("\n");
+}
+function tableToMarkdown(table) {
+  if (table.rows === 0 || table.cols === 0) return "";
+  const { cells, rows: numRows, cols: numCols } = table;
+  if (hasMergedCells(table)) return tableToHtml(table);
+  if (numRows === 1 && numCols === 1) {
+    const content = sanitizeText(cells[0][0].text);
+    if (!content) return "";
+    return content.split(/\n/).map((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return "";
+      if (/^\d+\.\s/.test(trimmed)) return `**${escapeGfm(trimmed)}**`;
+      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${escapeGfm(trimmed)}`;
+      return escapeGfm(trimmed);
+    }).filter(Boolean).join("\n");
+  }
+  if (numCols === 1 && numRows >= 2) {
+    return cells.map((row) => escapeGfm(sanitizeText(row[0].text)).replace(/\n/g, " ")).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];
+      if (!cell) continue;
+      display[r][c] = escapeGfm(sanitizeText(cell.text)).replace(/\|/g, "\\|").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}`);
+          }
+        }
+      }
+      c += cell.colSpan - 1;
+    }
+  }
+  const uniqueRows = [];
+  let pendingFirstCol = "";
+  for (let r = 0; r < display.length; r++) {
+    const row = display[r];
+    const isEmptyPlaceholder = row.every((cell) => cell === "");
+    if (isEmptyPlaceholder) continue;
+    const nonEmptyCols = row.filter((cell) => cell !== "");
+    const hasSkipInRow = row.some((_, c) => skip.has(`${r},${c}`));
+    if (!hasSkipInRow && nonEmptyCols.length === 1 && row[0] !== "" && row.slice(1).every((c) => c === "")) {
+      pendingFirstCol = row[0];
+      continue;
+    }
+    if (pendingFirstCol && row[0] === "") {
+      row[0] = pendingFirstCol;
+      pendingFirstCol = "";
+    } else {
+      pendingFirstCol = "";
+    }
+    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/types.ts
+var HEADING_RATIO_H1 = 1.5;
+var HEADING_RATIO_H2 = 1.3;
+var HEADING_RATIO_H3 = 1.15;
+
+export {
+  VERSION,
+  toArrayBuffer,
+  KordocError,
+  sanitizeError,
+  isPathTraversal,
+  precheckZipSize,
+  stripDtd,
+  sanitizeHref,
+  safeMin,
+  safeMax,
+  classifyError,
+  MAX_COLS,
+  MAX_ROWS,
+  buildTable,
+  convertTableToText,
+  flattenLayoutTables,
+  blocksToMarkdown,
+  HEADING_RATIO_H1,
+  HEADING_RATIO_H2,
+  HEADING_RATIO_H3
+};
+//# sourceMappingURL=chunk-FCQEF2ZM.js.map