hwpx-js 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -34,7 +34,8 @@ __export(index_exports, {
   createDefaultStyles: () => createDefaultStyles,
   read: () => read,
   utils: () => utils_exports,
-  write: () => write
+  write: () => write,
+  writePdf: () => writePdf2
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -813,14 +814,15 @@ var XmlParser = class {
 // src/codecs/hwpx/xml/parse-header.ts
 function parseHeaderXml(xml) {
   const root = parseXml(xml);
+  const refList = findChild(root, "hh:refList") || root;
   return {
-    fontFaces: parseFontFaces(root),
-    borderFills: parseBorderFills(root),
-    charProperties: parseCharProperties(root),
-    paraProperties: parseParaProperties(root),
-    styles: parseStyles(root),
-    bulletProperties: parseBullets(root),
-    numberingProperties: parseNumberings(root),
+    fontFaces: parseFontFaces(refList),
+    borderFills: parseBorderFills(refList),
+    charProperties: parseCharProperties(refList),
+    paraProperties: parseParaProperties(refList),
+    styles: parseStyles(refList),
+    bulletProperties: parseBullets(refList),
+    numberingProperties: parseNumberings(refList),
     compatibleDoc: parseCompatibleDoc(root)
   };
 }
@@ -894,15 +896,21 @@ function parseCharProperties(root) {
   if (!propsNode) return props;
   for (const cpNode of findChildren(propsNode, "hh:charPr")) {
     const fontRefNode = findChild(cpNode, "hh:fontRef");
+    const hasBoldElement = !!findChild(cpNode, "hh:bold");
+    const hasItalicElement = !!findChild(cpNode, "hh:italic");
+    const underlineNode = findChild(cpNode, "hh:underline");
+    const strikeoutNode = findChild(cpNode, "hh:strikeout");
+    const underline = underlineNode ? attrStr(underlineNode, "type", "NONE") : attrStr(cpNode, "underline", "NONE");
+    const strikeout = strikeoutNode ? attrStr(strikeoutNode, "shape", "NONE") === "NONE" ? "NONE" : "CONTINUOUS" : attrStr(cpNode, "strikeout", "NONE");
     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"),
+      shadeColor: cpNode.attrs["shadeColor"] && cpNode.attrs["shadeColor"] !== "none" ? parseColor(attrStr(cpNode, "shadeColor")) : void 0,
+      bold: hasBoldElement || attrBool(cpNode, "bold"),
+      italic: hasItalicElement || attrBool(cpNode, "italic"),
+      underline,
+      strikeout,
       useFontSpace: attrBool(cpNode, "useFontSpace"),
       useKerning: attrBool(cpNode, "useKerning"),
       spacing: cpNode.attrs["spacing"] !== void 0 ? attrInt(cpNode, "spacing") : void 0,
@@ -926,24 +934,54 @@ function parseParaProperties(root) {
   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");
+    const alignNode = findChild(ppNode, "hh:align");
+    const alignment = alignNode ? attrStr(alignNode, "horizontal", "JUSTIFY") : attrStr(ppNode, "align", "JUSTIFY");
+    let marginNode = findChild(ppNode, "hh:parMargin") || findChild(ppNode, "hh:margin");
+    let lineSpacingNode = findChild(ppNode, "hh:lineSpacing");
+    const switchNode = findChild(ppNode, "hp:switch");
+    if (switchNode) {
+      const caseNode = findChild(switchNode, "hp:case");
+      if (caseNode) {
+        if (!marginNode) marginNode = findChild(caseNode, "hh:margin");
+        if (!lineSpacingNode) lineSpacingNode = findChild(caseNode, "hh:lineSpacing");
+      }
+    }
+    let paraMargin = { left: 0, right: 0, indent: 0, prevSpacing: 0, nextSpacing: 0 };
+    if (marginNode) {
+      const leftChild = findChild(marginNode, "hc:left");
+      if (leftChild) {
+        const intentChild = findChild(marginNode, "hc:intent");
+        const rightChild = findChild(marginNode, "hc:right");
+        const prevChild = findChild(marginNode, "hc:prev");
+        const nextChild = findChild(marginNode, "hc:next");
+        paraMargin = {
+          left: leftChild ? attrInt(leftChild, "value") : 0,
+          right: rightChild ? attrInt(rightChild, "value") : 0,
+          indent: intentChild ? attrInt(intentChild, "value") : 0,
+          prevSpacing: prevChild ? attrInt(prevChild, "value") : 0,
+          nextSpacing: nextChild ? attrInt(nextChild, "value") : 0
+        };
+      } else {
+        paraMargin = {
+          left: attrInt(marginNode, "left"),
+          right: attrInt(marginNode, "right"),
+          indent: attrInt(marginNode, "indent"),
+          prevSpacing: attrInt(marginNode, "prev"),
+          nextSpacing: attrInt(marginNode, "next")
+        };
+      }
+    }
+    const headingNode = findChild(ppNode, "hh:heading");
     props.push({
       id: attrInt(ppNode, "id"),
-      alignment: attrStr(ppNode, "align", "JUSTIFY"),
-      heading: ppNode.attrs["heading"] ? ppNode.attrs["heading"] : void 0,
+      alignment,
+      heading: headingNode ? attrStr(headingNode, "type", "NONE") : 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 }
+      paraMargin
     });
   }
   return props;
@@ -1015,12 +1053,24 @@ function parseSectionXml(xml) {
   };
 }
 function parseSectionDef(root) {
-  const secPr = findChild(root, "hs:secPr");
+  let secPr = findChild(root, "hs:secPr");
+  if (!secPr) {
+    for (const p of findChildren(root, "hp:p")) {
+      for (const run of findChildren(p, "hp:run")) {
+        const found = findChild(run, "hp:secPr");
+        if (found) {
+          secPr = found;
+          break;
+        }
+      }
+      if (secPr) break;
+    }
+  }
   if (!secPr) {
     return defaultSectionDef();
   }
-  const pagePr = findChild(secPr, "hs:pagePr");
-  const pageMarginNode = findChild(secPr, "hs:pageMargin");
+  const pagePr = findChild(secPr, "hp:pagePr") || findChild(secPr, "hs:pagePr");
+  const pageMarginNode = findChild(secPr, "hs:pageMargin") || (pagePr ? findChild(pagePr, "hp:margin") || findChild(pagePr, "hs:margin") : void 0);
   const colPr = findChild(secPr, "hs:colPr");
   let columns;
   if (colPr && attrInt(colPr, "count", 1) > 1) {
@@ -1046,7 +1096,7 @@ function parseSectionDef(root) {
   return {
     pageWidth: pagePr ? attrInt(pagePr, "width", 59528) : 59528,
     pageHeight: pagePr ? attrInt(pagePr, "height", 84188) : 84188,
-    landscape: pagePr ? attrStr(pagePr, "landscape") === "LANDSCAPE" : false,
+    landscape: pagePr ? attrStr(pagePr, "landscape") === "LANDSCAPE" || attrStr(pagePr, "landscape") === "WIDELY" : false,
     gutterType: pagePr ? attrStr(pagePr, "gutterType", "LEFT_ONLY") : "LEFT_ONLY",
     pageMargin: pageMarginNode ? parsePageMargin(pageMarginNode) : defaultPageMargin(),
     columns,
@@ -1076,11 +1126,11 @@ function parseParagraph(pNode) {
   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 pageBreak2 = findChild(runNode, "hp:pageBreak");
     const colBreak = findChild(runNode, "hp:colBreak");
     if (lineBreak) {
       runs.push({ t: "break", breakType: "LINE", charPrIDRef });
-    } else if (pageBreak) {
+    } else if (pageBreak2) {
       runs.push({ t: "break", breakType: "PAGE", charPrIDRef });
     } else if (colBreak) {
       runs.push({ t: "break", breakType: "COLUMN", charPrIDRef });
@@ -1095,29 +1145,36 @@ function parseParagraph(pNode) {
         runs.push({ t: "picture", picture: parsePicture(picNode), charPrIDRef });
         continue;
       }
-      const runTextNode = findChild(runNode, "hp:runText");
+      const runTextNode = findChild(runNode, "hp:runText") || findChild(runNode, "hp:t");
       const text = runTextNode ? getTextContent(runTextNode) : "";
       runs.push({ t: "text", text, charPrIDRef });
     }
   }
+  const pageBreakVal = attrStr(pNode, "pageBreak", "0");
+  const pageBreak = pageBreakVal === "1" || pageBreakVal === "true";
   return {
     paraPrIDRef: attrInt(pNode, "paraPrIDRef"),
     styleIDRef: attrInt(pNode, "styleIDRef"),
-    runs
+    runs,
+    ...pageBreak ? { pageBreak: true } : {}
   };
 }
 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 szNode = findChild(tblNode, "hp:sz");
+  const width = szNode ? attrInt(szNode, "width", 0) : attrInt(tblNode, "width", 0);
   const colSzNodes = findChildren(tblNode, "hp:colSz");
-  const colWidths = colSzNodes.map((n) => attrInt(n, "width", 0));
+  let colWidths = colSzNodes.map((n) => attrInt(n, "width", 0));
   const rows = [];
   for (const trNode of findChildren(tblNode, "hp:tr")) {
     rows.push(parseTableRow(trNode));
   }
+  if (colWidths.length === 0 && rows.length > 0) {
+    colWidths = rows[0].cells.map((c) => c.width);
+  }
   return {
     rowCount,
     colCount,
@@ -1129,21 +1186,31 @@ function parseTable(tblNode) {
   };
 }
 function parseTableRow(trNode) {
-  const height = attrInt(trNode, "height", 0);
   const cells = [];
   for (const tcNode of findChildren(trNode, "hp:tc")) {
     cells.push(parseTableCell(tcNode));
   }
+  const height = attrInt(trNode, "height", 0) || (cells.length > 0 ? cells[0].height : 0);
   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 cellSpanNode = findChild(tcNode, "hp:cellSpan");
+  const colSpan = cellSpanNode ? attrInt(cellSpanNode, "colSpan", 1) : attrInt(tcNode, "colSpan", 1);
+  const rowSpan = cellSpanNode ? attrInt(cellSpanNode, "rowSpan", 1) : attrInt(tcNode, "rowSpan", 1);
+  const cellSzNode = findChild(tcNode, "hp:cellSz");
+  const width = cellSzNode ? attrInt(cellSzNode, "width", 0) : attrInt(tcNode, "width", 0);
+  const height = cellSzNode ? attrInt(cellSzNode, "height", 0) : attrInt(tcNode, "height", 0);
   const borderFillIDRef = attrInt(tcNode, "borderFillIDRef", 1);
   let padding;
-  if (tcNode.attrs["paddingLeft"] !== void 0) {
+  const cellMarginNode = findChild(tcNode, "hp:cellMargin");
+  if (cellMarginNode) {
+    padding = {
+      left: attrInt(cellMarginNode, "left"),
+      right: attrInt(cellMarginNode, "right"),
+      top: attrInt(cellMarginNode, "top"),
+      bottom: attrInt(cellMarginNode, "bottom")
+    };
+  } else if (tcNode.attrs["paddingLeft"] !== void 0) {
     padding = {
       left: attrInt(tcNode, "paddingLeft"),
       right: attrInt(tcNode, "paddingRight"),
@@ -2060,6 +2127,303 @@ function detectFormat(data) {
   return "unknown";
 }
 
+// src/codecs/pdf/writer.ts
+var PdfBuilder = class {
+  constructor() {
+    this.objects = [];
+    this.offsets = [];
+    this.output = "";
+  }
+  nextId() {
+    return this.objects.length + 1;
+  }
+  addObject(content) {
+    const id = this.nextId();
+    this.objects.push(content);
+    return id;
+  }
+  build() {
+    this.output = "%PDF-1.4\n%\xC0\xC1\xC2\xC3\n";
+    for (let i = 0; i < this.objects.length; i++) {
+      this.offsets.push(this.output.length);
+      this.output += `${i + 1} 0 obj
+${this.objects[i]}
+endobj
+`;
+    }
+    const xrefOffset = this.output.length;
+    this.output += "xref\n";
+    this.output += `0 ${this.objects.length + 1}
+`;
+    this.output += "0000000000 65535 f \n";
+    for (const off of this.offsets) {
+      this.output += off.toString().padStart(10, "0") + " 00000 n \n";
+    }
+    this.output += "trailer\n";
+    this.output += `<< /Size ${this.objects.length + 1} /Root 1 0 R >>
+`;
+    this.output += "startxref\n";
+    this.output += `${xrefOffset}
+`;
+    this.output += "%%EOF\n";
+    return stringToBytes(this.output);
+  }
+};
+function writePdf(doc, opts) {
+  const korFont = opts?.fontName || "Malgun Gothic";
+  const latFont = opts?.latinFontName || "Helvetica";
+  const pdf = new PdfBuilder();
+  const catalogId = pdf.addObject("");
+  const pagesId = pdf.addObject("");
+  const cidFontId = pdf.addObject(
+    `<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${sanitizeName(korFont)} /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /DW 1000 >>`
+  );
+  const korFontId = pdf.addObject(
+    `<< /Type /Font /Subtype /Type0 /BaseFont /${sanitizeName(korFont)} /Encoding /Identity-H /DescendantFonts [${cidFontId} 0 R] /ToUnicode ${pdf.nextId() + 1} 0 R >>`
+  );
+  const cmapStream = buildToUnicodeCMap();
+  const cmapId = pdf.addObject(
+    `<< /Length ${cmapStream.length} >>
+stream
+${cmapStream}
+endstream`
+  );
+  pdf.objects[korFontId - 1] = `<< /Type /Font /Subtype /Type0 /BaseFont /${sanitizeName(korFont)} /Encoding /Identity-H /DescendantFonts [${cidFontId} 0 R] /ToUnicode ${cmapId} 0 R >>`;
+  const latFontId = pdf.addObject(
+    `<< /Type /Font /Subtype /Type1 /BaseFont /${sanitizeName(latFont)} /Encoding /WinAnsiEncoding >>`
+  );
+  const fontResources = `/F1 ${korFontId} 0 R /F2 ${latFontId} 0 R`;
+  const pageIds = [];
+  for (const section of doc.sections) {
+    const pageW = section.def.pageWidth / 7200 * 72;
+    const pageH = section.def.pageHeight / 7200 * 72;
+    const ml = section.def.pageMargin.left / 7200 * 72;
+    const mr = section.def.pageMargin.right / 7200 * 72;
+    const mt = section.def.pageMargin.top / 7200 * 72;
+    const mb = section.def.pageMargin.bottom / 7200 * 72;
+    const bodyW = pageW - ml - mr;
+    const bodyH = pageH - mt - mb;
+    const ctx = {
+      doc,
+      pdf,
+      pagesId,
+      fontResources,
+      pageW,
+      pageH,
+      ml,
+      mr,
+      mt,
+      mb,
+      bodyW,
+      bodyH,
+      pageIds
+    };
+    renderSection(ctx, section);
+  }
+  pdf.objects[0] = `<< /Type /Catalog /Pages ${pagesId} 0 R >>`;
+  const kids = pageIds.map((id) => `${id} 0 R`).join(" ");
+  pdf.objects[1] = `<< /Type /Pages /Kids [${kids}] /Count ${pageIds.length} >>`;
+  return pdf.build();
+}
+function renderSection(ctx, section) {
+  let page = newPage(ctx);
+  for (const para of section.paragraphs) {
+    for (const run of para.runs) {
+      if (run.t === "text") {
+        const fontSize = getFontSize(ctx.doc, run.charPrIDRef);
+        const lineHeight = fontSize * 1.6;
+        if (page.y - lineHeight < 0) {
+          flushPage(ctx, page);
+          page = newPage(ctx);
+        }
+        if (run.text) {
+          const color = getTextColor(ctx.doc, run.charPrIDRef);
+          const bold = isBold(ctx.doc, run.charPrIDRef);
+          if (color !== "0 0 0") {
+            page.ops.push(color + " rg");
+          }
+          const lines = wrapText(run.text, fontSize, ctx.bodyW);
+          for (const line of lines) {
+            if (page.y - lineHeight < 0) {
+              flushPage(ctx, page);
+              page = newPage(ctx);
+            }
+            page.ops.push("BT");
+            page.ops.push(`/F1 ${fontSize} Tf`);
+            page.ops.push(`${ctx.ml} ${ctx.mt + page.y - lineHeight} Td`);
+            page.ops.push(`<${toUtf16Hex(line)}> Tj`);
+            page.ops.push("ET");
+            page.y -= lineHeight;
+          }
+          if (color !== "0 0 0") {
+            page.ops.push("0 0 0 rg");
+          }
+        } else {
+          page.y -= fontSize * 1.6;
+        }
+      } else if (run.t === "table") {
+        const tableHeight = estimateTableHeight(run.table, ctx.doc);
+        if (page.y - tableHeight < 0 && page.y < ctx.bodyH - 10) {
+          flushPage(ctx, page);
+          page = newPage(ctx);
+        }
+        renderTable(ctx, page, run.table);
+      }
+    }
+  }
+  flushPage(ctx, page);
+}
+function newPage(ctx) {
+  return { ops: [], y: ctx.bodyH };
+}
+function flushPage(ctx, page) {
+  if (page.ops.length === 0) return;
+  const stream = page.ops.join("\n");
+  const streamId = ctx.pdf.addObject(
+    `<< /Length ${byteLength(stream)} >>
+stream
+${stream}
+endstream`
+  );
+  const pageId = ctx.pdf.addObject(
+    `<< /Type /Page /Parent ${ctx.pagesId} 0 R /MediaBox [0 0 ${fmt(ctx.pageW)} ${fmt(ctx.pageH)}] /Resources << /Font << ${ctx.fontResources} >> >> /Contents ${streamId} 0 R >>`
+  );
+  ctx.pageIds.push(pageId);
+}
+function renderTable(ctx, page, table) {
+  const tableW = table.width / 7200 * 72;
+  const scale = Math.min(1, ctx.bodyW / tableW);
+  const startX = ctx.ml;
+  const startY = ctx.mt + page.y;
+  for (const row of table.rows) {
+    const rowH = row.height / 7200 * 72 * scale;
+    let cellX = startX;
+    for (const cell of row.cells) {
+      const cellW = cell.width / 7200 * 72 * scale;
+      const cellH = cell.height / 7200 * 72 * scale;
+      const cellY = startY - rowH;
+      page.ops.push("0.5 w");
+      page.ops.push(`${fmt(cellX)} ${fmt(cellY)} ${fmt(cellW)} ${fmt(cellH)} re S`);
+      const text = cell.paragraphs.flatMap((p) => p.runs.filter((r) => r.t === "text").map((r) => r.text)).join(" ");
+      if (text) {
+        const fontSize = 8 * scale;
+        const textX = cellX + 3;
+        const textY = cellY + cellH - fontSize - 2;
+        page.ops.push("BT");
+        page.ops.push(`/F1 ${fmt(fontSize)} Tf`);
+        page.ops.push(`${fmt(textX)} ${fmt(textY)} Td`);
+        page.ops.push(`<${toUtf16Hex(text.substring(0, 100))}> Tj`);
+        page.ops.push("ET");
+      }
+      cellX += cellW;
+    }
+    page.y -= rowH;
+    startY === ctx.mt + page.y + rowH;
+  }
+}
+function estimateTableHeight(table, doc) {
+  let h = 0;
+  for (const row of table.rows) {
+    h += row.height / 7200 * 72;
+  }
+  return h;
+}
+function getFontSize(doc, charPrIDRef) {
+  const cp = doc.head.charProperties.find((c) => c.id === charPrIDRef);
+  if (!cp) return 10;
+  return cp.height / 100;
+}
+function getTextColor(doc, charPrIDRef) {
+  const cp = doc.head.charProperties.find((c) => c.id === charPrIDRef);
+  if (!cp || cp.textColor === 0) return "0 0 0";
+  const r = (cp.textColor & 255) / 255;
+  const g = (cp.textColor >> 8 & 255) / 255;
+  const b = (cp.textColor >> 16 & 255) / 255;
+  return `${fmt(r)} ${fmt(g)} ${fmt(b)}`;
+}
+function isBold(doc, charPrIDRef) {
+  const cp = doc.head.charProperties.find((c) => c.id === charPrIDRef);
+  return cp?.bold || false;
+}
+function wrapText(text, fontSize, maxWidth) {
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  for (const ch of text) {
+    const w = ch.charCodeAt(0) > 127 ? fontSize : fontSize * 0.5;
+    if (currentWidth + w > maxWidth && current) {
+      lines.push(current);
+      current = "";
+      currentWidth = 0;
+    }
+    current += ch;
+    currentWidth += w;
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [""];
+}
+function buildToUnicodeCMap() {
+  return [
+    "/CIDInit /ProcSet findresource begin",
+    "12 dict begin",
+    "begincmap",
+    "/CIDSystemInfo",
+    "<< /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+    "/CMapName /Adobe-Identity-UCS def",
+    "/CMapType 2 def",
+    "1 begincodespacerange",
+    "<0000> <FFFF>",
+    "endcodespacerange",
+    "1 beginbfrange",
+    "<0000> <FFFF> <0000>",
+    "endbfrange",
+    "endcmap",
+    "CMapName currentdict /CMap defineresource pop",
+    "end",
+    "end"
+  ].join("\n");
+}
+function toUtf16Hex(str) {
+  let hex = "";
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    hex += code.toString(16).padStart(4, "0");
+  }
+  return hex.toUpperCase();
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "");
+}
+function fmt(n) {
+  return Number(n.toFixed(2)).toString();
+}
+function byteLength(str) {
+  let len = 0;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code <= 127) len++;
+    else if (code <= 2047) len += 2;
+    else len += 3;
+  }
+  return len;
+}
+function stringToBytes(str) {
+  const bytes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code <= 255) {
+      bytes.push(code);
+    } else {
+      if (code <= 2047) {
+        bytes.push(192 | code >> 6, 128 | code & 63);
+      } else {
+        bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+      }
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
 // src/utils/id.ts
 var IdCounter = class {
   constructor(start = 0) {
@@ -2392,6 +2756,9 @@ function read(data, opts) {
   }
   return readHwpx(data, opts);
 }
+function writePdf2(doc, opts) {
+  return writePdf(doc, opts);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HWPXBuilder,
@@ -2408,6 +2775,7 @@ function read(data, opts) {
   createDefaultStyles,
   read,
   utils,
-  write
+  write,
+  writePdf
 });
 //# sourceMappingURL=index.cjs.map