kordoc 4.12.2 → 4.13.0

package/dist/{chunk-IOJX4Q63.js → chunk-T7AFLXGA.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  parsePageRange
+} from "./chunk-MOL7MDBG.js";
 import {
   DEFAULT_CHAR,
   DEFAULT_PARA_GEOM,
@@ -7,11 +10,19 @@ import {
   createXmlParser,
   findChildByLocalName,
   parseRenderStyles
-} from "./chunk-FVBR7SC3.js";
+} from "./chunk-6JXMIX3G.js";
+import {
+  blocksToMarkdown
+} from "./chunk-GWFX5ZD7.js";
+import {
+  loadSharp,
+  rasterizePageSvg
+} from "./chunk-BQLZOQES.js";
 import {
   KordocError,
-  precheckZipSize
-} from "./chunk-FBLMVHDK.js";
+  precheckZipSize,
+  toArrayBuffer
+} from "./chunk-27QN27I3.js";
 
 // src/render/svg-render.ts
 import JSZip from "jszip";
@@ -251,13 +262,29 @@ var SPACE_EM_FONT = 300;
 function faceClassOf(face) {
   return face && /^(굴림체|돋움체|바탕체|궁서체)$/.test(face.trim()) ? "fixedPitch" : "hcr";
 }
+function faceClassForGen(face) {
+  if (!face) return "hcr";
+  const f = face.trim();
+  if (/^(굴림체|돋움체|바탕체|궁서체)$/.test(f)) return "fixedPitch";
+  if (/^(한컴돋움|맑은 고딕|HY견고딕|HY헤드라인M|HY중고딕|한양중고딕|나눔고딕|나눔스퀘어|돋움|굴림)$/.test(f)) return "gothic";
+  return "hcr";
+}
+function gothicWidthEm1000(cp) {
+  if (cp >= 128) return 1e3;
+  if (cp >= 65 && cp <= 90) return 720;
+  if (cp >= 97 && cp <= 122) return 560;
+  if (cp >= 48 && cp <= 57) return 580;
+  if (cp === 40 || cp === 41 || cp === 91 || cp === 93) return 350;
+  if (cp === 46 || cp === 44 || cp === 58 || cp === 59 || cp === 39) return 280;
+  return 500;
+}
 function fixedPitchWidthEm1000(cp) {
   return cp < 128 ? 500 : 1e3;
 }
 function measureTextWidth(text, height, ratioPct, opts) {
   const spaceEm = opts?.spaceEm ?? SPACE_EM_FIXED;
   const spacing = opts?.spacingPct ?? 0;
-  const widthEm = opts?.faceClass === "fixedPitch" ? fixedPitchWidthEm1000 : charWidthEm1000;
+  const widthEm = opts?.faceClass === "fixedPitch" ? fixedPitchWidthEm1000 : opts?.faceClass === "gothic" ? gothicWidthEm1000 : charWidthEm1000;
   let em = 0;
   for (const ch of text) {
     const cp = ch.codePointAt(0);
@@ -272,7 +299,7 @@ function simulateWrap(text, firstWidth, contWidth, height, ratioPct, mode = "kee
   const EPS = 0.5;
   const spaceEm = opts?.spaceEm ?? SPACE_EM_FIXED;
   const spacing = opts?.spacingPct ?? 0;
-  const widthEm = opts?.faceClass === "fixedPitch" ? fixedPitchWidthEm1000 : charWidthEm1000;
+  const widthEm = opts?.faceClass === "fixedPitch" ? fixedPitchWidthEm1000 : opts?.faceClass === "gothic" ? gothicWidthEm1000 : charWidthEm1000;
   const k = height * ratioPct / 100 / 1e3;
   const cwCp = (cp) => (cp === 32 ? spaceEm : widthEm(cp)) * (1 + spacing / 100) * k;
   const charW2 = (ch) => cwCp(ch.codePointAt(0));
@@ -534,6 +561,36 @@ function reflowSection(root, styles, geom, mode = "keep") {
   return counter.n;
 }
 
+// src/render/scene.ts
+function regionId(type, seq) {
+  return `${type}-${String(seq).padStart(6, "0")}`;
+}
+function unionBBox(a, b) {
+  const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+  return { page: a.page, x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+var RegionCollector = class {
+  regions = [];
+  counters = /* @__PURE__ */ new Map();
+  add(type, bbox, extra = {}) {
+    const seq = (this.counters.get(type) ?? 0) + 1;
+    this.counters.set(type, seq);
+    const id = regionId(type, seq);
+    const region = { id, type, page: bbox.page, regions: [bbox] };
+    if (extra.sourceId) region.sourceId = extra.sourceId;
+    if (extra.parentId) region.parentId = extra.parentId;
+    this.regions.push(region);
+    return id;
+  }
+  addFragment(id, bbox) {
+    const r = this.regions.find((x) => x.id === id);
+    if (!r) return;
+    const same = r.regions.find((f) => f.page === bbox.page);
+    if (same) Object.assign(same, unionBBox(same, bbox));
+    else r.regions.push(bbox);
+  }
+};
+
 // src/render/svg-render.ts
 function ln2(el) {
   return (el.tagName || "").replace(/^[^:]+:/, "");
@@ -564,6 +621,20 @@ function escapeXml(s) {
 }
 var OBJ_TAGS = /* @__PURE__ */ new Set(["tbl", "pic", "container", "equation", "rect", "ellipse", "polygon", "curv", "line", "arc", "ole", "textart"]);
 var pt = (u) => String(Math.round(u) / 100);
+var ptNum = (u) => Math.round(u) / 100;
+function pageNo(ctx) {
+  return ctx.pageBase + ctx.page + 1;
+}
+function bboxOf(ctx, x, y, w, h) {
+  const clippedH = Math.max(0, Math.min(h, ctx.pageH - y));
+  return { page: pageNo(ctx), x: ptNum(x), y: ptNum(y), width: ptNum(Math.max(0, w)), height: ptNum(clippedH) };
+}
+function regionOpenTag(id, type, page) {
+  return `<g data-kordoc-id="${id}" data-kordoc-type="${type}" data-kordoc-page="${page}">`;
+}
+function parentId(ctx) {
+  return ctx.parentStack.length ? ctx.parentStack[ctx.parentStack.length - 1] : void 0;
+}
 function emit(ctx, s) {
   ctx.pages[ctx.page].push(s);
 }
@@ -704,10 +775,23 @@ function drawPara(p, ox, oy, areaW, ctx, depth, segPages) {
   }
   const plans = planLines(m, ctx.styles);
   const baseV = m.segs[0].vertpos;
+  const hasText = m.chars.some((c) => c.ch !== "" && c.ch.trim() !== "");
+  let paraRegionId = null;
+  let gOpenOn = -1;
   for (let li = 0; li < plans.length; li++) {
     const plan = plans[li];
     if (segPages && segPages[li] !== void 0) ctx.page = segPages[li];
     const { seg } = plan;
+    if (hasText) {
+      const lineBox = bboxOf(ctx, ox + seg.horzpos, oy + seg.vertpos, seg.horzsize, seg.textheight);
+      if (paraRegionId === null) paraRegionId = ctx.regions.add("paragraph", lineBox, { parentId: parentId(ctx) });
+      else ctx.regions.addFragment(paraRegionId, lineBox);
+      if (gOpenOn !== ctx.page) {
+        if (gOpenOn >= 0) ctx.pages[gOpenOn].push("</g>");
+        emit(ctx, regionOpenTag(paraRegionId, "paragraph", pageNo(ctx)));
+        gOpenOn = ctx.page;
+      }
+    }
     let i = plan.start;
     let cursor = ox + seg.horzpos + plan.xoff;
     const y = oy + seg.vertpos + seg.baseline;
@@ -788,6 +872,8 @@ function drawPara(p, ox, oy, areaW, ctx, depth, segPages) {
       i = j;
     }
   }
+  if (gOpenOn >= 0) ctx.pages[gOpenOn].push("</g>");
+  if (paraRegionId) ctx.parentStack.push(paraRegionId);
   for (const o of m.objs) {
     if (o.inline) {
       let planIdx = 0;
@@ -806,6 +892,7 @@ function drawPara(p, ox, oy, areaW, ctx, depth, segPages) {
       drawObject(o, x, y, baseV, areaW, ctx, depth);
     }
   }
+  if (paraRegionId) ctx.parentStack.pop();
 }
 function anchorObject(o, ox, oy, baseV, areaW, ctx) {
   const { PW, PH, ML, MT, BODY_W, BODY_H } = ctx.geom;
@@ -888,6 +975,10 @@ function drawShape(o, x, y, ctx, depth) {
   const face = winBrush?.getAttribute("faceColor");
   const fill = face && face.toLowerCase() !== "none" ? face : "none";
   const fillAttr = ` fill="${fill === "none" ? "none" : escapeXml(fill)}"`;
+  ctx.stats.shapes++;
+  const shapeId = ctx.regions.add("shape", bboxOf(ctx, x, y, w, h), { parentId: parentId(ctx) });
+  emit(ctx, regionOpenTag(shapeId, "shape", pageNo(ctx)));
+  ctx.parentStack.push(shapeId);
   if (o.tag === "rect") {
     emit(ctx, `<rect x="${pt(x)}" y="${pt(y)}" width="${pt(w)}" height="${pt(h)}"${fillAttr}${strokeAttr}/>`);
   } else if (o.tag === "ellipse") {
@@ -909,6 +1000,8 @@ function drawShape(o, x, y, ctx, depth) {
   if (sub) {
     for (const p of elements2(sub)) if (ln2(p) === "p") drawPara(p, x, y, w, ctx, depth + 1);
   }
+  ctx.parentStack.pop();
+  emit(ctx, "</g>");
 }
 function cellContentExtent(cell, memo) {
   if (!cell.sub) return 0;
@@ -1009,6 +1102,11 @@ function drawTable(tbl, tx, ty, ctx, depth) {
   );
   const rowY = [0];
   for (let r = 0; r < nRows; r++) rowY.push(rowY[r] + rowH[r]);
+  const tblH = rowY[nRows];
+  if (ty + tblH > ctx.pageH + 100) warnOnce(ctx, "table-split", "\uD398\uC774\uC9C0\uC5D0 \uAC78\uCE5C \uD45C \u2014 \uBD84\uD560 \uC9C0\uC624\uBA54\uD2B8\uB9AC\uAC00 \uC5C6\uC5B4 \uC2DC\uC791 \uD398\uC774\uC9C0 \uC601\uC5ED\uB9CC region \uC73C\uB85C \uAE30\uB85D");
+  const tblId = ctx.regions.add("table", bboxOf(ctx, tx, ty, colX[nCols], tblH), { sourceId: tbl.getAttribute("id") ?? void 0, parentId: parentId(ctx) });
+  emit(ctx, regionOpenTag(tblId, "table", pageNo(ctx)));
+  ctx.parentStack.push(tblId);
   const geom = cells.map((c) => ({
     c,
     x: tx + colX[c.ca],
@@ -1042,6 +1140,8 @@ function drawTable(tbl, tx, ty, ctx, depth) {
     if (bf.left) emit(ctx, edgeLine(g.x, g.y, g.x, g.y + g.h, bf.left));
     if (bf.right) emit(ctx, edgeLine(g.x + g.w, g.y, g.x + g.w, g.y + g.h, bf.right));
   }
+  ctx.parentStack.pop();
+  emit(ctx, "</g>");
 }
 function imageSymbol(loaded, ctx) {
   if (!loaded.symId) {
@@ -1058,9 +1158,12 @@ function drawPic(pic, x, y, ctx) {
   const img = findFirst(pic, "img");
   const ref = img?.getAttribute("binaryItemIDRef");
   const loaded = ref != null ? ctx.images.get(ref) : void 0;
+  const imgId = ctx.regions.add("image", bboxOf(ctx, x, y, w, h), { sourceId: ref ?? void 0, parentId: parentId(ctx) });
+  emit(ctx, regionOpenTag(imgId, "image", pageNo(ctx)));
   if (!loaded) {
     emit(ctx, `<rect x="${pt(x)}" y="${pt(y)}" width="${pt(w)}" height="${pt(h)}" fill="#eee" stroke="#c00" stroke-width="0.5"/>`);
     warnOnce(ctx, `img:${ref}`, `\uC774\uBBF8\uC9C0 \uBC14\uC774\uB108\uB9AC \uB204\uB77D: ${ref ?? "(ref \uC5C6\uC74C)"}`);
+    emit(ctx, "</g>");
     return;
   }
   ctx.stats.images++;
@@ -1082,6 +1185,7 @@ function drawPic(pic, x, y, ctx) {
   } else {
     emit(ctx, `<use href="#${symId}" x="${pt(x)}" y="${pt(y)}" width="${pt(w)}" height="${pt(h)}"/>`);
   }
+  emit(ctx, "</g>");
 }
 function sniffMime(name, bytes) {
   const lower = name.toLowerCase();
@@ -1140,20 +1244,22 @@ function renderSectionToPages(root, geom, ctxBase, doReflow, reflowMode) {
       nPages = Math.max(nPages, cur + 1);
     }
   }
+  const pageH = nPages === 1 ? Math.max(PH, MT + maxTopV + 2e3) : PH;
   const ctx = {
     ...ctxBase,
     pages: Array.from({ length: nPages }, () => []),
     page: 0,
-    geom
+    geom,
+    pageH
   };
   for (const p of elements2(root)) {
     if (ln2(p) !== "p") continue;
     drawPara(p, ML, MT, BODY_W, ctx, 0, paraSegPages.get(p));
   }
-  const pageH = nPages === 1 ? Math.max(PH, MT + maxTopV + 2e3) : PH;
   return { pages: ctx.pages, pageH };
 }
-async function renderHwpxToSvg(input, options) {
+var SVG_FONT_FAMILY = `'HCR Batang','\uD568\uCD08\uB86C\uBC14\uD0D5','Hancom Batang',AppleMyungjo,'Noto Serif CJK KR',serif`;
+async function renderHwpxInternal(input, options) {
   const maxImg = options?.maxImageBytes ?? 40 * 1024 * 1024;
   const ab = input instanceof Uint8Array ? input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength) : input;
   precheckZipSize(ab, MAX_DECOMPRESS_SIZE, MAX_ZIP_ENTRIES);
@@ -1220,8 +1326,11 @@ async function renderHwpxToSvg(input, options) {
     highlights: (options?.highlights ?? []).map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0),
     warnings,
     warned: /* @__PURE__ */ new Set(),
-    stats: { texts: 0, images: 0, tables: 0 },
-    extentMemo: { cell: /* @__PURE__ */ new WeakMap(), table: /* @__PURE__ */ new WeakMap() }
+    stats: { texts: 0, images: 0, tables: 0, shapes: 0 },
+    extentMemo: { cell: /* @__PURE__ */ new WeakMap(), table: /* @__PURE__ */ new WeakMap() },
+    regions: new RegionCollector(),
+    parentStack: [],
+    pageBase: 0
   };
   const rendered = [];
   let noCacheSkipped = false;
@@ -1242,6 +1351,7 @@ async function renderHwpxToSvg(input, options) {
     const geom = readSectionGeom(root);
     const { pages, pageH } = renderSectionToPages(root, geom, ctxBase, !!options?.reflow, options?.reflowMode ?? "keep");
     rendered.push({ pages, PW: geom.PW, pageH, clipId: `pgclip${si}` });
+    ctxBase.pageBase += pages.length;
   }
   if (rendered.length === 0) {
     if (noCacheSkipped) {
@@ -1249,19 +1359,23 @@ async function renderHwpxToSvg(input, options) {
     }
     throw new KordocError("\uB80C\uB354\uD560 \uAD6C\uC5ED\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 HWPX\uAC00 \uC190\uC0C1\uB418\uC5C8\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4");
   }
+  return { sections: rendered, defs: ctxBase.defs, warnings, stats: ctxBase.stats, regions: ctxBase.regions.regions };
+}
+async function renderHwpxToSvg(input, options) {
+  const r = await renderHwpxInternal(input, options);
   const GAP = 2400;
   const clipDefs = [];
   const groups = [];
   let y = 0;
   let maxPW = 0;
-  let pageNo = 0;
-  for (const rs of rendered) {
+  let pageNo2 = 0;
+  for (const rs of r.sections) {
     maxPW = Math.max(maxPW, rs.PW);
     clipDefs.push(`<clipPath id="${rs.clipId}"><rect x="0" y="0" width="${pt(rs.PW)}" height="${pt(rs.pageH)}"/></clipPath>`);
     for (const buf of rs.pages) {
-      pageNo++;
+      pageNo2++;
       groups.push(
-        `<g data-page="${pageNo}" transform="translate(0 ${pt(y)})"><rect width="${pt(rs.PW)}" height="${pt(rs.pageH)}" fill="white" stroke="#c9c7c4" stroke-width="0.75"/><g clip-path="url(#${rs.clipId})">
+        `<g data-page="${pageNo2}" transform="translate(0 ${pt(y)})"><rect width="${pt(rs.PW)}" height="${pt(rs.pageH)}" fill="white" stroke="#c9c7c4" stroke-width="0.75"/><g clip-path="url(#${rs.clipId})">
 ${buf.join("\n")}
 </g></g>`
       );
@@ -1269,21 +1383,674 @@ ${buf.join("\n")}
     }
   }
   const totalH = Math.max(0, y - GAP);
-  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pt(maxPW)} ${pt(totalH)}" width="${pt(maxPW)}pt" height="${pt(totalH)}pt" font-family="'HCR Batang','\uD568\uCD08\uB86C\uBC14\uD0D5','Hancom Batang',AppleMyungjo,'Noto Serif CJK KR',serif" xml:space="preserve">
-<defs>${clipDefs.join("")}${ctxBase.defs.join("")}</defs>
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pt(maxPW)} ${pt(totalH)}" width="${pt(maxPW)}pt" height="${pt(totalH)}pt" font-family="${SVG_FONT_FAMILY}" xml:space="preserve">
+<defs>${clipDefs.join("")}${r.defs.join("")}</defs>
 ${groups.join("\n")}
 </svg>`;
-  return { svg, width: Math.round(maxPW) / 100, height: Math.round(totalH) / 100, pageCount: pageNo, warnings, stats: ctxBase.stats };
+  return { svg, width: Math.round(maxPW) / 100, height: Math.round(totalH) / 100, pageCount: pageNo2, warnings: r.warnings, stats: r.stats, regions: r.regions };
+}
+async function renderHwpxPages(input, options, select) {
+  const r = await renderHwpxInternal(input, options);
+  const pages = [];
+  const pageSvgs = /* @__PURE__ */ new Map();
+  const pageCount = r.sections.reduce((n, rs) => n + rs.pages.length, 0);
+  const chosen = typeof select === "function" ? select(pageCount) : select;
+  let pageNo2 = 0;
+  for (const rs of r.sections) {
+    for (const buf of rs.pages) {
+      pageNo2++;
+      pages.push({ page: pageNo2, width: ptNum(rs.PW), height: ptNum(rs.pageH) });
+      if (chosen && !chosen.has(pageNo2)) continue;
+      const body = buf.join("\n");
+      const used = /* @__PURE__ */ new Set();
+      for (const m of body.matchAll(/href="#(bin\d+)"/g)) used.add(m[1]);
+      const defs = r.defs.filter((d) => {
+        const m = /<symbol id="(bin\d+)"/.exec(d);
+        return m ? used.has(m[1]) : true;
+      });
+      const clipId = `pgclip${pageNo2}`;
+      pageSvgs.set(
+        pageNo2,
+        `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pt(rs.PW)} ${pt(rs.pageH)}" width="${pt(rs.PW)}pt" height="${pt(rs.pageH)}pt" font-family="${SVG_FONT_FAMILY}" xml:space="preserve" data-page="${pageNo2}">
+<defs><clipPath id="${clipId}"><rect x="0" y="0" width="${pt(rs.PW)}" height="${pt(rs.pageH)}"/></clipPath>${defs.join("")}</defs>
+<rect width="${pt(rs.PW)}" height="${pt(rs.pageH)}" fill="white"/>
+<g clip-path="url(#${clipId})">
+${body}
+</g>
+</svg>`
+      );
+    }
+  }
+  const scene = { format: "hwpx", pages, regions: r.regions, warnings: r.warnings, stats: { texts: r.stats.texts, tables: r.stats.tables, images: r.stats.images, shapes: r.stats.shapes } };
+  return { scene, pageSvgs };
+}
+
+// src/render/document.ts
+import { readFile } from "fs/promises";
+
+// src/detect.ts
+import JSZip2 from "jszip";
+
+// src/hwp5/cfb-lenient.ts
+var CFB_MAGIC = Buffer.from([208, 207, 17, 224, 161, 177, 26, 225]);
+var END_OF_CHAIN = 4294967294;
+var FREE_SECT = 4294967295;
+var MAX_CHAIN_LENGTH = 1e6;
+var MAX_DIR_ENTRIES = 1e5;
+var MAX_STREAM_SIZE = 100 * 1024 * 1024;
+function parseLenientCfb(data) {
+  if (data.length < 512) throw new Error("CFB \uD30C\uC77C\uC774 \uB108\uBB34 \uC9E7\uC2B5\uB2C8\uB2E4 (\uCD5C\uC18C 512\uBC14\uC774\uD2B8)");
+  if (!data.subarray(0, 8).equals(CFB_MAGIC)) throw new Error("CFB \uB9E4\uC9C1 \uBC14\uC774\uD2B8 \uBD88\uC77C\uCE58");
+  const sectorSizeShift = data.readUInt16LE(30);
+  if (sectorSizeShift < 7 || sectorSizeShift > 16) throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC139\uD130 \uD06C\uAE30 \uC2DC\uD504\uD2B8: " + sectorSizeShift);
+  const sectorSize = 1 << sectorSizeShift;
+  const miniSectorSizeShift = data.readUInt16LE(32);
+  if (miniSectorSizeShift > 16) throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBBF8\uB2C8 \uC139\uD130 \uD06C\uAE30 \uC2DC\uD504\uD2B8: " + miniSectorSizeShift);
+  const miniSectorSize = 1 << miniSectorSizeShift;
+  const headerFatSectorCount = data.readUInt32LE(44);
+  if (headerFatSectorCount > 1e4) throw new Error("FAT \uC139\uD130 \uC218\uAC00 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4: " + headerFatSectorCount);
+  const maxRealSectors = Math.ceil(Math.max(0, data.length - 512) / sectorSize);
+  const maxFatSectors = Math.max(1, Math.ceil(maxRealSectors / (sectorSize / 4)));
+  const fatSectorCount = Math.min(headerFatSectorCount, maxFatSectors);
+  const firstDirSector = data.readUInt32LE(48);
+  const miniStreamCutoff = data.readUInt32LE(56);
+  const firstMiniFatSector = data.readUInt32LE(60);
+  const miniFatSectorCount = data.readUInt32LE(64);
+  const firstDifatSector = data.readUInt32LE(68);
+  const difatSectorCount = data.readUInt32LE(72);
+  function sectorOffset(id) {
+    return 512 + id * sectorSize;
+  }
+  function readSectorData(id) {
+    const off = sectorOffset(id);
+    if (off + sectorSize > data.length) return Buffer.alloc(0);
+    return data.subarray(off, off + sectorSize);
+  }
+  const fatSectors = [];
+  for (let i = 0; i < 109 && fatSectors.length < fatSectorCount; i++) {
+    const sid = data.readUInt32LE(76 + i * 4);
+    if (sid === FREE_SECT || sid === END_OF_CHAIN) break;
+    fatSectors.push(sid);
+  }
+  let difatSector = firstDifatSector;
+  const visitedDifat = /* @__PURE__ */ new Set();
+  for (let d = 0; d < difatSectorCount && difatSector !== END_OF_CHAIN && difatSector !== FREE_SECT; d++) {
+    if (visitedDifat.has(difatSector)) break;
+    visitedDifat.add(difatSector);
+    const buf = readSectorData(difatSector);
+    if (buf.length < sectorSize) break;
+    const entriesPerSector = sectorSize / 4 - 1;
+    for (let i = 0; i < entriesPerSector && fatSectors.length < fatSectorCount; i++) {
+      const sid = buf.readUInt32LE(i * 4);
+      if (sid === FREE_SECT || sid === END_OF_CHAIN) continue;
+      fatSectors.push(sid);
+    }
+    difatSector = buf.readUInt32LE(entriesPerSector * 4);
+  }
+  const entriesPerFatSector = sectorSize / 4;
+  const fatTable = new Uint32Array(fatSectors.length * entriesPerFatSector);
+  for (let fi = 0; fi < fatSectors.length; fi++) {
+    const buf = readSectorData(fatSectors[fi]);
+    for (let i = 0; i < entriesPerFatSector; i++) {
+      fatTable[fi * entriesPerFatSector + i] = i * 4 + 3 < buf.length ? buf.readUInt32LE(i * 4) : FREE_SECT;
+    }
+  }
+  function readChain(startSector, maxBytes) {
+    if (startSector === END_OF_CHAIN || startSector === FREE_SECT) return Buffer.alloc(0);
+    if (maxBytes > MAX_STREAM_SIZE) throw new Error("\uC2A4\uD2B8\uB9BC\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4");
+    const chunks = [];
+    let current = startSector;
+    let totalRead = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (current !== END_OF_CHAIN && current !== FREE_SECT && totalRead < maxBytes) {
+      if (visited.has(current)) break;
+      if (visited.size > MAX_CHAIN_LENGTH) break;
+      visited.add(current);
+      const buf = readSectorData(current);
+      const remaining = maxBytes - totalRead;
+      chunks.push(remaining < sectorSize ? buf.subarray(0, remaining) : buf);
+      totalRead += Math.min(buf.length, remaining);
+      current = current < fatTable.length ? fatTable[current] : END_OF_CHAIN;
+    }
+    return Buffer.concat(chunks);
+  }
+  let miniFatTable = null;
+  function getMiniFatTable() {
+    if (miniFatTable) return miniFatTable;
+    if (miniFatSectorCount === 0 || firstMiniFatSector === END_OF_CHAIN) {
+      miniFatTable = new Uint32Array(0);
+      return miniFatTable;
+    }
+    const miniFatData = readChain(firstMiniFatSector, miniFatSectorCount * sectorSize);
+    const entries = miniFatData.length / 4;
+    miniFatTable = new Uint32Array(entries);
+    for (let i = 0; i < entries; i++) {
+      miniFatTable[i] = miniFatData.readUInt32LE(i * 4);
+    }
+    return miniFatTable;
+  }
+  const dirData = readChain(firstDirSector, MAX_DIR_ENTRIES * 128);
+  const dirEntries = [];
+  for (let offset = 0; offset + 128 <= dirData.length && dirEntries.length < MAX_DIR_ENTRIES; offset += 128) {
+    const nameLen = dirData.readUInt16LE(offset + 64);
+    if (nameLen <= 0 || nameLen > 64) {
+      dirEntries.push({ name: "", type: 0, startSector: 0, size: 0 });
+      continue;
+    }
+    const nameBytes = nameLen - 2;
+    const name = nameBytes > 0 ? dirData.subarray(offset, offset + nameBytes).toString("utf16le") : "";
+    const type = dirData[offset + 66];
+    const startSector = dirData.readUInt32LE(offset + 116);
+    const size = dirData.readUInt32LE(offset + 120);
+    dirEntries.push({ name, type, startSector, size });
+  }
+  let miniStreamData = null;
+  function getMiniStream() {
+    if (miniStreamData) return miniStreamData;
+    const root = dirEntries[0];
+    if (!root || root.type !== 5) {
+      miniStreamData = Buffer.alloc(0);
+      return miniStreamData;
+    }
+    miniStreamData = readChain(root.startSector, root.size || MAX_STREAM_SIZE);
+    return miniStreamData;
+  }
+  function readMiniStream(startSector, size) {
+    const mft = getMiniFatTable();
+    const ms = getMiniStream();
+    if (mft.length === 0 || ms.length === 0) return Buffer.alloc(0);
+    const chunks = [];
+    let current = startSector;
+    let totalRead = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (current !== END_OF_CHAIN && current !== FREE_SECT && totalRead < size) {
+      if (visited.has(current)) break;
+      if (visited.size > MAX_CHAIN_LENGTH) break;
+      visited.add(current);
+      const off = current * miniSectorSize;
+      const remaining = size - totalRead;
+      const chunkSize = Math.min(miniSectorSize, remaining);
+      if (off + chunkSize <= ms.length) {
+        chunks.push(ms.subarray(off, off + chunkSize));
+      }
+      totalRead += chunkSize;
+      current = current < mft.length ? mft[current] : END_OF_CHAIN;
+    }
+    return Buffer.concat(chunks);
+  }
+  function readStreamData(entry) {
+    if (entry.size === 0) return Buffer.alloc(0);
+    if (entry.size < miniStreamCutoff) {
+      const miniResult = readMiniStream(entry.startSector, entry.size);
+      if (miniResult.length > 0) return miniResult;
+    }
+    return readChain(entry.startSector, entry.size);
+  }
+  function findEntryByPath(path) {
+    const parts = path.replace(/^\//, "").split("/");
+    if (parts.length === 1) {
+      return dirEntries.find((e) => e.name === parts[0] && e.type === 2) ?? null;
+    }
+    const storageName = parts[0];
+    const streamName = parts.slice(1).join("/");
+    for (const e of dirEntries) {
+      if (e.type === 2 && e.name === streamName) {
+        return e;
+      }
+    }
+    const lastPart = parts[parts.length - 1];
+    return dirEntries.find((e) => e.type === 2 && e.name === lastPart) ?? null;
+  }
+  return {
+    findStream(path) {
+      const normalized = path.replace(/^\//, "");
+      const entry = findEntryByPath(normalized);
+      if (!entry || entry.type !== 2) return null;
+      const stream = readStreamData(entry);
+      return stream.length > 0 ? stream : null;
+    },
+    entries() {
+      return dirEntries.filter((e) => e.type === 2);
+    }
+  };
+}
+
+// src/detect.ts
+function magicBytes(buffer) {
+  return new Uint8Array(buffer, 0, Math.min(4, buffer.byteLength));
+}
+function isZipFile(buffer) {
+  const b = magicBytes(buffer);
+  return b[0] === 80 && b[1] === 75 && b[2] === 3 && b[3] === 4;
+}
+function isHwpxFile(buffer) {
+  return isZipFile(buffer);
+}
+function isOldHwpFile(buffer) {
+  const b = magicBytes(buffer);
+  return b[0] === 208 && b[1] === 207 && b[2] === 17 && b[3] === 224;
+}
+var HWP3_PREFIX = new TextEncoder().encode("HWP Document File V3.00");
+function isHwp3File(buffer) {
+  if (buffer.byteLength < HWP3_PREFIX.length) return false;
+  const head = new Uint8Array(buffer, 0, HWP3_PREFIX.length);
+  for (let i = 0; i < HWP3_PREFIX.length; i++) {
+    if (head[i] !== HWP3_PREFIX[i]) return false;
+  }
+  return true;
+}
+function isPdfFile(buffer) {
+  const b = magicBytes(buffer);
+  return b[0] === 37 && b[1] === 80 && b[2] === 68 && b[3] === 70;
+}
+function isImageFile(buffer) {
+  if (buffer.byteLength < 12) return false;
+  const b = new Uint8Array(buffer, 0, 12);
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return true;
+  if (b[0] === 255 && b[1] === 216 && b[2] === 255) return true;
+  if (b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80) return true;
+  return false;
+}
+function isHwpmlFile(buffer) {
+  const bytes = new Uint8Array(buffer, 0, Math.min(512, buffer.byteLength));
+  const head = new TextDecoder("utf-8", { fatal: false }).decode(bytes).replace(/^\uFEFF/, "");
+  return head.trimStart().startsWith("<?xml") && head.includes("<HWPML");
+}
+function detectFormat(buffer) {
+  if (buffer.byteLength < 4) return "unknown";
+  if (isHwp3File(buffer)) return "hwp3";
+  if (isZipFile(buffer)) return "hwpx";
+  if (isOldHwpFile(buffer)) return "hwp";
+  if (isPdfFile(buffer)) return "pdf";
+  if (isHwpmlFile(buffer)) return "hwpml";
+  if (isImageFile(buffer)) return "image";
+  return "unknown";
+}
+function detectOle2Format(buffer) {
+  try {
+    const cfb = parseLenientCfb(Buffer.from(buffer));
+    const names = cfb.entries().map((e) => e.name);
+    if (names.includes("Workbook") || names.includes("Book")) return "xls";
+    if (names.includes("FileHeader")) return "hwp";
+    if (names.some((n) => n === "DocInfo" || n.startsWith("Section"))) return "hwp";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectZipFormat(buffer) {
+  try {
+    const zip = await JSZip2.loadAsync(buffer);
+    if (zip.file("xl/workbook.xml")) return "xlsx";
+    if (zip.file("word/document.xml")) return "docx";
+    if (zip.file("Contents/content.hpf") || zip.file("mimetype")) return "hwpx";
+    const hasSection = Object.keys(zip.files).some((f) => f.startsWith("Contents/"));
+    if (hasSection) return "hwpx";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/render/html.ts
+function renderSceneToHtml(scene, pageSvgs, options = {}) {
+  const title = escapeXml(options.title ?? "kordoc");
+  const first = scene.pages.find((p) => pageSvgs.has(p.page)) ?? scene.pages[0];
+  const pageSize = first ? `${first.width}pt ${first.height}pt` : "auto";
+  const pages = [...pageSvgs.keys()].sort((a, b) => a - b).map((n) => {
+    const meta = scene.pages.find((p) => p.page === n);
+    const size = meta ? ` style="width:${meta.width}pt;height:${meta.height}pt"` : "";
+    return `<div class="kordoc-page" data-page="${n}"${size}>${pageSvgs.get(n)}</div>`;
+  });
+  return `<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+html, body { margin: 0; background: #e9e8e6; }
+.kordoc-document { display: flex; flex-direction: column; align-items: center; gap: 16px; padding: 16px 0; }
+.kordoc-page { position: relative; background: white; box-shadow: 0 1px 4px rgba(0,0,0,.25); }
+.kordoc-page > svg { display: block; width: 100%; height: 100%; }
+@page { size: ${pageSize}; margin: 0; }
+@media print {
+  html, body { background: white; }
+  .kordoc-document { gap: 0; padding: 0; }
+  .kordoc-page { box-shadow: none; break-after: page; page-break-after: always; }
+  .kordoc-page:last-child { break-after: auto; page-break-after: auto; }
+}
+</style>
+</head>
+<body>
+<div class="kordoc-document">
+${pages.join("\n")}
+</div>
+</body>
+</html>
+`;
+}
+
+// src/print/renderer.ts
+import { existsSync } from "fs";
+import MarkdownIt from "markdown-it";
+var PRESETS = {
+  default: `
+    @page { size: A4; margin: 20mm; }
+    body { font-family: 'Pretendard', 'Malgun Gothic', '\uB9D1\uC740 \uACE0\uB515', sans-serif; font-size: 11pt; line-height: 1.6; color: #111; }
+    h1 { font-size: 20pt; margin: 1em 0 0.5em; }
+    h2 { font-size: 16pt; margin: 1em 0 0.4em; }
+    h3 { font-size: 13pt; margin: 0.8em 0 0.3em; }
+    p { margin: 0.4em 0; }
+    table { border-collapse: collapse; margin: 0.6em 0; width: 100%; }
+    th, td { border: 1px solid #555; padding: 4px 8px; text-align: left; vertical-align: top; }
+    th { background: #f0f0f0; }
+    code { background: #f5f5f5; padding: 1px 4px; border-radius: 2px; font-family: 'D2Coding', Consolas, monospace; }
+    pre { background: #f5f5f5; padding: 8px; border-radius: 4px; overflow-x: auto; }
+    blockquote { border-left: 3px solid #ccc; padding-left: 12px; color: #555; margin: 0.6em 0; }
+    img { max-width: 100%; }
+  `,
+  "gov-formal": `
+    @page { size: A4; margin: 25mm 20mm; }
+    body { font-family: '\uD568\uCD08\uB86C\uBC14\uD0D5', 'HCR Batang', 'Batang', 'Malgun Gothic', serif; font-size: 11pt; line-height: 1.7; color: #000; }
+    h1 { font-size: 18pt; text-align: center; margin: 0.5em 0 1em; letter-spacing: 0.05em; }
+    h2 { font-size: 14pt; margin: 1em 0 0.4em; border-bottom: 1px solid #999; padding-bottom: 2px; }
+    h3 { font-size: 12pt; margin: 0.8em 0 0.3em; }
+    p { margin: 0.3em 0; text-indent: 1em; }
+    table { border-collapse: collapse; margin: 0.8em 0; width: 100%; }
+    th, td { border: 1px solid #000; padding: 5px 8px; vertical-align: top; }
+    th { background: #e8e8e8; font-weight: normal; }
+    blockquote { border-left: 2px solid #555; padding-left: 12px; margin: 0.6em 0; }
+  `,
+  compact: `
+    @page { size: A4; margin: 10mm; }
+    body { font-family: 'Pretendard', 'Malgun Gothic', sans-serif; font-size: 9pt; line-height: 1.4; color: #111; }
+    h1 { font-size: 14pt; margin: 0.5em 0 0.3em; }
+    h2 { font-size: 12pt; margin: 0.5em 0 0.3em; }
+    h3 { font-size: 10pt; margin: 0.4em 0 0.2em; }
+    p { margin: 0.2em 0; }
+    table { border-collapse: collapse; margin: 0.3em 0; width: 100%; font-size: 8pt; }
+    th, td { border: 1px solid #777; padding: 2px 4px; }
+    th { background: #f0f0f0; }
+  `
+};
+var md = new MarkdownIt({
+  html: true,
+  linkify: true,
+  breaks: false
+});
+function renderHtml(markdown, options) {
+  const preset = options?.preset ?? "default";
+  const css = PRESETS[preset] + (options?.extraCss ?? "");
+  const body = md.render(markdown);
+  const watermark = options?.watermark ? `<div class="watermark">${escapeHtml(options.watermark)}</div>` : "";
+  const watermarkCss = options?.watermark ? `
+    .watermark {
+      position: fixed;
+      top: 50%; left: 50%;
+      transform: translate(-50%, -50%) rotate(-30deg);
+      font-size: 80pt;
+      color: rgba(0,0,0,0.08);
+      pointer-events: none;
+      z-index: 9999;
+      white-space: nowrap;
+    }` : "";
+  return `<!DOCTYPE html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<style>${css}${watermarkCss}</style>
+</head>
+<body>
+${watermark}
+${body}
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+async function htmlToPdf(html, options) {
+  let puppeteer;
+  try {
+    puppeteer = await import("puppeteer-core");
+  } catch {
+    throw new KordocError(
+      "PDF \uC0DD\uC131\uC5D0 puppeteer-core\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. \uC124\uCE58: npm install puppeteer-core"
+    );
+  }
+  const executablePath = process.env.PUPPETEER_EXECUTABLE_PATH ?? findChromiumPath();
+  if (!executablePath) {
+    throw new KordocError(
+      "Chromium \uC2E4\uD589 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. PUPPETEER_EXECUTABLE_PATH \uD658\uACBD\uBCC0\uC218\uB97C \uC124\uC815\uD558\uC138\uC694."
+    );
+  }
+  const browser = await puppeteer.default.launch({
+    executablePath,
+    headless: true,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: "networkidle0" });
+    const margin = options?.margin;
+    const pdf = await page.pdf({
+      format: options?.pageSize ?? "A4",
+      landscape: options?.orientation === "landscape",
+      printBackground: true,
+      margin: margin ? {
+        top: toCss(margin.top),
+        right: toCss(margin.right),
+        bottom: toCss(margin.bottom),
+        left: toCss(margin.left)
+      } : void 0,
+      displayHeaderFooter: !!(options?.header || options?.footer),
+      headerTemplate: options?.header ?? "<div></div>",
+      footerTemplate: options?.footer ?? '<div style="font-size:8pt;width:100%;text-align:center;color:#777;"><span class="pageNumber"></span>/<span class="totalPages"></span></div>'
+    });
+    return Buffer.from(pdf);
+  } finally {
+    await browser.close();
+  }
+}
+function toCss(v) {
+  return typeof v === "number" ? `${v}mm` : v;
+}
+function findChromiumPath() {
+  const win = [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    process.env.LOCALAPPDATA + "\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+  ];
+  const mac = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+  ];
+  const linux = ["/usr/bin/google-chrome", "/usr/bin/chromium-browser", "/usr/bin/chromium"];
+  const candidates = process.platform === "win32" ? win : process.platform === "darwin" ? mac : linux;
+  for (const p of candidates) {
+    if (p && existsSync(p)) return p;
+  }
+  return null;
+}
+async function markdownToPdf(markdown, options) {
+  const html = renderHtml(markdown, options);
+  return htmlToPdf(html, options);
+}
+async function blocksToPdf(blocks, options) {
+  const markdown = blocksToMarkdown(blocks);
+  return markdownToPdf(markdown, options);
+}
+
+// src/render/pdf.ts
+async function renderHtmlToPdf(html, options = {}) {
+  let puppeteer;
+  try {
+    puppeteer = await import("puppeteer-core");
+  } catch {
+    throw new KordocError("PDF \uB80C\uB354\uC5D0\uB294 puppeteer-core \uAC00 \uD544\uC694\uD569\uB2C8\uB2E4 (npm install puppeteer-core). SVG/HTML/PNG \uB294 Chromium \uC5C6\uC774 \uB429\uB2C8\uB2E4");
+  }
+  const executablePath = options.browserExecutablePath ?? process.env.PUPPETEER_EXECUTABLE_PATH ?? findChromiumPath();
+  if (!executablePath) {
+    throw new KordocError("Chromium \uC2E4\uD589 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 browserExecutablePath \uC635\uC158 \uB610\uB294 PUPPETEER_EXECUTABLE_PATH \uD658\uACBD\uBCC0\uC218\uB97C \uC9C0\uC815\uD558\uC138\uC694");
+  }
+  const browser = await puppeteer.default.launch({ executablePath, headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"] });
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: "load" });
+    const pdf = await page.pdf({ printBackground: true, preferCSSPageSize: true });
+    return Buffer.from(pdf);
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/render/document.ts
+async function loadBuffer(input) {
+  if (typeof input === "string") {
+    try {
+      return toArrayBuffer(await readFile(input));
+    } catch (err) {
+      const code = err instanceof Error && "code" in err ? err.code : void 0;
+      throw new KordocError(code === "ENOENT" ? `\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${input}` : `\uD30C\uC77C \uC77D\uAE30 \uC2E4\uD328: ${input}`);
+    }
+  }
+  if (Buffer.isBuffer(input)) return toArrayBuffer(input);
+  if (input instanceof Uint8Array) return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
+  return input;
+}
+async function sourceFormatOf(buffer) {
+  const format = detectFormat(buffer);
+  if (format === "hwpx") {
+    const zip = await detectZipFormat(buffer);
+    if (zip === "hwpx" || zip === "unknown") return "hwpx";
+    throw new KordocError(`\uB80C\uB354 \uBBF8\uC9C0\uC6D0 \uD615\uC2DD(${zip}) \u2014 \uB808\uC774\uC544\uC6C3 \uB80C\uB354\uB294 HWPX \uB9CC \uC9C0\uC6D0\uD569\uB2C8\uB2E4`);
+  }
+  if (format === "hwp") throw new KordocError("HWP5 \uB808\uC774\uC544\uC6C3 \uB80C\uB354\uB294 \uC544\uC9C1 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 \u2014 \uD55C\uCEF4\uC5D0\uC11C HWPX \uB85C \uC800\uC7A5\uD55C \uB4A4 \uB80C\uB354\uD558\uC138\uC694 (#75 \uD6C4\uC18D)");
+  throw new KordocError(`\uB80C\uB354 \uBBF8\uC9C0\uC6D0 \uD615\uC2DD(${format}) \u2014 \uB808\uC774\uC544\uC6C3 \uB80C\uB354\uB294 HWPX \uB9CC \uC9C0\uC6D0\uD569\uB2C8\uB2E4`);
+}
+async function renderDocumentToScene(input, options = {}) {
+  const buffer = await loadBuffer(input);
+  const source = await sourceFormatOf(buffer);
+  if (source !== "hwpx") throw new KordocError("HWP5 \uB808\uC774\uC544\uC6C3 \uB80C\uB354\uB294 \uC544\uC9C1 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+  const select = options.pages !== void 0 ? (pageCount) => {
+    const set = parsePageRange(options.pages, pageCount);
+    if (set.size === 0) throw new KordocError(`\uC120\uD0DD\uD55C \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBB38\uC11C\uB294 ${pageCount}\uCABD (pages: ${JSON.stringify(options.pages)})`);
+    return set;
+  } : void 0;
+  const { scene, pageSvgs } = await renderHwpxPages(buffer, {
+    reflow: options.reflow ?? true,
+    reflowMode: options.reflowMode,
+    highlights: options.highlights,
+    maxImageBytes: options.maxImageBytes
+  }, select);
+  return { scene, pageSvgs };
+}
+async function renderDocument(input, options) {
+  const { scene, pageSvgs } = await renderDocumentToScene(input, options);
+  const pageNos = [...pageSvgs.keys()].sort((a, b) => a - b);
+  const sizeOf = (n) => scene.pages.find((p) => p.page === n);
+  const assets = [];
+  switch (options.format) {
+    case "svg":
+      for (const n of pageNos) {
+        const p = sizeOf(n);
+        assets.push({ format: "svg", page: n, data: pageSvgs.get(n), width: p.width, height: p.height, mimeType: "image/svg+xml" });
+      }
+      break;
+    case "html":
+      assets.push({ format: "html", data: renderSceneToHtml(scene, pageSvgs, { title: options.title }), mimeType: "text/html" });
+      break;
+    case "png":
+    case "jpeg":
+      for (const n of pageNos) {
+        const p = sizeOf(n);
+        const r = await rasterizePageSvg(pageSvgs.get(n), p.width, p.height, { format: options.format, maxWidthPx: options.maxWidthPx, quality: options.quality });
+        assets.push({ format: options.format, page: n, data: r.data, width: r.widthPx, height: r.heightPx, scale: r.scale, mimeType: r.mimeType });
+      }
+      break;
+    case "pdf": {
+      const html = renderSceneToHtml(scene, pageSvgs, { title: options.title });
+      assets.push({ format: "pdf", data: await renderHtmlToPdf(html, { browserExecutablePath: options.browserExecutablePath }), mimeType: "application/pdf" });
+      break;
+    }
+    default:
+      throw new KordocError(`\uC54C \uC218 \uC5C6\uB294 \uB80C\uB354 \uD3EC\uB9F7: ${String(options.format)} (svg|html|png|jpeg|pdf)`);
+  }
+  return { scene, assets };
+}
+
+// src/render/regions.ts
+function cropRect(bbox, scale, pageWidthPx, pageHeightPx, paddingPt = 0) {
+  const W = Math.max(1, Math.floor(pageWidthPx)), H = Math.max(1, Math.floor(pageHeightPx));
+  const clamp = (v, hi) => Math.min(Math.max(0, v), hi);
+  let left = clamp(Math.floor((bbox.x - paddingPt) * scale), W - 1);
+  let top = clamp(Math.floor((bbox.y - paddingPt) * scale), H - 1);
+  const right = clamp(Math.ceil((bbox.x + bbox.width + paddingPt) * scale), W);
+  const bottom = clamp(Math.ceil((bbox.y + bbox.height + paddingPt) * scale), H);
+  const width = Math.max(1, right - left), height = Math.max(1, bottom - top);
+  if (left + width > W) left = W - width;
+  if (top + height > H) top = H - height;
+  return { left, top, width, height };
+}
+async function extractRenderedRegions(input, options = {}) {
+  const { scene, pageSvgs } = await renderDocumentToScene(input, { pages: options.pages, reflow: options.reflow, reflowMode: options.reflowMode });
+  const types = options.types ? new Set(options.types) : null;
+  const format = options.format ?? "png";
+  const wanted = scene.regions.filter((r) => (!types || types.has(r.type)) && (!options.filter || options.filter(r)));
+  const byPage = /* @__PURE__ */ new Map();
+  for (const r of wanted) for (const b of r.regions) if (pageSvgs.has(b.page)) (byPage.get(b.page) ?? byPage.set(b.page, []).get(b.page)).push({ region: r, bbox: b });
+  if (byPage.size === 0) return [];
+  const sharp = await loadSharp();
+  const out = [];
+  for (const [page, items] of [...byPage.entries()].sort((a, b) => a[0] - b[0])) {
+    const meta = scene.pages.find((p) => p.page === page);
+    if (!meta) throw new KordocError(`\uD398\uC774\uC9C0 ${page} \uBA54\uD0C0 \uC5C6\uC74C`);
+    const raster = await rasterizePageSvg(pageSvgs.get(page), meta.width, meta.height, { format, maxWidthPx: options.maxWidthPx, quality: options.quality });
+    for (const { region, bbox } of items) {
+      const rect = cropRect(bbox, raster.scale, raster.widthPx, raster.heightPx, options.paddingPt ?? 0);
+      const pipeline = sharp(raster.data).extract(rect);
+      const data = format === "jpeg" ? await pipeline.jpeg({ quality: options.quality ?? 85 }).toBuffer() : await pipeline.png().toBuffer();
+      out.push({ region, page, bbox, mimeType: raster.mimeType, data, widthPx: rect.width, heightPx: rect.height });
+    }
+  }
+  const order = new Map(scene.regions.map((r, i) => [r.id, i]));
+  out.sort((a, b) => order.get(a.region.id) - order.get(b.region.id) || a.page - b.page);
+  return out;
 }
 
 export {
+  parseLenientCfb,
+  isZipFile,
+  isHwpxFile,
+  isOldHwpFile,
+  isPdfFile,
+  detectFormat,
+  detectOle2Format,
+  detectZipFormat,
   charWidthEm1000,
   SPACE_EM_FIXED,
   SPACE_EM_FONT,
+  faceClassForGen,
   measureTextWidth,
   simulateWrap,
   simulateWrapKeepWord,
   fitRatioForFewerLines,
-  renderHwpxToSvg
+  renderHtml,
+  markdownToPdf,
+  blocksToPdf,
+  regionId,
+  unionBBox,
+  RegionCollector,
+  renderHwpxToSvg,
+  renderHwpxPages,
+  renderSceneToHtml,
+  renderHtmlToPdf,
+  renderDocumentToScene,
+  renderDocument,
+  cropRect,
+  extractRenderedRegions
 };
-//# sourceMappingURL=chunk-IOJX4Q63.js.map
+//# sourceMappingURL=chunk-T7AFLXGA.js.map