hwpx-js 0.1.0

package/dist/index.js

@@ -0,0 +1,2378 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/codecs/hwpx/zip.ts
+import { zipSync, unzipSync } from "fflate";
+function createZip(entries) {
+  const data = {};
+  for (const entry of entries) {
+    data[entry.path] = entry.store ? [entry.data, { level: 0 }] : entry.data;
+  }
+  return zipSync(data);
+}
+function extractZip(data) {
+  return unzipSync(data);
+}
+function encodeUtf8(str) {
+  return new TextEncoder().encode(str);
+}
+function decodeUtf8(data) {
+  return new TextDecoder().decode(data);
+}
+
+// src/codecs/hwpx/xml/index.ts
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function attrs(map) {
+  const parts = [];
+  for (const [key, val] of Object.entries(map)) {
+    if (val === void 0) continue;
+    parts.push(`${key}="${escapeXml(String(val))}"`);
+  }
+  return parts.length > 0 ? " " + parts.join(" ") : "";
+}
+function el(tag, attributes, children) {
+  const a = attrs(attributes);
+  if (children === void 0 || children === "") {
+    return `<${tag}${a}/>`;
+  }
+  return `<${tag}${a}>${children}</${tag}>`;
+}
+function xmlDecl() {
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+}
+
+// src/codecs/hwpx/ns.ts
+var NS = {
+  // 한/글 문서 네임스페이스
+  hh: "http://www.hancom.co.kr/hwpml/2011/head",
+  hp: "http://www.hancom.co.kr/hwpml/2011/paragraph",
+  hs: "http://www.hancom.co.kr/hwpml/2011/section",
+  hc: "http://www.hancom.co.kr/hwpml/2011/core",
+  ha: "http://www.hancom.co.kr/hwpml/2011/app",
+  // OPF / ODF
+  opf: "http://www.idpf.org/2007/opf",
+  odf: "urn:oasis:names:tc:opendocument:xmlns:container",
+  // 미디어 타입
+  mimeHwpx: "application/hwp+zip"
+};
+
+// src/codecs/hwpx/xml/version.ts
+function generateVersionXml(meta) {
+  return xmlDecl() + "\n" + el(
+    "hc:version",
+    {
+      "xmlns:hc": NS.hc,
+      "xmlns:ha": NS.ha,
+      tagtypes: "1"
+    },
+    "\n" + el("ha:app", {}, "hwpx-js") + "\n" + el("ha:appversion", {}, meta.hwpVersion) + "\n" + el(
+      "hc:version",
+      { tagtypes: "0" },
+      el("ha:major", {}, "1") + el("ha:minor", {}, "4")
+    ) + "\n"
+  );
+}
+
+// src/codecs/hwpx/xml/container.ts
+function generateContainerXml() {
+  return xmlDecl() + "\n" + el(
+    "container",
+    { xmlns: NS.odf, version: "1.0" },
+    "\n" + el(
+      "rootfiles",
+      {},
+      "\n" + el("rootfile", {
+        "full-path": "Contents/content.hpf",
+        "media-type": NS.mimeHwpx
+      }) + "\n"
+    ) + "\n"
+  );
+}
+
+// src/codecs/hwpx/xml/manifest.ts
+function generateManifestXml(entries) {
+  const items = entries.map(
+    (e) => "\n" + el("manifest:file-entry", {
+      "manifest:full-path": e.fullPath,
+      "manifest:media-type": e.mediaType
+    })
+  ).join("");
+  return xmlDecl() + "\n" + el(
+    "manifest:manifest",
+    { "xmlns:manifest": "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" },
+    items + "\n"
+  );
+}
+function buildManifestEntries(sectionCount, binData) {
+  const entries = [
+    { fullPath: "/", mediaType: "application/hwp+zip" },
+    { fullPath: "version.xml", mediaType: "application/xml" },
+    { fullPath: "Contents/content.hpf", mediaType: "application/xml" },
+    { fullPath: "Contents/header.xml", mediaType: "application/xml" },
+    { fullPath: "settings.xml", mediaType: "application/xml" }
+  ];
+  for (let i = 0; i < sectionCount; i++) {
+    entries.push({
+      fullPath: `Contents/section${i}.xml`,
+      mediaType: "application/xml"
+    });
+  }
+  for (const bin of binData) {
+    const mimeMap = {
+      jpg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      bmp: "image/bmp",
+      tiff: "image/tiff",
+      wmf: "image/x-wmf",
+      emf: "image/x-emf"
+    };
+    entries.push({
+      fullPath: `BinData/${bin.name}`,
+      mediaType: mimeMap[bin.format] || "application/octet-stream"
+    });
+  }
+  return entries;
+}
+
+// src/codecs/hwpx/xml/settings.ts
+function generateSettingsXml() {
+  return xmlDecl() + "\n" + el(
+    "ha:HWPApplicationSetting",
+    { "xmlns:ha": NS.ha },
+    "\n" + el("ha:CaretPosition", { list: "0", para: "0", pos: "0" }) + "\n"
+  );
+}
+
+// src/codecs/hwpx/xml/content-hpf.ts
+function generateContentHpfXml(doc) {
+  const sectionItems = doc.sections.map(
+    (_, i) => el("opf:item", {
+      id: `section${i}`,
+      href: `section${i}.xml`,
+      "media-type": "application/xml"
+    })
+  ).join("\n");
+  const sectionRefs = doc.sections.map((_, i) => el("opf:itemref", { idref: `section${i}` })).join("\n");
+  const binItems = doc.binData.map(
+    (b) => el("opf:item", {
+      id: `bindata${b.id}`,
+      href: `../BinData/${b.name}`,
+      "media-type": getMimeType(b.format)
+    })
+  ).join("\n");
+  return xmlDecl() + "\n" + el(
+    "opf:package",
+    {
+      "xmlns:opf": NS.opf,
+      version: "1.0",
+      "unique-identifier": "bookid"
+    },
+    "\n" + el(
+      "opf:metadata",
+      {},
+      "\n" + el("opf:title", {}, doc.meta.title || "") + "\n"
+    ) + "\n" + el(
+      "opf:manifest",
+      {},
+      "\n" + el("opf:item", { id: "header", href: "header.xml", "media-type": "application/xml" }) + "\n" + sectionItems + "\n" + binItems + (binItems ? "\n" : "")
+    ) + "\n" + el(
+      "opf:spine",
+      {},
+      "\n" + sectionRefs + "\n"
+    ) + "\n"
+  );
+}
+function getMimeType(format) {
+  const map = {
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    bmp: "image/bmp",
+    tiff: "image/tiff",
+    wmf: "image/x-wmf",
+    emf: "image/x-emf"
+  };
+  return map[format] || "application/octet-stream";
+}
+
+// src/codecs/hwpx/xml/header.ts
+function generateHeaderXml(head) {
+  return xmlDecl() + "\n" + el(
+    "hh:head",
+    {
+      "xmlns:hh": NS.hh,
+      "xmlns:hc": NS.hc,
+      version: "1.4",
+      secCnt: "1"
+    },
+    "\n" + generateFontFaces(head.fontFaces) + generateBorderFills(head.borderFills) + generateCharProperties(head.charProperties) + generateParaProperties(head.paraProperties) + generateStyles(head.styles) + generateNumberings(head.numberingProperties) + generateBullets(head.bulletProperties) + generateCompatibleDoc(head.compatibleDoc)
+  );
+}
+function generateFontFaces(faces) {
+  if (faces.length === 0) return "";
+  const byLang = /* @__PURE__ */ new Map();
+  for (const f of faces) {
+    const arr = byLang.get(f.lang) || [];
+    arr.push(f);
+    byLang.set(f.lang, arr);
+  }
+  let xml = "";
+  xml += el(
+    "hh:fontfaces",
+    {},
+    "\n" + Array.from(byLang.entries()).map(
+      ([lang, items]) => el(
+        "hh:fontface",
+        { lang },
+        "\n" + items.map(
+          (f, i) => el("hh:font", { id: String(i), face: f.fontName, type: f.fontType || "ttf" })
+        ).join("\n") + "\n"
+      )
+    ).join("\n") + "\n"
+  );
+  xml += "\n";
+  return xml;
+}
+function generateBorderFills(fills) {
+  if (fills.length === 0) return "";
+  const items = fills.map((bf) => {
+    const borderElements = ["left", "right", "top", "bottom"].map((side) => generateBorderLine(side, bf.borders[side])).join("\n");
+    let fillContent = "";
+    if (bf.fillBrush) {
+      if (bf.fillBrush.type === "SOLID" && bf.fillBrush.faceColor !== void 0) {
+        fillContent = el(
+          "hc:fillBrush",
+          {},
+          "\n" + el("hc:winBrush", {
+            faceColor: colorToString(bf.fillBrush.faceColor),
+            hatchColor: bf.fillBrush.patternColor !== void 0 ? colorToString(bf.fillBrush.patternColor) : void 0
+          }) + "\n"
+        );
+      }
+    }
+    return el(
+      "hh:borderFill",
+      {
+        id: String(bf.id),
+        threeD: bf.threeD ? "1" : "0",
+        shadow: bf.shadow ? "1" : "0",
+        slash: bf.slash || "NONE",
+        backSlash: bf.backSlash || "NONE"
+      },
+      "\n" + borderElements + "\n" + fillContent
+    );
+  });
+  return el("hh:borderFills", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateBorderLine(side, line) {
+  return el(`hc:${side}Border`, {
+    type: line.type,
+    width: line.width,
+    color: colorToString(line.color)
+  });
+}
+function generateCharProperties(props) {
+  if (props.length === 0) return "";
+  const items = props.map((cp) => {
+    const fontRefs = el("hh:fontRef", {
+      hangul: String(cp.fontRef.hangul),
+      latin: String(cp.fontRef.latin),
+      hanja: String(cp.fontRef.hanja),
+      japanese: String(cp.fontRef.japanese),
+      other: String(cp.fontRef.other),
+      symbol: String(cp.fontRef.symbol),
+      user: String(cp.fontRef.user)
+    });
+    return el(
+      "hh:charPr",
+      {
+        id: String(cp.id),
+        height: String(cp.height),
+        textColor: colorToString(cp.textColor),
+        shadeColor: cp.shadeColor !== void 0 ? colorToString(cp.shadeColor) : void 0,
+        useFontSpace: cp.useFontSpace ? "1" : void 0,
+        useKerning: cp.useKerning ? "1" : void 0,
+        spacing: cp.spacing !== void 0 ? String(cp.spacing) : void 0,
+        relSz: cp.relSize !== void 0 ? String(cp.relSize) : void 0,
+        offset: cp.charOffset !== void 0 ? String(cp.charOffset) : void 0,
+        bold: cp.bold ? "1" : "0",
+        italic: cp.italic ? "1" : "0",
+        underline: cp.underline || "NONE",
+        strikeout: cp.strikeout || "NONE"
+      },
+      "\n" + fontRefs + "\n"
+    );
+  });
+  return el("hh:charProperties", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateParaProperties(props) {
+  if (props.length === 0) return "";
+  const items = props.map((pp) => {
+    const marginEl = el("hh:parMargin", {
+      left: String(pp.paraMargin.left),
+      right: String(pp.paraMargin.right),
+      indent: String(pp.paraMargin.indent),
+      prev: String(pp.paraMargin.prevSpacing),
+      next: String(pp.paraMargin.nextSpacing)
+    });
+    const lineSpacingEl = el("hh:lineSpacing", {
+      type: pp.lineSpacing.type,
+      value: String(pp.lineSpacing.value)
+    });
+    return el(
+      "hh:paraPr",
+      {
+        id: String(pp.id),
+        align: pp.alignment || "JUSTIFY",
+        heading: pp.heading,
+        breakBefore: pp.breakBefore
+      },
+      "\n" + marginEl + "\n" + lineSpacingEl + "\n"
+    );
+  });
+  return el("hh:paraProperties", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateStyles(styles) {
+  if (styles.length === 0) return "";
+  const items = styles.map(
+    (s) => el("hh:style", {
+      id: String(s.id),
+      type: s.type,
+      name: s.name,
+      engName: s.engName,
+      paraPrIDRef: s.paraPrIDRef !== void 0 ? String(s.paraPrIDRef) : void 0,
+      charPrIDRef: s.charPrIDRef !== void 0 ? String(s.charPrIDRef) : void 0,
+      nextStyleIDRef: s.nextStyleIDRef !== void 0 ? String(s.nextStyleIDRef) : void 0
+    })
+  );
+  return el("hh:styles", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateNumberings(numberings) {
+  if (numberings.length === 0) return "";
+  const items = numberings.map((n) => {
+    const levels = n.levels.map(
+      (lvl, i) => el("hh:paraHead", {
+        level: String(i + 1),
+        numFormat: lvl.format,
+        start: lvl.start !== void 0 ? String(lvl.start) : "1",
+        prefix: lvl.prefix || "",
+        suffix: lvl.suffix || "."
+      })
+    ).join("\n");
+    return el("hh:numbering", { id: String(n.id) }, "\n" + levels + "\n");
+  });
+  return el("hh:numberings", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateBullets(bullets) {
+  if (bullets.length === 0) return "";
+  const items = bullets.map(
+    (b) => el("hh:bullet", {
+      id: String(b.id),
+      char: b.bulletChar,
+      bulletSz: b.bulletSize !== void 0 ? String(b.bulletSize) : void 0
+    })
+  );
+  return el("hh:bullets", {}, "\n" + items.join("\n") + "\n") + "\n";
+}
+function generateCompatibleDoc(compat) {
+  if (!compat) return "";
+  return el("hh:compatibleDocument", { targetProgram: compat }) + "\n";
+}
+function colorToString(color) {
+  return "#" + color.toString(16).padStart(6, "0");
+}
+
+// src/codecs/hwpx/xml/section.ts
+function generateSectionXml(section, sectionIndex) {
+  return xmlDecl() + "\n" + el(
+    "hs:sec",
+    {
+      "xmlns:hs": NS.hs,
+      "xmlns:hp": NS.hp,
+      "xmlns:hc": NS.hc
+    },
+    "\n" + generateSectionDef(section.def) + section.paragraphs.map((p) => generateParagraph(p)).join("\n") + "\n"
+  );
+}
+function generateSectionDef(def) {
+  const pagePr = el("hs:pagePr", {
+    landscape: def.landscape ? "LANDSCAPE" : "PORTRAIT",
+    width: String(def.pageWidth),
+    height: String(def.pageHeight),
+    gutterType: def.gutterType || "LEFT_ONLY"
+  });
+  const pageMargin = el("hs:pageMargin", {
+    left: String(def.pageMargin.left),
+    right: String(def.pageMargin.right),
+    top: String(def.pageMargin.top),
+    bottom: String(def.pageMargin.bottom),
+    header: String(def.pageMargin.header),
+    footer: String(def.pageMargin.footer),
+    gutter: String(def.pageMargin.gutter)
+  });
+  let extra = "";
+  if (def.columns && def.columns.count > 1) {
+    extra += generateColumns(def.columns) + "\n";
+  }
+  if (def.headerFooter) {
+    if (def.headerFooter.header) {
+      extra += generateHeaderFooter("hs:header", def.headerFooter.header) + "\n";
+    }
+    if (def.headerFooter.footer) {
+      extra += generateHeaderFooter("hs:footer", def.headerFooter.footer) + "\n";
+    }
+  }
+  return el(
+    "hs:secPr",
+    {},
+    "\n" + pagePr + "\n" + pageMargin + "\n" + extra
+  ) + "\n";
+}
+function generateColumns(cols) {
+  return el("hs:colPr", {
+    type: cols.type || "NORMAL",
+    count: String(cols.count),
+    gap: String(cols.gap || 0),
+    sameSz: cols.sameSizes ? "1" : "0"
+  });
+}
+function generateHeaderFooter(tag, subDoc) {
+  const paragraphs = subDoc.paragraphs.map((p) => generateParagraph(p)).join("\n");
+  return el(tag, {}, "\n" + paragraphs + "\n");
+}
+function generateParagraph(para) {
+  const runs = para.runs.map((run) => generateRun(run)).join("");
+  return el(
+    "hp:p",
+    {
+      paraPrIDRef: String(para.paraPrIDRef),
+      styleIDRef: String(para.styleIDRef)
+    },
+    "\n" + runs
+  );
+}
+function generateRun(run) {
+  switch (run.t) {
+    case "text":
+      return generateTextRun(run);
+    case "table":
+      return generateTableRun(run);
+    case "picture":
+      return generatePictureRun(run);
+    case "break":
+      return generateBreakRun(run);
+    default:
+      return "";
+  }
+}
+function generateTextRun(run) {
+  return el(
+    "hp:run",
+    { charPrIDRef: String(run.charPrIDRef) },
+    "\n" + el("hp:runText", {}, escapeXml(run.text)) + "\n"
+  );
+}
+function generateTableRun(run) {
+  return el(
+    "hp:run",
+    { charPrIDRef: String(run.charPrIDRef) },
+    "\n" + generateTable(run.table) + "\n"
+  );
+}
+function generatePictureRun(run) {
+  return el(
+    "hp:run",
+    { charPrIDRef: String(run.charPrIDRef) },
+    "\n" + generatePicture(run.picture) + "\n"
+  );
+}
+function generateBreakRun(run) {
+  const tagMap = {
+    LINE: "hp:lineBreak",
+    PAGE: "hp:pageBreak",
+    COLUMN: "hp:colBreak"
+  };
+  const tag = tagMap[run.breakType] || "hp:lineBreak";
+  return el(
+    "hp:run",
+    { charPrIDRef: String(run.charPrIDRef) },
+    `
+<${tag}/>
+`
+  );
+}
+function generateTable(table) {
+  const colWidths = table.colWidths.map((w) => el("hp:colSz", { width: String(w) })).join("\n");
+  const rows = table.rows.map((row, ri) => generateTableRow(row, ri)).join("\n");
+  return el(
+    "hp:tbl",
+    {
+      rowCnt: String(table.rowCount),
+      colCnt: String(table.colCount),
+      cellSpacing: table.cellSpacing !== void 0 ? String(table.cellSpacing) : "0",
+      borderFillIDRef: String(table.borderFillIDRef),
+      width: String(table.width)
+    },
+    "\n" + colWidths + "\n" + rows + "\n"
+  );
+}
+function generateTableRow(row, rowIndex) {
+  const cells = row.cells.map((cell) => generateTableCell(cell)).join("\n");
+  return el(
+    "hp:tr",
+    { height: String(row.height) },
+    "\n" + cells + "\n"
+  );
+}
+function generateTableCell(cell) {
+  const paddingAttrs = {};
+  if (cell.padding) {
+    paddingAttrs["paddingLeft"] = String(cell.padding.left);
+    paddingAttrs["paddingRight"] = String(cell.padding.right);
+    paddingAttrs["paddingTop"] = String(cell.padding.top);
+    paddingAttrs["paddingBottom"] = String(cell.padding.bottom);
+  }
+  const paragraphs = cell.paragraphs.map((p) => generateParagraph(p)).join("\n");
+  return el(
+    "hp:tc",
+    {
+      colSpan: String(cell.colSpan),
+      rowSpan: String(cell.rowSpan),
+      width: String(cell.width),
+      height: String(cell.height),
+      borderFillIDRef: String(cell.borderFillIDRef),
+      ...paddingAttrs
+    },
+    "\n" + el("hp:subList", {}, "\n" + paragraphs + "\n") + "\n"
+  );
+}
+function generatePicture(pic) {
+  return el(
+    "hp:pic",
+    {
+      binDataIDRef: String(pic.binDataIDRef),
+      width: String(pic.width),
+      height: String(pic.height),
+      offsetX: pic.offsetX !== void 0 ? String(pic.offsetX) : void 0,
+      offsetY: pic.offsetY !== void 0 ? String(pic.offsetY) : void 0
+    }
+  );
+}
+
+// src/codecs/hwpx/writer.ts
+function writeHwpx(doc, _opts) {
+  const entries = [];
+  entries.push({
+    path: "mimetype",
+    data: encodeUtf8(NS.mimeHwpx),
+    store: true
+  });
+  entries.push({
+    path: "META-INF/container.xml",
+    data: encodeUtf8(generateContainerXml())
+  });
+  const manifestEntries = buildManifestEntries(
+    doc.sections.length,
+    doc.binData.map((b) => ({ name: b.name, format: b.format }))
+  );
+  entries.push({
+    path: "META-INF/manifest.xml",
+    data: encodeUtf8(generateManifestXml(manifestEntries))
+  });
+  entries.push({
+    path: "version.xml",
+    data: encodeUtf8(generateVersionXml(doc.meta))
+  });
+  entries.push({
+    path: "settings.xml",
+    data: encodeUtf8(generateSettingsXml())
+  });
+  entries.push({
+    path: "Contents/content.hpf",
+    data: encodeUtf8(generateContentHpfXml(doc))
+  });
+  entries.push({
+    path: "Contents/header.xml",
+    data: encodeUtf8(generateHeaderXml(doc.head))
+  });
+  for (let i = 0; i < doc.sections.length; i++) {
+    entries.push({
+      path: `Contents/section${i}.xml`,
+      data: encodeUtf8(generateSectionXml(doc.sections[i], i))
+    });
+  }
+  for (const bin of doc.binData) {
+    entries.push({
+      path: `BinData/${bin.name}`,
+      data: bin.data
+    });
+  }
+  return createZip(entries);
+}
+
+// src/codecs/hwpx/xml/parser.ts
+function parseXml(xml) {
+  const parser = new XmlParser(xml);
+  return parser.parse();
+}
+function findChild(node, tag) {
+  return node.children.find((c) => c.tag === tag || stripNs(c.tag) === tag);
+}
+function findChildren(node, tag) {
+  return node.children.filter((c) => c.tag === tag || stripNs(c.tag) === tag);
+}
+function stripNs(tag) {
+  const idx = tag.indexOf(":");
+  return idx >= 0 ? tag.substring(idx + 1) : tag;
+}
+function attrInt(node, name, defaultValue = 0) {
+  const v = node.attrs[name];
+  if (v === void 0) return defaultValue;
+  const n = parseInt(v, 10);
+  return isNaN(n) ? defaultValue : n;
+}
+function attrStr(node, name, defaultValue = "") {
+  return node.attrs[name] ?? defaultValue;
+}
+function attrBool(node, name, defaultValue = false) {
+  const v = node.attrs[name];
+  if (v === void 0) return defaultValue;
+  return v === "1" || v === "true";
+}
+var XmlParser = class {
+  constructor(xml) {
+    this.xml = xml;
+    this.pos = 0;
+  }
+  parse() {
+    this.skipWhitespace();
+    if (this.xml.startsWith("<?", this.pos)) {
+      const end = this.xml.indexOf("?>", this.pos);
+      if (end >= 0) this.pos = end + 2;
+    }
+    this.skipWhitespace();
+    return this.parseElement();
+  }
+  parseElement() {
+    this.expect("<");
+    const tag = this.readTagName();
+    const attrs3 = this.readAttributes();
+    this.skipWhitespace();
+    if (this.xml.startsWith("/>", this.pos)) {
+      this.pos += 2;
+      return { tag, attrs: attrs3, children: [], text: "" };
+    }
+    this.expect(">");
+    const children = [];
+    let text = "";
+    let hasChildElements = false;
+    while (this.pos < this.xml.length) {
+      if (this.xml.startsWith("</", this.pos)) {
+        this.pos += 2;
+        const closingTag = this.readTagName();
+        this.skipWhitespace();
+        this.expect(">");
+        const finalText2 = hasChildElements ? text.trim() : text;
+        return { tag, attrs: attrs3, children, text: finalText2 };
+      }
+      if (this.xml.startsWith("<!--", this.pos)) {
+        const end = this.xml.indexOf("-->", this.pos);
+        if (end >= 0) this.pos = end + 3;
+        continue;
+      }
+      if (this.xml.startsWith("<![CDATA[", this.pos)) {
+        const end = this.xml.indexOf("]]>", this.pos);
+        if (end >= 0) {
+          text += this.xml.substring(this.pos + 9, end);
+          this.pos = end + 3;
+        }
+        continue;
+      }
+      if (this.xml[this.pos] === "<") {
+        hasChildElements = true;
+        children.push(this.parseElement());
+      } else {
+        const nextTag = this.xml.indexOf("<", this.pos);
+        if (nextTag >= 0) {
+          text += this.xml.substring(this.pos, nextTag);
+          this.pos = nextTag;
+        } else {
+          text += this.xml.substring(this.pos);
+          this.pos = this.xml.length;
+        }
+      }
+    }
+    const finalText = hasChildElements ? text.trim() : text;
+    return { tag, attrs: attrs3, children, text: finalText };
+  }
+  readTagName() {
+    const start = this.pos;
+    while (this.pos < this.xml.length) {
+      const ch = this.xml[this.pos];
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
+      this.pos++;
+    }
+    return this.xml.substring(start, this.pos);
+  }
+  readAttributes() {
+    const attrs3 = {};
+    while (this.pos < this.xml.length) {
+      this.skipWhitespace();
+      const ch = this.xml[this.pos];
+      if (ch === ">" || ch === "/") break;
+      const name = this.readAttrName();
+      this.skipWhitespace();
+      this.expect("=");
+      this.skipWhitespace();
+      const value = this.readAttrValue();
+      attrs3[name] = this.unescapeXml(value);
+    }
+    return attrs3;
+  }
+  readAttrName() {
+    const start = this.pos;
+    while (this.pos < this.xml.length) {
+      const ch = this.xml[this.pos];
+      if (ch === "=" || ch === " " || ch === "	" || ch === "\n" || ch === ">" || ch === "/") break;
+      this.pos++;
+    }
+    return this.xml.substring(start, this.pos);
+  }
+  readAttrValue() {
+    const quote = this.xml[this.pos];
+    if (quote !== '"' && quote !== "'") {
+      throw new Error(`Expected quote at pos ${this.pos}`);
+    }
+    this.pos++;
+    const start = this.pos;
+    const end = this.xml.indexOf(quote, this.pos);
+    if (end < 0) throw new Error(`Unterminated attribute value at pos ${start}`);
+    this.pos = end + 1;
+    return this.xml.substring(start, end);
+  }
+  skipWhitespace() {
+    while (this.pos < this.xml.length) {
+      const ch = this.xml[this.pos];
+      if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") break;
+      this.pos++;
+    }
+  }
+  expect(ch) {
+    if (!this.xml.startsWith(ch, this.pos)) {
+      throw new Error(
+        `Expected "${ch}" at pos ${this.pos}, got "${this.xml.substring(this.pos, this.pos + 10)}"`
+      );
+    }
+    this.pos += ch.length;
+  }
+  unescapeXml(str) {
+    return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+  }
+};
+
+// src/codecs/hwpx/xml/parse-header.ts
+function parseHeaderXml(xml) {
+  const root = parseXml(xml);
+  return {
+    fontFaces: parseFontFaces(root),
+    borderFills: parseBorderFills(root),
+    charProperties: parseCharProperties(root),
+    paraProperties: parseParaProperties(root),
+    styles: parseStyles(root),
+    bulletProperties: parseBullets(root),
+    numberingProperties: parseNumberings(root),
+    compatibleDoc: parseCompatibleDoc(root)
+  };
+}
+function parseFontFaces(root) {
+  const faces = [];
+  const fontfacesNode = findChild(root, "hh:fontfaces");
+  if (!fontfacesNode) return faces;
+  for (const faceNode of findChildren(fontfacesNode, "hh:fontface")) {
+    const lang = attrStr(faceNode, "lang", "HANGUL");
+    for (const fontNode of findChildren(faceNode, "hh:font")) {
+      faces.push({
+        lang,
+        fontName: attrStr(fontNode, "face"),
+        fontType: attrStr(fontNode, "type", "ttf")
+      });
+    }
+  }
+  return faces;
+}
+function parseBorderFills(root) {
+  const fills = [];
+  const fillsNode = findChild(root, "hh:borderFills");
+  if (!fillsNode) return fills;
+  for (const bfNode of findChildren(fillsNode, "hh:borderFill")) {
+    const leftBorder = findChild(bfNode, "hc:leftBorder");
+    const rightBorder = findChild(bfNode, "hc:rightBorder");
+    const topBorder = findChild(bfNode, "hc:topBorder");
+    const bottomBorder = findChild(bfNode, "hc:bottomBorder");
+    let fillBrush;
+    const fillBrushNode = findChild(bfNode, "hc:fillBrush");
+    if (fillBrushNode) {
+      const winBrush = findChild(fillBrushNode, "hc:winBrush");
+      if (winBrush) {
+        fillBrush = {
+          type: "SOLID",
+          faceColor: parseColor(attrStr(winBrush, "faceColor", "#000000")),
+          patternColor: winBrush.attrs["hatchColor"] ? parseColor(attrStr(winBrush, "hatchColor")) : void 0
+        };
+      }
+    }
+    fills.push({
+      id: attrInt(bfNode, "id"),
+      threeD: attrBool(bfNode, "threeD"),
+      shadow: attrBool(bfNode, "shadow"),
+      slash: attrStr(bfNode, "slash", "NONE"),
+      backSlash: attrStr(bfNode, "backSlash", "NONE"),
+      borders: {
+        left: parseBorderLine(leftBorder),
+        right: parseBorderLine(rightBorder),
+        top: parseBorderLine(topBorder),
+        bottom: parseBorderLine(bottomBorder)
+      },
+      fillBrush
+    });
+  }
+  return fills;
+}
+function parseBorderLine(node) {
+  if (!node) {
+    return { type: "NONE", width: "0.1mm", color: 0 };
+  }
+  return {
+    type: attrStr(node, "type", "NONE"),
+    width: attrStr(node, "width", "0.1mm"),
+    color: parseColor(attrStr(node, "color", "#000000"))
+  };
+}
+function parseCharProperties(root) {
+  const props = [];
+  const propsNode = findChild(root, "hh:charProperties");
+  if (!propsNode) return props;
+  for (const cpNode of findChildren(propsNode, "hh:charPr")) {
+    const fontRefNode = findChild(cpNode, "hh:fontRef");
+    props.push({
+      id: attrInt(cpNode, "id"),
+      height: attrInt(cpNode, "height", 1e3),
+      textColor: parseColor(attrStr(cpNode, "textColor", "#000000")),
+      shadeColor: cpNode.attrs["shadeColor"] ? parseColor(attrStr(cpNode, "shadeColor")) : void 0,
+      bold: attrBool(cpNode, "bold"),
+      italic: attrBool(cpNode, "italic"),
+      underline: attrStr(cpNode, "underline", "NONE"),
+      strikeout: attrStr(cpNode, "strikeout", "NONE"),
+      useFontSpace: attrBool(cpNode, "useFontSpace"),
+      useKerning: attrBool(cpNode, "useKerning"),
+      spacing: cpNode.attrs["spacing"] !== void 0 ? attrInt(cpNode, "spacing") : void 0,
+      relSize: cpNode.attrs["relSz"] !== void 0 ? attrInt(cpNode, "relSz") : void 0,
+      charOffset: cpNode.attrs["offset"] !== void 0 ? attrInt(cpNode, "offset") : void 0,
+      fontRef: fontRefNode ? {
+        hangul: attrInt(fontRefNode, "hangul"),
+        latin: attrInt(fontRefNode, "latin"),
+        hanja: attrInt(fontRefNode, "hanja"),
+        japanese: attrInt(fontRefNode, "japanese"),
+        other: attrInt(fontRefNode, "other"),
+        symbol: attrInt(fontRefNode, "symbol"),
+        user: attrInt(fontRefNode, "user")
+      } : { hangul: 0, latin: 0, hanja: 0, japanese: 0, other: 0, symbol: 0, user: 0 }
+    });
+  }
+  return props;
+}
+function parseParaProperties(root) {
+  const props = [];
+  const propsNode = findChild(root, "hh:paraProperties");
+  if (!propsNode) return props;
+  for (const ppNode of findChildren(propsNode, "hh:paraPr")) {
+    const marginNode = findChild(ppNode, "hh:parMargin");
+    const lineSpacingNode = findChild(ppNode, "hh:lineSpacing");
+    props.push({
+      id: attrInt(ppNode, "id"),
+      alignment: attrStr(ppNode, "align", "JUSTIFY"),
+      heading: ppNode.attrs["heading"] ? ppNode.attrs["heading"] : void 0,
+      breakBefore: ppNode.attrs["breakBefore"] ? ppNode.attrs["breakBefore"] : void 0,
+      lineSpacing: lineSpacingNode ? {
+        type: attrStr(lineSpacingNode, "type", "PERCENT"),
+        value: attrInt(lineSpacingNode, "value", 160)
+      } : { type: "PERCENT", value: 160 },
+      paraMargin: marginNode ? {
+        left: attrInt(marginNode, "left"),
+        right: attrInt(marginNode, "right"),
+        indent: attrInt(marginNode, "indent"),
+        prevSpacing: attrInt(marginNode, "prev"),
+        nextSpacing: attrInt(marginNode, "next")
+      } : { left: 0, right: 0, indent: 0, prevSpacing: 0, nextSpacing: 0 }
+    });
+  }
+  return props;
+}
+function parseStyles(root) {
+  const styles = [];
+  const stylesNode = findChild(root, "hh:styles");
+  if (!stylesNode) return styles;
+  for (const sNode of findChildren(stylesNode, "hh:style")) {
+    styles.push({
+      id: attrInt(sNode, "id"),
+      type: attrStr(sNode, "type", "PARA"),
+      name: attrStr(sNode, "name"),
+      engName: sNode.attrs["engName"] || void 0,
+      paraPrIDRef: sNode.attrs["paraPrIDRef"] !== void 0 ? attrInt(sNode, "paraPrIDRef") : void 0,
+      charPrIDRef: sNode.attrs["charPrIDRef"] !== void 0 ? attrInt(sNode, "charPrIDRef") : void 0,
+      nextStyleIDRef: sNode.attrs["nextStyleIDRef"] !== void 0 ? attrInt(sNode, "nextStyleIDRef") : void 0
+    });
+  }
+  return styles;
+}
+function parseNumberings(root) {
+  const result = [];
+  const node = findChild(root, "hh:numberings");
+  if (!node) return result;
+  for (const nNode of findChildren(node, "hh:numbering")) {
+    const levels = [];
+    for (const lNode of findChildren(nNode, "hh:paraHead")) {
+      levels.push({
+        format: attrStr(lNode, "numFormat", "DIGIT"),
+        start: attrInt(lNode, "start", 1),
+        prefix: lNode.attrs["prefix"] || void 0,
+        suffix: lNode.attrs["suffix"] || void 0
+      });
+    }
+    result.push({ id: attrInt(nNode, "id"), levels });
+  }
+  return result;
+}
+function parseBullets(root) {
+  const result = [];
+  const node = findChild(root, "hh:bullets");
+  if (!node) return result;
+  for (const bNode of findChildren(node, "hh:bullet")) {
+    result.push({
+      id: attrInt(bNode, "id"),
+      bulletChar: attrStr(bNode, "char", "\u25CF"),
+      bulletSize: bNode.attrs["bulletSz"] !== void 0 ? attrInt(bNode, "bulletSz") : void 0
+    });
+  }
+  return result;
+}
+function parseCompatibleDoc(root) {
+  const node = findChild(root, "hh:compatibleDocument");
+  if (!node) return void 0;
+  return attrStr(node, "targetProgram") || void 0;
+}
+function parseColor(hex) {
+  const h = hex.replace("#", "");
+  return parseInt(h, 16);
+}
+
+// src/codecs/hwpx/xml/parse-section.ts
+function parseSectionXml(xml) {
+  const root = parseXml(xml);
+  return {
+    def: parseSectionDef(root),
+    paragraphs: parseParagraphs(root)
+  };
+}
+function parseSectionDef(root) {
+  const secPr = findChild(root, "hs:secPr");
+  if (!secPr) {
+    return defaultSectionDef();
+  }
+  const pagePr = findChild(secPr, "hs:pagePr");
+  const pageMarginNode = findChild(secPr, "hs:pageMargin");
+  const colPr = findChild(secPr, "hs:colPr");
+  let columns;
+  if (colPr && attrInt(colPr, "count", 1) > 1) {
+    columns = {
+      type: attrStr(colPr, "type", "NORMAL"),
+      count: attrInt(colPr, "count", 1),
+      gap: attrInt(colPr, "gap", 0),
+      sameSizes: attrStr(colPr, "sameSz") === "1"
+    };
+  }
+  let headerFooter;
+  const headerNode = findChild(secPr, "hs:header");
+  const footerNode = findChild(secPr, "hs:footer");
+  if (headerNode || footerNode) {
+    headerFooter = {};
+    if (headerNode) {
+      headerFooter.header = { paragraphs: parseParagraphs(headerNode) };
+    }
+    if (footerNode) {
+      headerFooter.footer = { paragraphs: parseParagraphs(footerNode) };
+    }
+  }
+  return {
+    pageWidth: pagePr ? attrInt(pagePr, "width", 59528) : 59528,
+    pageHeight: pagePr ? attrInt(pagePr, "height", 84188) : 84188,
+    landscape: pagePr ? attrStr(pagePr, "landscape") === "LANDSCAPE" : false,
+    gutterType: pagePr ? attrStr(pagePr, "gutterType", "LEFT_ONLY") : "LEFT_ONLY",
+    pageMargin: pageMarginNode ? parsePageMargin(pageMarginNode) : defaultPageMargin(),
+    columns,
+    headerFooter
+  };
+}
+function parsePageMargin(node) {
+  return {
+    left: attrInt(node, "left"),
+    right: attrInt(node, "right"),
+    top: attrInt(node, "top"),
+    bottom: attrInt(node, "bottom"),
+    header: attrInt(node, "header"),
+    footer: attrInt(node, "footer"),
+    gutter: attrInt(node, "gutter")
+  };
+}
+function parseParagraphs(parent) {
+  const paragraphs = [];
+  for (const pNode of findChildren(parent, "hp:p")) {
+    paragraphs.push(parseParagraph(pNode));
+  }
+  return paragraphs;
+}
+function parseParagraph(pNode) {
+  const runs = [];
+  for (const runNode of findChildren(pNode, "hp:run")) {
+    const charPrIDRef = attrInt(runNode, "charPrIDRef");
+    const lineBreak = findChild(runNode, "hp:lineBreak");
+    const pageBreak = findChild(runNode, "hp:pageBreak");
+    const colBreak = findChild(runNode, "hp:colBreak");
+    if (lineBreak) {
+      runs.push({ t: "break", breakType: "LINE", charPrIDRef });
+    } else if (pageBreak) {
+      runs.push({ t: "break", breakType: "PAGE", charPrIDRef });
+    } else if (colBreak) {
+      runs.push({ t: "break", breakType: "COLUMN", charPrIDRef });
+    } else {
+      const tblNode = findChild(runNode, "hp:tbl");
+      if (tblNode) {
+        runs.push({ t: "table", table: parseTable(tblNode), charPrIDRef });
+        continue;
+      }
+      const picNode = findChild(runNode, "hp:pic");
+      if (picNode) {
+        runs.push({ t: "picture", picture: parsePicture(picNode), charPrIDRef });
+        continue;
+      }
+      const runTextNode = findChild(runNode, "hp:runText");
+      const text = runTextNode ? getTextContent(runTextNode) : "";
+      runs.push({ t: "text", text, charPrIDRef });
+    }
+  }
+  return {
+    paraPrIDRef: attrInt(pNode, "paraPrIDRef"),
+    styleIDRef: attrInt(pNode, "styleIDRef"),
+    runs
+  };
+}
+function parseTable(tblNode) {
+  const rowCount = attrInt(tblNode, "rowCnt", 1);
+  const colCount = attrInt(tblNode, "colCnt", 1);
+  const width = attrInt(tblNode, "width", 0);
+  const borderFillIDRef = attrInt(tblNode, "borderFillIDRef", 1);
+  const cellSpacing = attrInt(tblNode, "cellSpacing", 0);
+  const colSzNodes = findChildren(tblNode, "hp:colSz");
+  const colWidths = colSzNodes.map((n) => attrInt(n, "width", 0));
+  const rows = [];
+  for (const trNode of findChildren(tblNode, "hp:tr")) {
+    rows.push(parseTableRow(trNode));
+  }
+  return {
+    rowCount,
+    colCount,
+    width,
+    borderFillIDRef,
+    cellSpacing: cellSpacing || void 0,
+    colWidths,
+    rows
+  };
+}
+function parseTableRow(trNode) {
+  const height = attrInt(trNode, "height", 0);
+  const cells = [];
+  for (const tcNode of findChildren(trNode, "hp:tc")) {
+    cells.push(parseTableCell(tcNode));
+  }
+  return { height, cells };
+}
+function parseTableCell(tcNode) {
+  const colSpan = attrInt(tcNode, "colSpan", 1);
+  const rowSpan = attrInt(tcNode, "rowSpan", 1);
+  const width = attrInt(tcNode, "width", 0);
+  const height = attrInt(tcNode, "height", 0);
+  const borderFillIDRef = attrInt(tcNode, "borderFillIDRef", 1);
+  let padding;
+  if (tcNode.attrs["paddingLeft"] !== void 0) {
+    padding = {
+      left: attrInt(tcNode, "paddingLeft"),
+      right: attrInt(tcNode, "paddingRight"),
+      top: attrInt(tcNode, "paddingTop"),
+      bottom: attrInt(tcNode, "paddingBottom")
+    };
+  }
+  const subList = findChild(tcNode, "hp:subList");
+  const paragraphs = subList ? parseParagraphs(subList) : [];
+  return { paragraphs, colSpan, rowSpan, width, height, borderFillIDRef, padding };
+}
+function parsePicture(picNode) {
+  return {
+    binDataIDRef: attrInt(picNode, "binDataIDRef", 0),
+    width: attrInt(picNode, "width", 0),
+    height: attrInt(picNode, "height", 0),
+    offsetX: picNode.attrs["offsetX"] !== void 0 ? attrInt(picNode, "offsetX") : void 0,
+    offsetY: picNode.attrs["offsetY"] !== void 0 ? attrInt(picNode, "offsetY") : void 0
+  };
+}
+function getTextContent(node) {
+  let text = node.text;
+  for (const child of node.children) {
+    text += getTextContent(child);
+  }
+  return unescapeXml(text);
+}
+function unescapeXml(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+}
+function defaultSectionDef() {
+  return {
+    pageWidth: 59528,
+    pageHeight: 84188,
+    pageMargin: defaultPageMargin(),
+    landscape: false
+  };
+}
+function defaultPageMargin() {
+  return {
+    left: 8504,
+    right: 8504,
+    top: 7087,
+    bottom: 7087,
+    header: 4252,
+    footer: 4252,
+    gutter: 0
+  };
+}
+
+// src/codecs/hwpx/xml/parse-content-hpf.ts
+function parseContentHpfXml(xml) {
+  const root = parseXml(xml);
+  const metadata = findChild(root, "opf:metadata");
+  const titleNode = metadata ? findChild(metadata, "opf:title") : void 0;
+  const title = titleNode ? titleNode.text : "";
+  const manifest = findChild(root, "opf:manifest");
+  const items = manifest ? findChildren(manifest, "opf:item") : [];
+  const sectionFiles = [];
+  const binDataFiles = [];
+  for (const item of items) {
+    const id = attrStr(item, "id");
+    const href = attrStr(item, "href");
+    const mediaType = attrStr(item, "media-type");
+    if (id.startsWith("section")) {
+      sectionFiles.push(href);
+    } else if (id.startsWith("bindata")) {
+      binDataFiles.push({ id, href, mediaType });
+    }
+  }
+  if (sectionFiles.length === 0) {
+    const spine = findChild(root, "opf:spine");
+    if (spine) {
+      for (const itemref of findChildren(spine, "opf:itemref")) {
+        const idref = attrStr(itemref, "idref");
+        if (idref.startsWith("section")) {
+          sectionFiles.push(`${idref}.xml`);
+        }
+      }
+    }
+  }
+  return { title, sectionFiles, binDataFiles };
+}
+
+// src/errors.ts
+var HWPXError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HWPXError";
+  }
+};
+var HWPXValidationError = class extends HWPXError {
+  constructor(field, message) {
+    super(`Validation error on "${field}": ${message}`);
+    this.name = "HWPXValidationError";
+    this.field = field;
+  }
+};
+
+// src/codecs/hwpx/reader.ts
+function readHwpx(data, _opts) {
+  const files = extractZip(data);
+  const mimetype = files["mimetype"];
+  if (mimetype) {
+    const mt = decodeUtf8(mimetype);
+    if (!mt.includes("hwp")) {
+      throw new HWPXError(`Invalid mimetype: "${mt}"`);
+    }
+  }
+  const contentHpf = getFile(files, "Contents/content.hpf");
+  const hpfInfo = parseContentHpfXml(decodeUtf8(contentHpf));
+  const headerXml = getFile(files, "Contents/header.xml");
+  const head = parseHeaderXml(decodeUtf8(headerXml));
+  const sections = hpfInfo.sectionFiles.map((file) => {
+    const path = file.startsWith("Contents/") ? file : `Contents/${file}`;
+    const sectionData = getFile(files, path);
+    return parseSectionXml(decodeUtf8(sectionData));
+  });
+  const meta = parseMeta(files, hpfInfo.title);
+  const binData = parseBinData(files, hpfInfo.binDataFiles);
+  return { meta, head, sections, binData };
+}
+function getFile(files, path) {
+  const data = files[path];
+  if (!data) {
+    throw new HWPXError(`Required file not found in HWPX archive: ${path}`);
+  }
+  return data;
+}
+function parseMeta(files, title) {
+  const meta = {
+    hwpVersion: "5.1.0.1",
+    title: title || void 0
+  };
+  const versionData = files["version.xml"];
+  if (versionData) {
+    const versionXml = decodeUtf8(versionData);
+    const versionMatch = versionXml.match(/<ha:appversion[^>]*>([^<]+)/);
+    if (versionMatch) {
+      meta.hwpVersion = versionMatch[1];
+    }
+  }
+  return meta;
+}
+function parseBinData(files, binDataFiles) {
+  const items = [];
+  for (let i = 0; i < binDataFiles.length; i++) {
+    const { href, mediaType } = binDataFiles[i];
+    const cleanPath = href.replace(/^\.\.\//, "");
+    const path = cleanPath.startsWith("BinData/") ? cleanPath : `BinData/${cleanPath}`;
+    const data = files[path];
+    if (!data) continue;
+    const name = path.replace("BinData/", "");
+    const format = mediaTypeToFormat(mediaType);
+    items.push({
+      id: i + 1,
+      format,
+      name,
+      data
+    });
+  }
+  return items;
+}
+function mediaTypeToFormat(mediaType) {
+  const map = {
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/bmp": "bmp",
+    "image/tiff": "tiff",
+    "image/x-wmf": "wmf",
+    "image/x-emf": "emf"
+  };
+  return map[mediaType] || "png";
+}
+
+// src/codecs/hwp5/reader.ts
+import { inflateSync } from "fflate";
+
+// src/codecs/hwp5/ole.ts
+var HEADER_SIZE = 512;
+var DIR_ENTRY_SIZE = 128;
+var ENDOFCHAIN = 4294967294;
+function parseOle(data) {
+  if (data.length < HEADER_SIZE) {
+    throw new HWPXError("File too small for OLE format");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  if (view.getUint32(0, true) !== 3759263696 || view.getUint32(4, true) !== 2712738529) {
+    throw new HWPXError("Invalid OLE magic number");
+  }
+  const sectorSize = 1 << view.getUint16(30, true);
+  const miniSectorSize = 1 << view.getUint16(32, true);
+  const fatSectors = view.getInt32(44, true);
+  const firstDirSector = view.getInt32(48, true);
+  const miniStreamCutoff = view.getUint32(56, true);
+  const firstMiniFatSector = view.getInt32(60, true);
+  const miniSectorCount = view.getInt32(64, true);
+  const firstDifatSector = view.getInt32(68, true);
+  const difatCount = view.getInt32(72, true);
+  const difat = [];
+  for (let i = 0; i < 109 && i < fatSectors; i++) {
+    difat.push(view.getInt32(76 + i * 4, true));
+  }
+  let difatSector = firstDifatSector;
+  while (difatSector >= 0 && difatSector !== ENDOFCHAIN && difat.length < fatSectors) {
+    const offset = sectorOffset(difatSector, sectorSize);
+    const entriesPerSector = sectorSize / 4 - 1;
+    for (let i = 0; i < entriesPerSector && difat.length < fatSectors; i++) {
+      difat.push(view.getInt32(offset + i * 4, true));
+    }
+    difatSector = view.getInt32(offset + entriesPerSector * 4, true);
+  }
+  const fat = [];
+  for (const fatSectorIdx of difat) {
+    if (fatSectorIdx < 0) break;
+    const offset = sectorOffset(fatSectorIdx, sectorSize);
+    for (let i = 0; i < sectorSize / 4; i++) {
+      fat.push(view.getInt32(offset + i * 4, true));
+    }
+  }
+  const dirData = readSectorChain(data, fat, firstDirSector, sectorSize);
+  const entries = parseDirectoryEntries(dirData);
+  let miniFat = [];
+  if (firstMiniFatSector >= 0 && firstMiniFatSector !== ENDOFCHAIN) {
+    const miniFatData = readSectorChain(data, fat, firstMiniFatSector, sectorSize);
+    const miniFatView = new DataView(miniFatData.buffer, miniFatData.byteOffset, miniFatData.byteLength);
+    for (let i = 0; i < miniFatData.length / 4; i++) {
+      miniFat.push(miniFatView.getInt32(i * 4, true));
+    }
+  }
+  let miniStream = new Uint8Array(0);
+  if (entries.length > 0 && entries[0].startSector >= 0) {
+    miniStream = readSectorChain(data, fat, entries[0].startSector, sectorSize);
+  }
+  function getStreamByEntry(entry) {
+    if (entry.size === 0) return new Uint8Array(0);
+    if (entry.size < miniStreamCutoff) {
+      return readMiniSectorChain(miniStream, miniFat, entry.startSector, miniSectorSize, entry.size);
+    } else {
+      const raw = readSectorChain(data, fat, entry.startSector, sectorSize);
+      return raw.slice(0, entry.size);
+    }
+  }
+  function getStream(name) {
+    const entry = entries.find((e) => e.name === name && e.type === 2);
+    if (!entry) {
+      throw new HWPXError(`OLE stream not found: ${name}`);
+    }
+    return getStreamByEntry(entry);
+  }
+  function listStreams() {
+    return entries.filter((e) => e.type === 2).map((e) => e.name);
+  }
+  return { entries, getStream, getStreamByEntry, listStreams };
+}
+function sectorOffset(sector, sectorSize) {
+  return HEADER_SIZE + sector * sectorSize;
+}
+function readSectorChain(data, fat, startSector, sectorSize) {
+  const sectors = [];
+  let sector = startSector;
+  const maxSectors = fat.length;
+  while (sector >= 0 && sector !== ENDOFCHAIN && sectors.length < maxSectors) {
+    sectors.push(sector);
+    sector = fat[sector] ?? ENDOFCHAIN;
+  }
+  const result = new Uint8Array(sectors.length * sectorSize);
+  for (let i = 0; i < sectors.length; i++) {
+    const offset = sectorOffset(sectors[i], sectorSize);
+    const chunk = data.subarray(offset, offset + sectorSize);
+    result.set(chunk, i * sectorSize);
+  }
+  return result;
+}
+function readMiniSectorChain(miniStream, miniFat, startSector, miniSectorSize, size) {
+  const sectors = [];
+  let sector = startSector;
+  const maxSectors = miniFat.length;
+  while (sector >= 0 && sector !== ENDOFCHAIN && sectors.length < maxSectors) {
+    sectors.push(sector);
+    sector = miniFat[sector] ?? ENDOFCHAIN;
+  }
+  const result = new Uint8Array(sectors.length * miniSectorSize);
+  for (let i = 0; i < sectors.length; i++) {
+    const offset = sectors[i] * miniSectorSize;
+    const chunk = miniStream.subarray(offset, offset + miniSectorSize);
+    result.set(chunk, i * miniSectorSize);
+  }
+  return result.slice(0, size);
+}
+function parseDirectoryEntries(data) {
+  const entries = [];
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  for (let offset = 0; offset + DIR_ENTRY_SIZE <= data.length; offset += DIR_ENTRY_SIZE) {
+    const nameLen = view.getUint16(offset + 64, true);
+    if (nameLen === 0) continue;
+    const nameBytes = data.subarray(offset, offset + nameLen - 2);
+    let name = "";
+    for (let i = 0; i < nameBytes.length; i += 2) {
+      const code = nameBytes[i] | nameBytes[i + 1] << 8;
+      if (code === 0) break;
+      name += String.fromCharCode(code);
+    }
+    const type = data[offset + 66];
+    const startSector = view.getInt32(offset + 116, true);
+    const size = view.getUint32(offset + 120, true);
+    const leftSiblingId = view.getInt32(offset + 68, true);
+    const rightSiblingId = view.getInt32(offset + 72, true);
+    const childId = view.getInt32(offset + 76, true);
+    entries.push({
+      name,
+      type,
+      size,
+      startSector,
+      childId,
+      leftSiblingId,
+      rightSiblingId
+    });
+  }
+  return entries;
+}
+
+// src/codecs/hwp5/records.ts
+var TAG = {
+  DOCUMENT_PROPERTIES: 16,
+  ID_MAPPINGS: 17,
+  BIN_DATA: 18,
+  FACE_NAME: 19,
+  BORDER_FILL: 20,
+  CHAR_SHAPE: 21,
+  TAB_DEF: 22,
+  NUMBERING: 23,
+  BULLET: 24,
+  PARA_SHAPE: 25,
+  STYLE: 26,
+  // BodyText
+  PARA_HEADER: 66,
+  PARA_TEXT: 67,
+  PARA_CHAR_SHAPE: 68,
+  PARA_LINE_SEG: 69,
+  CTRL_HEADER: 71,
+  PAGE_DEF: 72,
+  FOOTNOTE_SHAPE: 73,
+  PAGE_BORDER_FILL: 74,
+  LIST_HEADER: 75,
+  TABLE: 79,
+  CTRL_DATA: 80,
+  SHAPE_COMPONENT: 82
+};
+function parseRecords(data) {
+  const records = [];
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+  while (offset + 4 <= data.length) {
+    const header = view.getUint32(offset, true);
+    const tagId = header & 1023;
+    const level = header >> 10 & 1023;
+    let size = header >> 20 & 4095;
+    offset += 4;
+    if (size === 4095) {
+      if (offset + 4 > data.length) break;
+      size = view.getUint32(offset, true);
+      offset += 4;
+    }
+    if (offset + size > data.length) break;
+    records.push({
+      tagId,
+      level,
+      size,
+      data: data.subarray(offset, offset + size)
+    });
+    offset += size;
+  }
+  return records;
+}
+function readUtf16(data, offset, charCount) {
+  let str = "";
+  for (let i = 0; i < charCount; i++) {
+    const code = data[offset + i * 2] | data[offset + i * 2 + 1] << 8;
+    if (code === 0) break;
+    str += String.fromCharCode(code);
+  }
+  return str;
+}
+function readU16(data, offset) {
+  return data[offset] | data[offset + 1] << 8;
+}
+function readU32(data, offset) {
+  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
+}
+function readI32(data, offset) {
+  return data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24;
+}
+
+// src/utils/units.ts
+var HWPUNIT_PER_INCH = 7200;
+var MM_PER_INCH = 25.4;
+var PT_PER_INCH = 72;
+function mmToHwpunit(mm) {
+  return Math.round(mm / MM_PER_INCH * HWPUNIT_PER_INCH);
+}
+function hwpunitToMm(hu) {
+  return hu / HWPUNIT_PER_INCH * MM_PER_INCH;
+}
+function ptToHwpunit(pt) {
+  return Math.round(pt / PT_PER_INCH * HWPUNIT_PER_INCH);
+}
+function hwpunitToPt(hu) {
+  return hu / HWPUNIT_PER_INCH * PT_PER_INCH;
+}
+function pxToHwpunit(px, dpi = 96) {
+  return Math.round(px / dpi * HWPUNIT_PER_INCH);
+}
+function hwpunitToPx(hu, dpi = 96) {
+  return hu / HWPUNIT_PER_INCH * dpi;
+}
+function ptToCharHeight(pt) {
+  return Math.round(pt * 100);
+}
+function charHeightToPt(height) {
+  return height / 100;
+}
+
+// src/utils/color.ts
+function hexToColorref(hex) {
+  const h = hex.replace("#", "");
+  const r = parseInt(h.substring(0, 2), 16);
+  const g = parseInt(h.substring(2, 4), 16);
+  const b = parseInt(h.substring(4, 6), 16);
+  return b << 16 | g << 8 | r;
+}
+function colorrefToHex(colorref) {
+  const r = colorref & 255;
+  const g = colorref >> 8 & 255;
+  const b = colorref >> 16 & 255;
+  return "#" + [r, g, b].map((c) => c.toString(16).padStart(2, "0")).join("");
+}
+function colorrefToRgbString(colorref) {
+  const r = colorref & 255;
+  const g = colorref >> 8 & 255;
+  const b = colorref >> 16 & 255;
+  return `${r}, ${g}, ${b}`;
+}
+function rgbToColorref(rgb) {
+  const r = rgb >> 16 & 255;
+  const g = rgb >> 8 & 255;
+  const b = rgb & 255;
+  return b << 16 | g << 8 | r;
+}
+
+// src/defaults.ts
+function defaultFontRef() {
+  return { hangul: 0, latin: 0, hanja: 0, japanese: 0, other: 0, symbol: 0, user: 0 };
+}
+function createDefaultFontFaces() {
+  return [
+    { lang: "HANGUL", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "LATIN", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "HANJA", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "JAPANESE", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "OTHER", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "SYMBOL", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" },
+    { lang: "USER", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" }
+  ];
+}
+function createDefaultCharProperty(id = 0) {
+  return {
+    id,
+    height: ptToCharHeight(10),
+    // 10pt
+    textColor: hexToColorref("#000000"),
+    bold: false,
+    italic: false,
+    underline: "NONE",
+    strikeout: "NONE",
+    fontRef: defaultFontRef(),
+    useFontSpace: false,
+    useKerning: true,
+    relSize: 100,
+    spacing: 0,
+    charOffset: 0
+  };
+}
+function createDefaultParaProperty(id = 0) {
+  return {
+    id,
+    alignment: "JUSTIFY",
+    lineSpacing: { type: "PERCENT", value: 160 },
+    paraMargin: {
+      left: 0,
+      right: 0,
+      indent: 0,
+      prevSpacing: 0,
+      nextSpacing: 0
+    }
+  };
+}
+function createDefaultBorderFill(id = 1) {
+  const noBorder = {
+    type: "NONE",
+    width: "0.1mm",
+    color: hexToColorref("#000000")
+  };
+  return {
+    id,
+    borders: {
+      left: { ...noBorder },
+      right: { ...noBorder },
+      top: { ...noBorder },
+      bottom: { ...noBorder }
+    }
+  };
+}
+function createDefaultStyles() {
+  return [
+    {
+      id: 0,
+      type: "PARA",
+      name: "\uBC14\uD0D5\uAE00",
+      engName: "Normal",
+      paraPrIDRef: 0,
+      charPrIDRef: 0,
+      nextStyleIDRef: 0
+    }
+  ];
+}
+function createDefaultSectionDef() {
+  return {
+    pageWidth: mmToHwpunit(210),
+    pageHeight: mmToHwpunit(297),
+    pageMargin: createDefaultPageMargin(),
+    landscape: false,
+    gutterType: "LEFT_ONLY"
+  };
+}
+function createDefaultPageMargin() {
+  return {
+    left: mmToHwpunit(30),
+    right: mmToHwpunit(30),
+    top: mmToHwpunit(25),
+    bottom: mmToHwpunit(25),
+    header: mmToHwpunit(15),
+    footer: mmToHwpunit(15),
+    gutter: 0
+  };
+}
+function createDefaultHead() {
+  return {
+    fontFaces: createDefaultFontFaces(),
+    charProperties: [createDefaultCharProperty(0)],
+    paraProperties: [createDefaultParaProperty(0)],
+    styles: createDefaultStyles(),
+    borderFills: [createDefaultBorderFill(1)],
+    bulletProperties: [],
+    numberingProperties: [],
+    compatibleDoc: "HWP"
+  };
+}
+function createDefaultMeta() {
+  return {
+    hwpVersion: "5.1.0.1"
+  };
+}
+function createDefaultDocument() {
+  return {
+    meta: createDefaultMeta(),
+    head: createDefaultHead(),
+    sections: [
+      {
+        def: createDefaultSectionDef(),
+        paragraphs: []
+      }
+    ],
+    binData: []
+  };
+}
+
+// src/codecs/hwp5/reader.ts
+function readHwp5(data) {
+  const ole = parseOle(data);
+  const fileHeader = ole.getStream("FileHeader");
+  const compressed = isCompressed(fileHeader);
+  const hwpVersion = readHwpVersion(fileHeader);
+  const docInfoRaw = ole.getStream("DocInfo");
+  const docInfoData = compressed ? tryDecompress(docInfoRaw) : docInfoRaw;
+  const docInfoRecords = parseRecords(docInfoData);
+  const head = parseDocInfo(docInfoRecords);
+  const sections = parseBodyText(ole, compressed);
+  const meta = {
+    ...createDefaultMeta(),
+    hwpVersion
+  };
+  return { meta, head, sections, binData: [] };
+}
+function isCompressed(fileHeader) {
+  if (fileHeader.length < 40) return false;
+  const flags = readU32(fileHeader, 36);
+  return (flags & 1) !== 0;
+}
+function readHwpVersion(fileHeader) {
+  if (fileHeader.length < 36) return "5.0.0.0";
+  const major = fileHeader[35];
+  const minor = fileHeader[34];
+  const build = fileHeader[33];
+  const revision = fileHeader[32];
+  return `${major}.${minor}.${build}.${revision}`;
+}
+function tryDecompress(data) {
+  try {
+    return inflateSync(data);
+  } catch {
+    return data;
+  }
+}
+function parseDocInfo(records) {
+  const head = createDefaultHead();
+  head.fontFaces = [];
+  head.charProperties = [];
+  head.paraProperties = [];
+  head.styles = [];
+  head.borderFills = [];
+  let fontId = 0;
+  let charPrId = 0;
+  let paraPrId = 0;
+  let styleId = 0;
+  let borderFillId = 1;
+  for (const rec of records) {
+    switch (rec.tagId) {
+      case TAG.FACE_NAME: {
+        const face = parseFaceName(rec.data, fontId);
+        if (face) {
+          head.fontFaces.push(face);
+          fontId++;
+        }
+        break;
+      }
+      case TAG.CHAR_SHAPE: {
+        const cp = parseCharShape(rec.data, charPrId);
+        if (cp) {
+          head.charProperties.push(cp);
+          charPrId++;
+        }
+        break;
+      }
+      case TAG.PARA_SHAPE: {
+        const pp = parseParaShape(rec.data, paraPrId);
+        if (pp) {
+          head.paraProperties.push(pp);
+          paraPrId++;
+        }
+        break;
+      }
+      case TAG.STYLE: {
+        const style = parseStyle(rec.data, styleId);
+        if (style) {
+          head.styles.push(style);
+          styleId++;
+        }
+        break;
+      }
+      case TAG.BORDER_FILL: {
+        const bf = parseBorderFillRecord(rec.data, borderFillId);
+        if (bf) {
+          head.borderFills.push(bf);
+          borderFillId++;
+        }
+        break;
+      }
+    }
+  }
+  if (head.fontFaces.length === 0) head.fontFaces = [{ lang: "HANGUL", fontName: "\uD568\uCD08\uB86C\uB3CB\uC6C0", fontType: "ttf" }];
+  if (head.charProperties.length === 0) head.charProperties = [{ id: 0, height: 1e3, textColor: 0, fontRef: { hangul: 0, latin: 0, hanja: 0, japanese: 0, other: 0, symbol: 0, user: 0 } }];
+  if (head.paraProperties.length === 0) head.paraProperties = [{ id: 0, alignment: "JUSTIFY", lineSpacing: { type: "PERCENT", value: 160 }, paraMargin: { left: 0, right: 0, indent: 0, prevSpacing: 0, nextSpacing: 0 } }];
+  if (head.styles.length === 0) head.styles = [{ id: 0, type: "PARA", name: "\uBC14\uD0D5\uAE00", engName: "Normal", paraPrIDRef: 0, charPrIDRef: 0 }];
+  if (head.borderFills.length === 0) head.borderFills = [createDefaultBorderFill(1)];
+  return head;
+}
+function parseFaceName(data, id) {
+  if (data.length < 6) return null;
+  const nameLen = readU16(data, 2);
+  if (data.length < 4 + nameLen * 2) return null;
+  const fontName = readUtf16(data, 4, nameLen);
+  const langMap = ["HANGUL", "LATIN", "HANJA", "JAPANESE", "OTHER", "SYMBOL", "USER"];
+  const lang = langMap[id % 7] || "HANGUL";
+  return { lang, fontName, fontType: "ttf" };
+}
+function parseCharShape(data, id) {
+  if (data.length < 72) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const fontRef = {
+    hangul: readU16(data, 0),
+    latin: readU16(data, 2),
+    hanja: readU16(data, 4),
+    japanese: readU16(data, 6),
+    other: readU16(data, 8),
+    symbol: readU16(data, 10),
+    user: readU16(data, 12)
+  };
+  const height = readI32(data, 70);
+  let textColor = 0;
+  if (data.length >= 78) {
+    textColor = readU32(data, 74);
+  }
+  let bold = false;
+  let italic = false;
+  if (data.length >= 74) {
+    const attr = readU32(data, 70);
+  }
+  return {
+    id,
+    height: height > 0 ? height : 1e3,
+    textColor: textColor & 16777215,
+    fontRef,
+    bold,
+    italic
+  };
+}
+function parseParaShape(data, id) {
+  if (data.length < 8) return null;
+  const attr = readU32(data, 0);
+  const alignment = ["JUSTIFY", "LEFT", "RIGHT", "CENTER", "DISTRIBUTE", "DISTRIBUTE_SPACE"][attr & 7] || "JUSTIFY";
+  let leftMargin = 0, rightMargin = 0, indent = 0;
+  if (data.length >= 20) {
+    leftMargin = readI32(data, 4);
+    rightMargin = readI32(data, 8);
+    indent = readI32(data, 12);
+  }
+  let prevSpacing = 0, nextSpacing = 0;
+  if (data.length >= 28) {
+    prevSpacing = readI32(data, 16);
+    nextSpacing = readI32(data, 20);
+  }
+  let lineSpacingValue = 160;
+  if (data.length >= 32) {
+    lineSpacingValue = readI32(data, 24);
+  }
+  return {
+    id,
+    alignment,
+    lineSpacing: { type: "PERCENT", value: lineSpacingValue > 0 ? lineSpacingValue : 160 },
+    paraMargin: {
+      left: Math.max(0, leftMargin),
+      right: Math.max(0, rightMargin),
+      indent,
+      prevSpacing: Math.max(0, prevSpacing),
+      nextSpacing: Math.max(0, nextSpacing)
+    }
+  };
+}
+function parseStyle(data, id) {
+  if (data.length < 8) return null;
+  const nameLen = readU16(data, 0);
+  let offset = 2;
+  const name = readUtf16(data, offset, nameLen);
+  offset += nameLen * 2;
+  let engName = "";
+  if (offset + 2 <= data.length) {
+    const engNameLen = readU16(data, offset);
+    offset += 2;
+    if (offset + engNameLen * 2 <= data.length) {
+      engName = readUtf16(data, offset, engNameLen);
+      offset += engNameLen * 2;
+    }
+  }
+  let type = "PARA";
+  let paraPrIDRef = 0;
+  let charPrIDRef = 0;
+  if (offset + 4 <= data.length) {
+    const styleType = data[offset];
+    type = styleType === 1 ? "CHAR" : "PARA";
+    offset += 1;
+  }
+  return {
+    id,
+    type,
+    name: name || `Style${id}`,
+    engName: engName || void 0,
+    paraPrIDRef,
+    charPrIDRef
+  };
+}
+function parseBorderFillRecord(data, id) {
+  if (data.length < 2) return null;
+  return createDefaultBorderFill(id);
+}
+function parseBodyText(ole, compressed) {
+  const sections = [];
+  const streams = ole.listStreams();
+  const sectionStreams = streams.filter((name) => /^Section\d+$/.test(name)).sort((a, b) => {
+    const numA = parseInt(a.replace("Section", ""), 10);
+    const numB = parseInt(b.replace("Section", ""), 10);
+    return numA - numB;
+  });
+  if (sectionStreams.length === 0) {
+    for (const entry of ole.entries) {
+      if (/^Section\d+$/.test(entry.name) && entry.type === 2) {
+        sectionStreams.push(entry.name);
+      }
+    }
+    sectionStreams.sort();
+  }
+  for (const streamName of sectionStreams) {
+    try {
+      const raw = ole.getStream(streamName);
+      const sectionData = compressed ? tryDecompress(raw) : raw;
+      const records = parseRecords(sectionData);
+      sections.push(parseSectionRecords(records));
+    } catch {
+      sections.push({ def: createDefaultSectionDef(), paragraphs: [] });
+    }
+  }
+  if (sections.length === 0) {
+    sections.push({ def: createDefaultSectionDef(), paragraphs: [] });
+  }
+  return sections;
+}
+function parseSectionRecords(records) {
+  const paragraphs = [];
+  let currentParaCharShapeRef = 0;
+  let currentParaStyleRef = 0;
+  for (let i = 0; i < records.length; i++) {
+    const rec = records[i];
+    if (rec.tagId === TAG.PARA_HEADER) {
+      if (rec.data.length >= 4) {
+        const nCharShapeRef = readU32(rec.data, 0);
+      }
+      let textRec = null;
+      let charShapeRec = null;
+      for (let j = i + 1; j < records.length && records[j].level > rec.level; j++) {
+        if (records[j].tagId === TAG.PARA_TEXT && !textRec) {
+          textRec = records[j];
+        }
+        if (records[j].tagId === TAG.PARA_CHAR_SHAPE && !charShapeRec) {
+          charShapeRec = records[j];
+        }
+      }
+      const text = textRec ? parseParaText(textRec.data) : "";
+      const charPrIDRef = charShapeRec ? readU32(charShapeRec.data, 4) : 0;
+      const paraPrIDRef = rec.data.length >= 6 ? readU16(rec.data, 4) : 0;
+      const styleIDRef = rec.data.length >= 8 ? readU16(rec.data, 6) : 0;
+      paragraphs.push({
+        paraPrIDRef,
+        styleIDRef,
+        runs: [{ t: "text", text, charPrIDRef }]
+      });
+    }
+    if (rec.tagId === TAG.PAGE_DEF) {
+    }
+  }
+  return {
+    def: createDefaultSectionDef(),
+    paragraphs
+  };
+}
+function parseParaText(data) {
+  let text = "";
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  for (let offset = 0; offset + 1 < data.length; offset += 2) {
+    const ch = view.getUint16(offset, true);
+    if (ch < 32) {
+      switch (ch) {
+        case 13:
+        // paragraph break
+        case 10:
+          break;
+        case 9:
+          text += "	";
+          break;
+        case 1:
+        // reserved
+        case 2:
+        // section/column control
+        case 3:
+          offset += 14;
+          break;
+        case 4:
+        // field end
+        case 11:
+        // control char (inline)
+        case 12:
+        // control char (extended)
+        case 15:
+        // hyphen
+        case 16:
+        // reserved
+        case 17:
+        // reserved
+        case 18:
+        // reserved
+        case 23:
+        // reserved
+        case 24:
+          break;
+        default:
+          break;
+      }
+    } else {
+      text += String.fromCharCode(ch);
+    }
+  }
+  return text;
+}
+
+// src/utils/detect.ts
+function detectFormat(data) {
+  if (data.length < 4) return "unknown";
+  if (data[0] === 80 && data[1] === 75 && data[2] === 3 && data[3] === 4) {
+    return "hwpx";
+  }
+  if (data[0] === 208 && data[1] === 207 && data[2] === 17 && data[3] === 224) {
+    return "hwp5";
+  }
+  return "unknown";
+}
+
+// src/utils/id.ts
+var IdCounter = class {
+  constructor(start = 0) {
+    this.value = start;
+  }
+  next() {
+    return this.value++;
+  }
+  current() {
+    return this.value;
+  }
+  reset(start = 0) {
+    this.value = start;
+  }
+};
+
+// src/builder.ts
+var HWPXBuilder = class {
+  constructor() {
+    this.charPrCache = /* @__PURE__ */ new Map();
+    this.doc = createDefaultDocument();
+    this.charPrIdCounter = new IdCounter(1);
+    this.paraPrIdCounter = new IdCounter(1);
+    this.borderFillIdCounter = new IdCounter(2);
+    this.binDataIdCounter = new IdCounter(1);
+  }
+  /** 단일 스타일 문단 추가 */
+  addParagraph(text, style) {
+    const charPrId = this.getOrCreateCharPr(style);
+    const para = {
+      paraPrIDRef: 0,
+      styleIDRef: 0,
+      runs: [
+        {
+          t: "text",
+          text,
+          charPrIDRef: charPrId
+        }
+      ]
+    };
+    this.currentSection().paragraphs.push(para);
+    return this;
+  }
+  /** 복수 스타일 세그먼트로 구성된 문단 추가 */
+  addStyledText(segments) {
+    const runs = segments.map((seg) => ({
+      t: "text",
+      text: seg.text,
+      charPrIDRef: this.getOrCreateCharPr(seg.style)
+    }));
+    const para = {
+      paraPrIDRef: 0,
+      styleIDRef: 0,
+      runs
+    };
+    this.currentSection().paragraphs.push(para);
+    return this;
+  }
+  /** 빈 문단(빈 줄) 추가 */
+  addEmptyParagraph() {
+    const para = {
+      paraPrIDRef: 0,
+      styleIDRef: 0,
+      runs: [
+        {
+          t: "text",
+          text: "",
+          charPrIDRef: 0
+        }
+      ]
+    };
+    this.currentSection().paragraphs.push(para);
+    return this;
+  }
+  /** 페이지 설정 변경 */
+  setPageSettings(opts) {
+    const def = this.currentSection().def;
+    if (opts.width !== void 0) def.pageWidth = mmToHwpunit(opts.width);
+    if (opts.height !== void 0) def.pageHeight = mmToHwpunit(opts.height);
+    if (opts.landscape !== void 0) def.landscape = opts.landscape;
+    if (opts.marginLeft !== void 0) def.pageMargin.left = mmToHwpunit(opts.marginLeft);
+    if (opts.marginRight !== void 0) def.pageMargin.right = mmToHwpunit(opts.marginRight);
+    if (opts.marginTop !== void 0) def.pageMargin.top = mmToHwpunit(opts.marginTop);
+    if (opts.marginBottom !== void 0) def.pageMargin.bottom = mmToHwpunit(opts.marginBottom);
+    return this;
+  }
+  /** 테이블 추가 (string[][] 데이터, 셀 병합은 merges 옵션) */
+  addTable(data, opts) {
+    const rowCount = data.length;
+    const colCount = data.length > 0 ? data[0].length : 0;
+    if (rowCount === 0 || colCount === 0) return this;
+    const secDef = this.currentSection().def;
+    const bodyWidth = opts?.width ? mmToHwpunit(opts.width) : secDef.pageWidth - secDef.pageMargin.left - secDef.pageMargin.right;
+    const colWidths = opts?.colWidths ? opts.colWidths.map((w) => mmToHwpunit(w)) : Array(colCount).fill(Math.floor(bodyWidth / colCount));
+    const borderFillId = this.getOrCreateTableBorderFill(opts?.borderStyle || "SOLID");
+    const cellPadding = opts?.cellPadding ? mmToHwpunit(opts.cellPadding) : mmToHwpunit(1.5);
+    const rowHeight = mmToHwpunit(10);
+    const mergeMap = /* @__PURE__ */ new Map();
+    if (opts?.merges) {
+      for (const m of opts.merges) {
+        mergeMap.set(`${m.row},${m.col}`, { rowSpan: m.rowSpan, colSpan: m.colSpan });
+        for (let r = m.row; r < m.row + m.rowSpan; r++) {
+          for (let c = m.col; c < m.col + m.colSpan; c++) {
+            if (r !== m.row || c !== m.col) {
+              mergeMap.set(`${r},${c}`, "hidden");
+            }
+          }
+        }
+      }
+    }
+    const rows = data.map((rowData, ri) => ({
+      height: rowHeight,
+      cells: rowData.map((cellText, ci) => {
+        const key = `${ri},${ci}`;
+        const mergeInfo = mergeMap.get(key);
+        if (mergeInfo === "hidden") return null;
+        const span = mergeInfo ? mergeInfo : { rowSpan: 1, colSpan: 1 };
+        let cellWidth = 0;
+        for (let c = ci; c < ci + span.colSpan && c < colWidths.length; c++) {
+          cellWidth += colWidths[c];
+        }
+        return {
+          paragraphs: [{
+            paraPrIDRef: 0,
+            styleIDRef: 0,
+            runs: [{ t: "text", text: cellText, charPrIDRef: 0 }]
+          }],
+          colSpan: span.colSpan,
+          rowSpan: span.rowSpan,
+          width: cellWidth || colWidths[ci] || colWidths[0],
+          height: rowHeight * span.rowSpan,
+          borderFillIDRef: borderFillId,
+          padding: {
+            left: cellPadding,
+            right: cellPadding,
+            top: cellPadding,
+            bottom: cellPadding
+          }
+        };
+      }).filter((c) => c !== null)
+    }));
+    const table = {
+      rows,
+      borderFillIDRef: borderFillId,
+      width: bodyWidth,
+      rowCount,
+      colCount,
+      colWidths
+    };
+    const para = {
+      paraPrIDRef: 0,
+      styleIDRef: 0,
+      runs: [{ t: "table", table, charPrIDRef: 0 }]
+    };
+    this.currentSection().paragraphs.push(para);
+    return this;
+  }
+  /** 이미지 추가 */
+  addImage(data, format, opts) {
+    const id = this.binDataIdCounter.next();
+    const name = `image${id}.${format}`;
+    this.doc.binData.push({ id, format, name, data });
+    const pic = {
+      binDataIDRef: id,
+      width: mmToHwpunit(opts.width),
+      height: mmToHwpunit(opts.height)
+    };
+    const para = {
+      paraPrIDRef: 0,
+      styleIDRef: 0,
+      runs: [{ t: "picture", picture: pic, charPrIDRef: 0 }]
+    };
+    this.currentSection().paragraphs.push(para);
+    return this;
+  }
+  /** 머리글/바닥글 설정 */
+  setHeaderFooter(opts) {
+    const def = this.currentSection().def;
+    if (!def.headerFooter) def.headerFooter = {};
+    if (opts.header !== void 0) {
+      def.headerFooter.header = {
+        paragraphs: [{
+          paraPrIDRef: 0,
+          styleIDRef: 0,
+          runs: [{ t: "text", text: opts.header, charPrIDRef: 0 }]
+        }]
+      };
+    }
+    if (opts.footer !== void 0) {
+      def.headerFooter.footer = {
+        paragraphs: [{
+          paraPrIDRef: 0,
+          styleIDRef: 0,
+          runs: [{ t: "text", text: opts.footer, charPrIDRef: 0 }]
+        }]
+      };
+    }
+    return this;
+  }
+  /** 다단 설정 */
+  setColumns(opts) {
+    const def = this.currentSection().def;
+    def.columns = {
+      type: opts.type || "NORMAL",
+      count: opts.count,
+      gap: mmToHwpunit(opts.gap ?? 10),
+      sameSizes: true
+    };
+    return this;
+  }
+  /** 새 섹션 시작 */
+  addSection() {
+    this.doc.sections.push({
+      def: createDefaultSectionDef(),
+      paragraphs: []
+    });
+    return this;
+  }
+  /** 문서 빌드 */
+  build() {
+    return this.doc;
+  }
+  // ─── Internal ───
+  currentSection() {
+    return this.doc.sections[this.doc.sections.length - 1];
+  }
+  getOrCreateCharPr(style) {
+    if (!style) return 0;
+    const key = this.styleKey(style);
+    const cached = this.charPrCache.get(key);
+    if (cached !== void 0) return cached;
+    const id = this.charPrIdCounter.next();
+    const base = createDefaultCharProperty(id);
+    if (style.fontSize !== void 0) base.height = ptToCharHeight(style.fontSize);
+    if (style.bold !== void 0) base.bold = style.bold;
+    if (style.italic !== void 0) base.italic = style.italic;
+    if (style.color !== void 0) base.textColor = hexToColorref(style.color);
+    if (style.underline) base.underline = "BOTTOM";
+    if (style.strikeout) base.strikeout = "CONTINUOUS";
+    if (style.fontName) {
+      const fontIdx = this.ensureFont(style.fontName);
+      base.fontRef = {
+        hangul: fontIdx,
+        latin: fontIdx,
+        hanja: fontIdx,
+        japanese: fontIdx,
+        other: fontIdx,
+        symbol: fontIdx,
+        user: fontIdx
+      };
+    }
+    this.doc.head.charProperties.push(base);
+    this.charPrCache.set(key, id);
+    return id;
+  }
+  ensureFont(fontName) {
+    const faces = this.doc.head.fontFaces;
+    const hangulFaces = faces.filter((f) => f.lang === "HANGUL");
+    const existing = hangulFaces.findIndex((f) => f.fontName === fontName);
+    if (existing !== -1) return existing;
+    const newIdx = hangulFaces.length;
+    const langs = [];
+    const allLangs = ["HANGUL", "LATIN", "HANJA", "JAPANESE", "OTHER", "SYMBOL", "USER"];
+    for (const lang of allLangs) {
+      faces.push({ lang, fontName, fontType: "ttf" });
+    }
+    return newIdx;
+  }
+  getOrCreateTableBorderFill(lineType) {
+    const line = {
+      type: lineType,
+      width: "0.12mm",
+      color: hexToColorref("#000000")
+    };
+    const bf = {
+      id: this.borderFillIdCounter.next(),
+      borders: {
+        left: { ...line },
+        right: { ...line },
+        top: { ...line },
+        bottom: { ...line }
+      }
+    };
+    this.doc.head.borderFills.push(bf);
+    return bf.id;
+  }
+  styleKey(style) {
+    return JSON.stringify({
+      fs: style.fontSize,
+      b: style.bold,
+      i: style.italic,
+      c: style.color,
+      u: style.underline,
+      s: style.strikeout,
+      f: style.fontName
+    });
+  }
+};
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  IdCounter: () => IdCounter,
+  charHeightToPt: () => charHeightToPt,
+  colorrefToHex: () => colorrefToHex,
+  colorrefToRgbString: () => colorrefToRgbString,
+  detectFormat: () => detectFormat,
+  hexToColorref: () => hexToColorref,
+  hwpunitToMm: () => hwpunitToMm,
+  hwpunitToPt: () => hwpunitToPt,
+  hwpunitToPx: () => hwpunitToPx,
+  mmToHwpunit: () => mmToHwpunit,
+  ptToCharHeight: () => ptToCharHeight,
+  ptToHwpunit: () => ptToHwpunit,
+  pxToHwpunit: () => pxToHwpunit,
+  rgbToColorref: () => rgbToColorref
+});
+
+// src/index.ts
+function write(doc, opts) {
+  return writeHwpx(doc, opts);
+}
+function read(data, opts) {
+  const format = detectFormat(data);
+  if (format === "hwp5") {
+    return readHwp5(data);
+  }
+  if (format === "unknown") {
+    throw new HWPXError("Unknown file format. Expected HWPX or HWP5 file.");
+  }
+  return readHwpx(data, opts);
+}
+export {
+  HWPXBuilder,
+  HWPXError,
+  HWPXValidationError,
+  createDefaultBorderFill,
+  createDefaultCharProperty,
+  createDefaultDocument,
+  createDefaultFontFaces,
+  createDefaultHead,
+  createDefaultMeta,
+  createDefaultParaProperty,
+  createDefaultSectionDef,
+  createDefaultStyles,
+  read,
+  utils_exports as utils,
+  write
+};
+//# sourceMappingURL=index.js.map