@masumdev/markforge 0.4.1 → 0.5.0

package/dist/index.mjs

@@ -14,8 +14,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/core/engine.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 
 // src/core/parser.ts
 import matter from "gray-matter";
@@ -591,12 +591,14 @@ import {
   ExternalHyperlink,
   TabStopType,
   PageBreak,
-  NumberFormat
+  NumberFormat,
+  SectionType
 } from "docx";
 
 // src/core/imageResolver.ts
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
 var memoryImageCache = /* @__PURE__ */ new Map();
 function getMimeType(filePathOrUrl) {
   const clean = filePathOrUrl.split("?")[0].toLowerCase();
@@ -653,9 +655,19 @@ async function resolveImage(src, baseDir = process.cwd()) {
       memoryImageCache.set(cacheKey, resolved2);
       return resolved2;
     }
-    let localPath = path.isAbsolute(src) ? src : path.resolve(baseDir, src);
+    let localPath = src;
+    if (src.startsWith("file://")) {
+      try {
+        localPath = fileURLToPath(src);
+      } catch {
+        localPath = src;
+      }
+    }
+    if (!path.isAbsolute(localPath)) {
+      localPath = path.resolve(baseDir, localPath);
+    }
     if (!fs.existsSync(localPath)) {
-      const cwdPath = path.resolve(process.cwd(), src);
+      const cwdPath = path.resolve(process.cwd(), src.startsWith("file://") ? localPath : src);
       if (fs.existsSync(cwdPath)) {
         localPath = cwdPath;
       } else {
@@ -1078,6 +1090,7 @@ var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
   OutputFormat2["PDF"] = "pdf";
   OutputFormat2["HTML"] = "html";
   OutputFormat2["PNG"] = "png";
+  OutputFormat2["TXT"] = "txt";
   return OutputFormat2;
 })(OutputFormat || {});
 var Theme = /* @__PURE__ */ ((Theme2) => {
@@ -1112,6 +1125,33 @@ var WatermarkPosition = /* @__PURE__ */ ((WatermarkPosition2) => {
   WatermarkPosition2["BOTTOM_RIGHT"] = "bottom-right";
   return WatermarkPosition2;
 })(WatermarkPosition || {});
+var CoverPagePreset = /* @__PURE__ */ ((CoverPagePreset2) => {
+  CoverPagePreset2["MODERN"] = "modern";
+  CoverPagePreset2["CORPORATE_SPLIT"] = "corporate-split";
+  CoverPagePreset2["MINIMAL"] = "minimal";
+  CoverPagePreset2["CARD"] = "card";
+  return CoverPagePreset2;
+})(CoverPagePreset || {});
+var BackCoverPreset = /* @__PURE__ */ ((BackCoverPreset2) => {
+  BackCoverPreset2["MODERN"] = "modern";
+  BackCoverPreset2["CORPORATE"] = "corporate";
+  BackCoverPreset2["MINIMAL"] = "minimal";
+  BackCoverPreset2["CONTACT_CARD"] = "contact-card";
+  return BackCoverPreset2;
+})(BackCoverPreset || {});
+var SignatureAlign = /* @__PURE__ */ ((SignatureAlign2) => {
+  SignatureAlign2["LEFT"] = "left";
+  SignatureAlign2["CENTER"] = "center";
+  SignatureAlign2["RIGHT"] = "right";
+  SignatureAlign2["SPACE_BETWEEN"] = "space-between";
+  return SignatureAlign2;
+})(SignatureAlign || {});
+var SignatureStyle = /* @__PURE__ */ ((SignatureStyle2) => {
+  SignatureStyle2["LINE"] = "line";
+  SignatureStyle2["BOX"] = "box";
+  SignatureStyle2["CLEAN"] = "clean";
+  return SignatureStyle2;
+})(SignatureStyle || {});
 
 // src/core/html/htmlThemes.ts
 var THEME_COMPONENTS = `
@@ -2426,7 +2466,7 @@ async function renderBackCoverHtml(backCover, baseDir = process.cwd()) {
 `;
   return { html, css };
 }
-async function buildHtmlDocument(doc, config, baseDir = process.cwd()) {
+async function buildHtmlDocument(doc, config = {}, baseDir = process.cwd()) {
   var _a, _b;
   const resolved = resolveDocumentConfig(doc.metadata, config);
   const baseThemeCss = generateThemeCss(resolved.theme);
@@ -2777,8 +2817,11 @@ function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function generateWatermarkPngBuffer(chromePath, wm) {
-  const tmpHtml = path4.join(os.tmpdir(), `markforge-wm-${Date.now()}-${Math.random().toString(36).slice(2)}.html`);
-  const tmpPng = path4.join(os.tmpdir(), `markforge-wm-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
+  const tmpId = Math.random().toString(36).substring(2, 9);
+  const tmpDir = os.tmpdir();
+  const tmpHtml = path4.join(tmpDir, `markforge-wm-${tmpId}.html`);
+  const tmpPng = path4.join(tmpDir, `markforge-wm-${tmpId}.png`);
+  const tmpProfile = path4.join(tmpDir, `markforge-wm-prof-${tmpId}`);
   try {
     const text = escapeXml(wm.text.toUpperCase());
     const fontSize = (wm.fontSize || 52) * 1.5;
@@ -2829,6 +2872,9 @@ function generateWatermarkPngBuffer(chromePath, wm) {
       chromePath,
       [
         "--headless=new",
+        `--user-data-dir=${tmpProfile}`,
+        "--no-first-run",
+        "--no-default-browser-check",
         "--disable-gpu",
         "--disable-sync",
         "--disable-extensions",
@@ -2850,6 +2896,7 @@ function generateWatermarkPngBuffer(chromePath, wm) {
     try {
       if (fs4.existsSync(tmpHtml)) fs4.unlinkSync(tmpHtml);
       if (fs4.existsSync(tmpPng)) fs4.unlinkSync(tmpPng);
+      if (fs4.existsSync(tmpProfile)) fs4.rmSync(tmpProfile, { recursive: true, force: true });
     } catch {
     }
   }
@@ -2865,6 +2912,8 @@ function findChromeExecutable() {
   const winLocalAppData = process.env.LOCALAPPDATA ?? "";
   const winProgramFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
   const winProgramFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
+  const winProgramW6432 = process.env.ProgramW6432 ?? "C:\\Program Files";
+  const winUserProfile = process.env.USERPROFILE ?? "";
   const candidates = [
     // Linux
     "/usr/bin/google-chrome",
@@ -2883,17 +2932,34 @@ function findChromeExecutable() {
     // Windows — Microsoft Edge (Native Windows 10/11 browser, enterprise whitelist friendly)
     `${winProgramFiles}\\Microsoft\\Edge\\Application\\msedge.exe`,
     `${winProgramFilesX86}\\Microsoft\\Edge\\Application\\msedge.exe`,
+    `${winProgramW6432}\\Microsoft\\Edge\\Application\\msedge.exe`,
     `${winLocalAppData}\\Microsoft\\Edge\\Application\\msedge.exe`,
-    // Windows — Google Chrome
+    `${winLocalAppData}\\Microsoft\\Edge Dev\\Application\\msedge.exe`,
+    `${winLocalAppData}\\Microsoft\\Edge Beta\\Application\\msedge.exe`,
+    // Windows — Google Chrome & Chrome SxS (Canary)
     `${winProgramFiles}\\Google\\Chrome\\Application\\chrome.exe`,
     `${winProgramFilesX86}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${winProgramW6432}\\Google\\Chrome\\Application\\chrome.exe`,
     `${winLocalAppData}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${winLocalAppData}\\Google\\Chrome SxS\\Application\\chrome.exe`,
     // Windows — Brave Browser
     `${winProgramFiles}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
     `${winProgramFilesX86}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+    `${winProgramW6432}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
     `${winLocalAppData}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
     // Windows — Chromium
-    `${winLocalAppData}\\Chromium\\Application\\chrome.exe`
+    `${winLocalAppData}\\Chromium\\Application\\chrome.exe`,
+    // Windows — Scoop Package Manager
+    `${winUserProfile}\\scoop\\apps\\googlechrome\\current\\chrome.exe`,
+    `${winUserProfile}\\scoop\\apps\\chromium\\current\\chrome.exe`,
+    `${winUserProfile}\\scoop\\apps\\brave\\current\\brave.exe`,
+    `${winUserProfile}\\scoop\\apps\\msedge\\current\\msedge.exe`,
+    `${winUserProfile}\\scoop\\shims\\chrome.exe`,
+    `${winUserProfile}\\scoop\\shims\\msedge.exe`,
+    // Windows — Chocolatey
+    "C:\\ProgramData\\chocolatey\\bin\\chrome.exe",
+    "C:\\ProgramData\\chocolatey\\bin\\msedge.exe",
+    "C:\\ProgramData\\chocolatey\\bin\\brave.exe"
   ].filter(Boolean);
   for (const candidate of candidates) {
     try {
@@ -2904,13 +2970,15 @@ function findChromeExecutable() {
     }
   }
   try {
-    const cmd = isWin ? "where" : "which";
-    const names = isWin ? ["chrome", "msedge", "brave", "google-chrome", "chromium", "chromium-browser"] : ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"];
+    const cmd = isWin ? "where.exe" : "which";
+    const names = isWin ? ["chrome.exe", "msedge.exe", "brave.exe", "chrome", "msedge", "brave", "google-chrome", "chromium", "chromium-browser"] : ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"];
     for (const name of names) {
-      const res = spawnSync(cmd, [name], { encoding: "utf-8" });
+      const res = spawnSync(cmd, [name], { encoding: "utf-8", windowsHide: true });
       if (res.status === 0 && res.stdout.trim()) {
-        const binPath = res.stdout.split(/\r?\n/)[0].trim();
-        if (fs4.existsSync(binPath)) return binPath;
+        const lines = res.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+        for (const line of lines) {
+          if (fs4.existsSync(line)) return line;
+        }
       }
     }
   } catch {
@@ -3244,6 +3312,8 @@ async function renderMermaidToPng(mermaidCode, _baseDir = process.cwd()) {
   const tmpDir = os2.tmpdir();
   const tmpHtml = path5.join(tmpDir, `mermaid_${tmpId}.html`);
   const tmpScreenshot = path5.join(tmpDir, `mermaid_${tmpId}.png`);
+  const tmpProfile = path5.join(tmpDir, `mermaid_prof_${tmpId}`);
+  const isWin = process.platform === "win32";
   const htmlContent = `<!DOCTYPE html>
 <html>
 <head>
@@ -3287,10 +3357,14 @@ ${mermaidCode}
     const res = spawnSync2(
       chromePath,
       [
-        "--headless",
+        "--headless=new",
+        `--user-data-dir=${tmpProfile}`,
+        "--no-first-run",
+        "--no-default-browser-check",
         "--disable-gpu",
-        "--no-sandbox",
-        "--disable-setuid-sandbox",
+        "--disable-sync",
+        "--disable-extensions",
+        ...isWin ? [] : ["--no-sandbox", "--disable-setuid-sandbox"],
         "--allow-file-access-from-files",
         "--disable-web-security",
         "--disable-software-rasterizer",
@@ -3299,7 +3373,7 @@ ${mermaidCode}
         `--screenshot=${tmpScreenshot}`,
         fileUrl
       ],
-      { timeout: 15e3 }
+      { timeout: 15e3, windowsHide: true }
     );
     if (res.status === 0 && fs5.existsSync(tmpScreenshot)) {
       const buffer = fs5.readFileSync(tmpScreenshot);
@@ -3310,6 +3384,7 @@ ${mermaidCode}
     try {
       if (fs5.existsSync(tmpHtml)) fs5.unlinkSync(tmpHtml);
       if (fs5.existsSync(tmpScreenshot)) fs5.unlinkSync(tmpScreenshot);
+      if (fs5.existsSync(tmpProfile)) fs5.rmSync(tmpProfile, { recursive: true, force: true });
     } catch {
     }
   }
@@ -4451,6 +4526,7 @@ async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
     );
     docSections.push({
       properties: {
+        type: SectionType.NEXT_PAGE,
         page: {
           size: {
             width: resolved.paperDimensions.widthTwip,
@@ -4465,13 +4541,14 @@ async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
           }
         }
       },
-      headers: void 0,
-      footers: void 0,
+      headers: { default: new Header({ children: [] }) },
+      footers: { default: new Footer({ children: [] }) },
       children: coverElements
     });
   }
   docSections.push({
     properties: {
+      type: SectionType.NEXT_PAGE,
       page: {
         pageNumbers: {
           start: 1,
@@ -4492,8 +4569,8 @@ async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
         }
       }
     },
-    headers: docHeader ? { default: docHeader } : void 0,
-    footers: docFooter ? { default: docFooter } : void 0,
+    headers: docHeader ? { default: docHeader } : { default: new Header({ children: [] }) },
+    footers: docFooter ? { default: docFooter } : { default: new Footer({ children: [] }) },
     children: docElements
   });
   if (resolved.backCover && resolved.backCover.enabled) {
@@ -4508,6 +4585,7 @@ async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
     );
     docSections.push({
       properties: {
+        type: SectionType.NEXT_PAGE,
         page: {
           size: {
             width: resolved.paperDimensions.widthTwip,
@@ -4522,8 +4600,8 @@ async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
           }
         }
       },
-      headers: void 0,
-      footers: void 0,
+      headers: { default: new Header({ children: [] }) },
+      footers: { default: new Footer({ children: [] }) },
       children: backElements
     });
   }
@@ -4926,6 +5004,432 @@ function createEmptyDocxCell(widthDxa) {
   });
 }
 
+// src/core/text/textBuilder.ts
+var LINE_WIDTH = 80;
+var HR_DOUBLE = "=".repeat(LINE_WIDTH);
+var HR_SINGLE = "-".repeat(LINE_WIDTH);
+function centerText(text, width = LINE_WIDTH) {
+  if (text.length >= width) return text;
+  const leftPad = Math.floor((width - text.length) / 2);
+  return " ".repeat(leftPad) + text;
+}
+function renderInlinesToText(spans = [], meta = {}) {
+  let result = "";
+  for (const span of spans) {
+    switch (span.type) {
+      case "text": {
+        const content = replaceDocumentTokens(span.content, meta);
+        result += content;
+        break;
+      }
+      case "bold": {
+        const inner = span.children ? renderInlinesToText(span.children, meta) : replaceDocumentTokens(span.content, meta);
+        result += `**${inner}**`;
+        break;
+      }
+      case "italic": {
+        const inner = span.children ? renderInlinesToText(span.children, meta) : replaceDocumentTokens(span.content, meta);
+        result += `*${inner}*`;
+        break;
+      }
+      case "code": {
+        result += `\`${span.content}\``;
+        break;
+      }
+      case "link": {
+        const inner = span.children ? renderInlinesToText(span.children, meta) : replaceDocumentTokens(span.content, meta);
+        result += span.url && span.url !== inner ? `${inner} (${span.url})` : inner;
+        break;
+      }
+      case "image": {
+        result += `[Image: ${span.alt || "image"} (${span.url || ""})]`;
+        break;
+      }
+      case "strikethrough": {
+        const inner = span.children ? renderInlinesToText(span.children, meta) : replaceDocumentTokens(span.content, meta);
+        result += `~${inner}~`;
+        break;
+      }
+      case "mathInline": {
+        result += `$${span.content}$`;
+        break;
+      }
+      case "footnoteRef": {
+        const id = span.footnoteId || span.content;
+        result += `[${id}]`;
+        break;
+      }
+      case "htmlInline": {
+        result += span.content.replace(/<[^>]+>/g, "");
+        break;
+      }
+      default: {
+        result += span.content || "";
+        break;
+      }
+    }
+  }
+  return result;
+}
+async function buildTextDocument(doc, config = {}, _baseDir = process.cwd()) {
+  const resolved = resolveDocumentConfig(doc.metadata, config);
+  const meta = {
+    ...doc.metadata,
+    ...config.metadata,
+    title: resolved.title,
+    subtitle: resolved.subtitle,
+    author: resolved.author,
+    company: resolved.company,
+    version: resolved.version,
+    date: resolved.date
+  };
+  const nodes = JSON.parse(JSON.stringify(doc.nodes));
+  const tocEntries = JSON.parse(JSON.stringify(doc.tocEntries));
+  if (resolved.numberHeadings && resolved.numberHeadings.enabled) {
+    applyHeadingNumbering(nodes, tocEntries, resolved.numberHeadings);
+  }
+  const lines = [];
+  if (resolved.coverPage && resolved.coverPage.enabled) {
+    const cover = resolved.coverPage;
+    const coverTitle = (cover.title || meta.title || "DOCUMENT").toUpperCase();
+    const coverSubtitle = cover.subtitle || meta.subtitle || "";
+    const coverAuthor = cover.author || meta.author || "";
+    const coverCompany = cover.company || meta.company || "";
+    const coverDate = cover.date || meta.date || "";
+    const coverVersion = cover.version || meta.version || "";
+    const coverBadge = cover.badge || "";
+    const coverFooter = cover.footerText || "";
+    lines.push(HR_DOUBLE);
+    lines.push(centerText(coverTitle));
+    if (coverSubtitle) {
+      lines.push(centerText(coverSubtitle));
+    }
+    lines.push(HR_DOUBLE);
+    if (coverBadge) {
+      lines.push(`[${coverBadge}]`);
+      lines.push("");
+    }
+    if (coverAuthor) lines.push(`Author:     ${coverAuthor}`);
+    if (coverCompany) lines.push(`Company:    ${coverCompany}`);
+    if (coverDate) lines.push(`Date:       ${coverDate}`);
+    if (coverVersion) lines.push(`Version:    ${coverVersion}`);
+    if (coverFooter) lines.push(`Notice:     ${coverFooter}`);
+    lines.push(HR_DOUBLE);
+    lines.push("");
+    lines.push("");
+  }
+  if (resolved.toc) {
+    const headings = nodes.filter(
+      (n) => n.type === "heading" && (n.level || 1) <= 3
+    );
+    if (headings.length > 0) {
+      const tocTitle = "TABLE OF CONTENTS";
+      lines.push(HR_DOUBLE);
+      lines.push(centerText(tocTitle));
+      lines.push(HR_DOUBLE);
+      for (const h of headings) {
+        const level = h.level || 1;
+        const indent = "  ".repeat(level - 1);
+        const headingText = renderInlinesToText(h.inlines, meta);
+        const prefix = level === 1 ? "* " : "- ";
+        lines.push(`${indent}${prefix}${headingText}`);
+      }
+      lines.push(HR_DOUBLE);
+      lines.push("");
+      lines.push("");
+    }
+  }
+  function renderNode(node, listLevel = 0) {
+    var _a;
+    switch (node.type) {
+      case "heading": {
+        const level = node.level || 1;
+        const text = renderInlinesToText(node.inlines, meta);
+        lines.push("");
+        if (level === 1) {
+          lines.push(HR_DOUBLE);
+          lines.push(text.toUpperCase());
+          lines.push(HR_DOUBLE);
+        } else if (level === 2) {
+          lines.push(HR_SINGLE);
+          lines.push(text);
+          lines.push(HR_SINGLE);
+        } else {
+          const hashes = "#".repeat(level);
+          lines.push(`${hashes} ${text}`);
+        }
+        lines.push("");
+        break;
+      }
+      case "paragraph": {
+        const text = renderInlinesToText(node.inlines, meta);
+        if (text.trim()) {
+          lines.push(text);
+          lines.push("");
+        }
+        break;
+      }
+      case "callout": {
+        const calloutType = (node.calloutType || "NOTE").toUpperCase();
+        lines.push(`| [${calloutType}]`);
+        if (node.inlines && node.inlines.length > 0) {
+          const text = renderInlinesToText(node.inlines, meta);
+          text.split("\n").forEach((l) => lines.push(`| ${l}`));
+        }
+        lines.push("");
+        break;
+      }
+      case "blockquote": {
+        if (node.inlines && node.inlines.length > 0) {
+          const text = renderInlinesToText(node.inlines, meta);
+          text.split("\n").forEach((l) => lines.push(`> ${l}`));
+          lines.push("");
+        }
+        break;
+      }
+      case "codeBlock": {
+        const lang = node.language ? `[Language: ${node.language}]` : "[Code]";
+        lines.push(HR_SINGLE);
+        lines.push(lang);
+        lines.push(HR_SINGLE);
+        const codeText = node.text || "";
+        lines.push(codeText);
+        lines.push(HR_SINGLE);
+        lines.push("");
+        break;
+      }
+      case "list": {
+        if (node.children) {
+          let itemIndex = 1;
+          for (const item of node.children) {
+            const indent = "  ".repeat(listLevel);
+            let prefix = node.ordered ? `${itemIndex}. ` : "* ";
+            itemIndex++;
+            if (item.checked !== void 0) {
+              prefix = item.checked ? "[x] " : "[ ] ";
+            }
+            if (item.inlines && item.inlines.length > 0) {
+              const text = renderInlinesToText(item.inlines, meta);
+              lines.push(`${indent}${prefix}${text}`);
+            }
+            if (item.children && item.children.length > 0) {
+              for (const subChild of item.children) {
+                if (subChild.type === "list") {
+                  renderNode(subChild, listLevel + 1);
+                } else if (subChild.type === "paragraph") {
+                  const text = renderInlinesToText(subChild.inlines, meta);
+                  lines.push(`${indent}  ${text}`);
+                } else {
+                  renderNode(subChild, listLevel + 1);
+                }
+              }
+            }
+          }
+          lines.push("");
+        }
+        break;
+      }
+      case "table": {
+        const rows = node.children || [];
+        if (rows.length === 0) break;
+        const rowCells = [];
+        let maxCols = 0;
+        for (const row of rows) {
+          const cells = row.children || [];
+          const texts = cells.map((c) => renderInlinesToText(c.inlines, meta));
+          const isHeader = cells.some((c) => c.isHeader);
+          maxCols = Math.max(maxCols, texts.length);
+          rowCells.push({ isHeader, texts });
+        }
+        if (maxCols === 0) break;
+        const colWidths = new Array(maxCols).fill(3);
+        for (const r of rowCells) {
+          for (let col = 0; col < maxCols; col++) {
+            const cellText = r.texts[col] || "";
+            colWidths[col] = Math.max(colWidths[col] ?? 3, cellText.length);
+          }
+        }
+        const separatorLine = "+" + colWidths.map((w) => "-".repeat(w + 2)).join("+") + "+";
+        const formatRow = (texts) => {
+          const paddedCells = colWidths.map((width, colIdx) => {
+            const text = texts[colIdx] || "";
+            return " " + text.padEnd(width, " ") + " ";
+          });
+          return "|" + paddedCells.join("|") + "|";
+        };
+        lines.push(separatorLine);
+        for (const r of rowCells) {
+          lines.push(formatRow(r.texts));
+          if (r.isHeader) {
+            lines.push(separatorLine);
+          }
+        }
+        if (!((_a = rowCells[rowCells.length - 1]) == null ? void 0 : _a.isHeader)) {
+          lines.push(separatorLine);
+        }
+        lines.push("");
+        break;
+      }
+      case "mathBlock": {
+        lines.push("[Equation]");
+        lines.push(`  $$${node.text || ""} $$`);
+        lines.push("");
+        break;
+      }
+      case "mermaid": {
+        lines.push("[Diagram: Mermaid]");
+        lines.push(node.text || "");
+        lines.push("");
+        break;
+      }
+      case "thematicBreak": {
+        lines.push(HR_SINGLE);
+        lines.push("");
+        break;
+      }
+      case "columns": {
+        if (node.children) {
+          for (const col of node.children) {
+            if (col.children) {
+              for (const child of col.children) {
+                renderNode(child, listLevel);
+              }
+            }
+          }
+        }
+        break;
+      }
+      default: {
+        if (node.children && node.children.length > 0) {
+          for (const child of node.children) {
+            renderNode(child, listLevel);
+          }
+        }
+        break;
+      }
+    }
+  }
+  for (const node of nodes) {
+    renderNode(node);
+  }
+  if (doc.footnoteDefs && doc.footnoteDefs.length > 0) {
+    lines.push(HR_SINGLE);
+    lines.push("FOOTNOTES");
+    lines.push(HR_SINGLE);
+    for (const fn of doc.footnoteDefs) {
+      const text = renderInlinesToText(fn.inlines, meta);
+      lines.push(`[${fn.id}] ${text}`);
+    }
+    lines.push("");
+  }
+  if (resolved.signatures && resolved.signatures.items && resolved.signatures.items.length > 0) {
+    lines.push(HR_SINGLE);
+    lines.push("SIGNATURES & APPROVALS");
+    lines.push(HR_SINGLE);
+    lines.push("");
+    for (const item of resolved.signatures.items) {
+      const title = item.title || "Signatory";
+      const name = item.name ? replaceDocumentTokens(item.name, meta) : "";
+      const role = item.role ? replaceDocumentTokens(item.role, meta) : "";
+      const date = item.date ? replaceDocumentTokens(item.date, meta) : "";
+      lines.push(`[${title}]`);
+      lines.push("____________________________________");
+      if (name) lines.push(`Name: ${name}`);
+      if (role) lines.push(`Role: ${role}`);
+      if (date) lines.push(`Date: ${date}`);
+      lines.push("");
+    }
+  }
+  if (resolved.backCover && resolved.backCover.enabled) {
+    const back = resolved.backCover;
+    const backTitle = (back.title || "THANK YOU").toUpperCase();
+    const backSubtitle = back.subtitle || "";
+    const backCompany = back.company ? replaceDocumentTokens(back.company, meta) : "";
+    const backAddress = back.address ? replaceDocumentTokens(back.address, meta) : "";
+    const backEmail = back.email ? replaceDocumentTokens(back.email, meta) : "";
+    const backPhone = back.phone ? replaceDocumentTokens(back.phone, meta) : "";
+    const backWebsite = back.website ? replaceDocumentTokens(back.website, meta) : "";
+    const backCopyright = back.copyright ? replaceDocumentTokens(back.copyright, meta) : "";
+    lines.push(HR_DOUBLE);
+    lines.push(centerText(backTitle));
+    if (backSubtitle) {
+      lines.push(centerText(backSubtitle));
+    }
+    lines.push(HR_DOUBLE);
+    if (backCompany) lines.push(`Company:   ${backCompany}`);
+    if (backAddress) lines.push(`Address:   ${backAddress}`);
+    if (backEmail) lines.push(`Email:     ${backEmail}`);
+    if (backPhone) lines.push(`Phone:     ${backPhone}`);
+    if (backWebsite) lines.push(`Website:   ${backWebsite}`);
+    if (back.social && back.social.github) {
+      lines.push(`GitHub:    ${back.social.github}`);
+    }
+    if (backCopyright) {
+      lines.push("");
+      lines.push(backCopyright);
+    }
+    lines.push(HR_DOUBLE);
+    lines.push("");
+  }
+  return lines.join("\n").trim() + "\n";
+}
+
+// src/core/png/pngBuilder.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
+import { pathToFileURL as pathToFileURL4 } from "url";
+import { spawnSync as spawnSync3 } from "child_process";
+async function buildPngDocument(doc, config, baseDir) {
+  const htmlContent = await buildHtmlDocument(doc, config, baseDir);
+  const chromePath = findChromeExecutable();
+  if (!chromePath) {
+    throw new Error(
+      "Headless Chrome / Chromium / Edge executable not found for PNG document export. Please install Google Chrome, Chromium, or Microsoft Edge, or set CHROME_PATH environment variable."
+    );
+  }
+  const tmpHtml = path6.join(
+    os3.tmpdir(),
+    `markforge-png-${Date.now()}-${Math.random().toString(36).slice(2)}.html`
+  );
+  const tmpPng = path6.join(
+    os3.tmpdir(),
+    `markforge-png-${Date.now()}-${Math.random().toString(36).slice(2)}.png`
+  );
+  try {
+    fs6.writeFileSync(tmpHtml, htmlContent, "utf-8");
+    const fileUrl = pathToFileURL4(tmpHtml).href;
+    const spawnResult = spawnSync3(
+      chromePath,
+      [
+        "--headless=new",
+        "--disable-gpu",
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--hide-scrollbars",
+        "--force-device-scale-factor=2",
+        "--window-size=1200,1600",
+        `--screenshot=${tmpPng}`,
+        fileUrl
+      ],
+      { timeout: 3e4, windowsHide: true }
+    );
+    if (spawnResult.error) {
+      throw new Error(`Failed to execute Chromium for PNG export: ${spawnResult.error.message}`);
+    }
+    if (!fs6.existsSync(tmpPng) || fs6.statSync(tmpPng).size === 0) {
+      throw new Error("Chromium PNG export failed to generate output screenshot file.");
+    }
+    return fs6.readFileSync(tmpPng);
+  } finally {
+    try {
+      if (fs6.existsSync(tmpHtml)) fs6.unlinkSync(tmpHtml);
+      if (fs6.existsSync(tmpPng)) fs6.unlinkSync(tmpPng);
+    } catch {
+    }
+  }
+}
+
 // src/core/engine.ts
 function formatServerTimestamp(date = /* @__PURE__ */ new Date()) {
   const pad = (n) => String(n).padStart(2, "0");
@@ -4949,20 +5453,20 @@ async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgre
   let baseDir = process.cwd();
   let inputFileName = "document.md";
   let isFilePath = false;
-  if (fs6.existsSync(inputFilePathOrContent)) {
+  if (fs7.existsSync(inputFilePathOrContent)) {
     isFilePath = true;
-    rawMarkdown = fs6.readFileSync(inputFilePathOrContent, "utf-8");
-    baseDir = path6.dirname(path6.resolve(inputFilePathOrContent));
-    inputFileName = path6.basename(inputFilePathOrContent);
+    rawMarkdown = fs7.readFileSync(inputFilePathOrContent, "utf-8");
+    baseDir = path7.dirname(path7.resolve(inputFilePathOrContent));
+    inputFileName = path7.basename(inputFilePathOrContent);
   } else {
     rawMarkdown = inputFilePathOrContent;
   }
   onProgress == null ? void 0 : onProgress(`Parsing markdown AST: ${inputFileName}...`);
   const parsedDoc = parseMarkdownDocument(rawMarkdown);
   const baseName = inputFileName.replace(/\.(md|mdx|markdown)$/i, "");
-  const outputDir = config.outputDir ? path6.isAbsolute(config.outputDir) ? config.outputDir : path6.resolve(process.cwd(), config.outputDir) : baseDir;
-  if (!fs6.existsSync(outputDir)) {
-    fs6.mkdirSync(outputDir, { recursive: true });
+  const outputDir = config.outputDir ? path7.isAbsolute(config.outputDir) ? config.outputDir : path7.resolve(process.cwd(), config.outputDir) : baseDir;
+  if (!fs7.existsSync(outputDir)) {
+    fs7.mkdirSync(outputDir, { recursive: true });
   }
   const formats = Array.isArray(config.to) ? config.to : [config.to || "docx", "pdf"];
   const generatedFiles = [];
@@ -4972,8 +5476,8 @@ async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgre
       if (fmt === "docx") {
         onProgress == null ? void 0 : onProgress(`Generating DOCX document: ${baseName}.docx...`);
         const docxBuffer = await buildDocxDocument(parsedDoc, config, baseDir);
-        const docxPath = path6.join(outputDir, `${baseName}.docx`);
-        fs6.writeFileSync(docxPath, docxBuffer);
+        const docxPath = path7.join(outputDir, `${baseName}.docx`);
+        fs7.writeFileSync(docxPath, docxBuffer);
         generatedFiles.push({
           format: "docx",
           filePath: docxPath,
@@ -4983,8 +5487,8 @@ async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgre
       } else if (fmt === "html") {
         onProgress == null ? void 0 : onProgress(`Generating HTML document: ${baseName}.html...`);
         const htmlString = await buildHtmlDocument(parsedDoc, config, baseDir);
-        const htmlPath = path6.join(outputDir, `${baseName}.html`);
-        fs6.writeFileSync(htmlPath, htmlString, "utf-8");
+        const htmlPath = path7.join(outputDir, `${baseName}.html`);
+        fs7.writeFileSync(htmlPath, htmlString, "utf-8");
         generatedFiles.push({
           format: "html",
           filePath: htmlPath,
@@ -4994,14 +5498,36 @@ async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgre
       } else if (fmt === "pdf") {
         onProgress == null ? void 0 : onProgress(`Generating PDF document: ${baseName}.pdf...`);
         const pdfBuffer = await buildPdfDocument(parsedDoc, config, baseDir);
-        const pdfPath = path6.join(outputDir, `${baseName}.pdf`);
-        fs6.writeFileSync(pdfPath, pdfBuffer);
+        const pdfPath = path7.join(outputDir, `${baseName}.pdf`);
+        fs7.writeFileSync(pdfPath, pdfBuffer);
         generatedFiles.push({
           format: "pdf",
           filePath: pdfPath,
           fileName: `${baseName}.pdf`,
           sizeBytes: pdfBuffer.length
         });
+      } else if (fmt === "txt") {
+        onProgress == null ? void 0 : onProgress(`Generating Plain Text document: ${baseName}.txt...`);
+        const textContent = await buildTextDocument(parsedDoc, config, baseDir);
+        const textPath = path7.join(outputDir, `${baseName}.txt`);
+        fs7.writeFileSync(textPath, textContent, "utf-8");
+        generatedFiles.push({
+          format: "txt",
+          filePath: textPath,
+          fileName: `${baseName}.txt`,
+          sizeBytes: Buffer.byteLength(textContent, "utf-8")
+        });
+      } else if (fmt === "png") {
+        onProgress == null ? void 0 : onProgress(`Generating PNG document: ${baseName}.png...`);
+        const pngBuffer = await buildPngDocument(parsedDoc, config, baseDir);
+        const pngPath = path7.join(outputDir, `${baseName}.png`);
+        fs7.writeFileSync(pngPath, pngBuffer);
+        generatedFiles.push({
+          format: "png",
+          filePath: pngPath,
+          fileName: `${baseName}.png`,
+          sizeBytes: pngBuffer.length
+        });
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -5020,14 +5546,14 @@ async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgre
 
 // src/server/previewServer.ts
 import * as http from "http";
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 async function startPreviewServer(options) {
-  const absoluteFilePath = path7.resolve(process.cwd(), options.filePath);
-  if (!fs7.existsSync(absoluteFilePath)) {
+  const absoluteFilePath = path8.resolve(process.cwd(), options.filePath);
+  if (!fs8.existsSync(absoluteFilePath)) {
     throw new Error(`MarkForge preview error: File not found at "${absoluteFilePath}"`);
   }
-  const baseDir = path7.dirname(absoluteFilePath);
+  const baseDir = path8.dirname(absoluteFilePath);
   const { config: fileConfig } = await loadConfig(void 0, baseDir);
   const baseConfig = options.config || fileConfig;
   const port = options.port || 3e3;
@@ -5045,9 +5571,9 @@ data: ${Date.now()}
     });
   };
   let debounceTimer = null;
-  const watcher = fs7.watch(baseDir, { recursive: false }, (_event, filename) => {
+  const watcher = fs8.watch(baseDir, { recursive: false }, (_event, filename) => {
     if (!filename) return;
-    const changedPath = path7.resolve(baseDir, filename);
+    const changedPath = path8.resolve(baseDir, filename);
     if (changedPath === absoluteFilePath || filename.includes("markforge") || filename.endsWith(".css")) {
       if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(() => {
@@ -5074,12 +5600,12 @@ data: ${Date.now()}
     }
     if (url.pathname === "/api/file-content" && req.method === "GET") {
       try {
-        const content = fs7.readFileSync(absoluteFilePath, "utf-8");
+        const content = fs8.readFileSync(absoluteFilePath, "utf-8");
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
             content,
-            fileName: path7.basename(absoluteFilePath),
+            fileName: path8.basename(absoluteFilePath),
             filePath: absoluteFilePath
           })
         );
@@ -5099,7 +5625,7 @@ data: ${Date.now()}
         try {
           const parsed = JSON.parse(body);
           if (typeof parsed.content === "string") {
-            fs7.writeFileSync(absoluteFilePath, parsed.content, "utf-8");
+            fs8.writeFileSync(absoluteFilePath, parsed.content, "utf-8");
             broadcastReload();
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ success: true, savedAt: Date.now() }));
@@ -5118,11 +5644,11 @@ data: ${Date.now()}
     if (url.pathname === "/api/export" && (req.method === "GET" || req.method === "POST")) {
       const format = url.searchParams.get("format") || "docx";
       try {
-        const mdContent = fs7.readFileSync(absoluteFilePath, "utf-8");
+        const mdContent = fs8.readFileSync(absoluteFilePath, "utf-8");
         const doc = parseMarkdownDocument(mdContent);
         const { config: resolvedConfig } = await loadConfig(void 0, baseDir);
         const mergedConfig = { ...baseConfig, ...resolvedConfig };
-        const fileBase = path7.basename(absoluteFilePath, path7.extname(absoluteFilePath));
+        const fileBase = path8.basename(absoluteFilePath, path8.extname(absoluteFilePath));
         if (format === "docx") {
           const buffer = await buildDocxDocument(doc, mergedConfig, baseDir);
           res.writeHead(200, {
@@ -5157,7 +5683,7 @@ data: ${Date.now()}
     }
     if (url.pathname === "/document-content") {
       try {
-        const mdContent = fs7.readFileSync(absoluteFilePath, "utf-8");
+        const mdContent = fs8.readFileSync(absoluteFilePath, "utf-8");
         const doc = parseMarkdownDocument(mdContent);
         const { config: resolvedConfig } = await loadConfig(void 0, baseDir);
         const html = await buildHtmlDocument(doc, { ...baseConfig, ...resolvedConfig }, baseDir);
@@ -5190,8 +5716,8 @@ data: ${Date.now()}
       return;
     }
     if (url.pathname === "/" || url.pathname === "/index.html") {
-      const fileName = path7.basename(absoluteFilePath);
-      const initialContent = fs7.readFileSync(absoluteFilePath, "utf-8");
+      const fileName = path8.basename(absoluteFilePath);
+      const initialContent = fs8.readFileSync(absoluteFilePath, "utf-8");
       const appHtml = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -5895,9 +6421,9 @@ function defineConfig(config) {
 }
 
 // src/version.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
-import { fileURLToPath } from "url";
+import * as fs9 from "fs";
+import * as path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 try {
   if (typeof globalThis !== "undefined" && (!globalThis.localStorage || typeof globalThis.localStorage.getItem !== "function")) {
     Object.defineProperty(globalThis, "localStorage", {
@@ -5922,16 +6448,16 @@ function readVersionFromPackageJson(fromDir) {
   let currentDir = fromDir;
   for (let i = 0; i < 10; i++) {
     try {
-      const pkgJsonPath = path8.join(currentDir, "package.json");
-      if (fs8.existsSync(pkgJsonPath)) {
-        const pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJsonPath = path9.join(currentDir, "package.json");
+      if (fs9.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
         if (pkg.name === "@masumdev/markforge" && pkg.version) {
           return pkg.version;
         }
       }
     } catch {
     }
-    const parentDir = path8.dirname(currentDir);
+    const parentDir = path9.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -5944,7 +6470,7 @@ function getPackageDir() {
     return __dirname;
   }
   try {
-    return path8.dirname(fileURLToPath(import.meta.url));
+    return path9.dirname(fileURLToPath2(import.meta.url));
   } catch {
     return process.cwd();
   }
@@ -5954,6 +6480,8 @@ function getMarkforgeVersion(fromDir = getPackageDir()) {
   return readVersionFromPackageJson(fromDir);
 }
 export {
+  BackCoverPreset,
+  CoverPagePreset,
   DEFAULT_CONFIG,
   KATEX_INLINE_CSS,
   MARKFORGE_VERSION,
@@ -5962,6 +6490,8 @@ export {
   PAPER_DIMENSIONS_TWIP,
   PaperSizeEnum,
   SYNTAX_COLORS,
+  SignatureAlign,
+  SignatureStyle,
   SyntaxTheme,
   THEMES,
   THEME_CORPORATE,
@@ -5972,6 +6502,9 @@ export {
   buildDocxDocument,
   buildHtmlDocument,
   buildPdfDocument,
+  buildPngDocument,
+  buildTextDocument,
+  buildTextDocument as buildTxtDocument,
   compileMarkdown,
   defineConfig,
   escapeHtml,
@@ -6000,6 +6533,7 @@ export {
   renderBackCoverHtml,
   renderCoverPageHtml,
   renderInlinesToHtml,
+  renderInlinesToText,
   renderMathToHtml,
   renderMermaidToPng,
   renderNodesToHtml,