@masumdev/markforge 0.4.1 → 0.5.0

package/dist/App-JOOTPDJN.mjs

@@ -0,0 +1,847 @@
+#!/usr/bin/env node
+try {
+  if (typeof globalThis !== "undefined" && (!globalThis.localStorage || typeof globalThis.localStorage.getItem !== "function")) {
+    Object.defineProperty(globalThis, "localStorage", {
+      value: { getItem: () => null, setItem: () => {}, removeItem: () => {}, clear: () => {}, key: () => null, length: 0 },
+      configurable: true, writable: true,
+    });
+  }
+} catch {}
+import {
+  MARKFORGE_VERSION
+} from "./chunk-UNWAEVDU.mjs";
+import {
+  applyHeadingNumbering,
+  buildDocxDocument,
+  buildHtmlDocument,
+  buildPdfDocument,
+  findChromeExecutable,
+  parseMarkdownDocument,
+  replaceDocumentTokens,
+  resolveDocumentConfig
+} from "./chunk-H3ZUUSHP.mjs";
+import {
+  DEFAULT_CONFIG
+} from "./chunk-BPHDY6VB.mjs";
+import "./chunk-YZHGBG4N.mjs";
+
+// src/ui/App.tsx
+import { useState, useEffect } from "react";
+import { Box as Box4 } from "ink";
+
+// src/ui/Header.tsx
+import * as path from "path";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function formatDisplayPath(p) {
+  if (!p) return "";
+  try {
+    const rel = path.relative(process.cwd(), p);
+    return rel && !rel.startsWith("..") && rel.length < p.length ? `./${rel}` : p;
+  } catch {
+    return p;
+  }
+}
+var Header = ({
+  inputFile,
+  configPath,
+  config,
+  theme = "corporate",
+  targetFormats = ["docx", "pdf"]
+}) => {
+  const resolvedTheme = (config == null ? void 0 : config.theme) || theme;
+  const themeLabel = typeof resolvedTheme === "object" ? "Custom (ThemeProps)" : String(resolvedTheme || "corporate");
+  const activeFeatures = [];
+  if (config == null ? void 0 : config.toc) activeFeatures.push("TOC");
+  if (config == null ? void 0 : config.numberHeadings) {
+    if (typeof config.numberHeadings === "object") {
+      const isNumEnabled = config.numberHeadings.enabled ?? true;
+      if (isNumEnabled) {
+        activeFeatures.push(`Numbering (depth ${config.numberHeadings.depth ?? 3})`);
+      }
+    } else if (config.numberHeadings === true) {
+      activeFeatures.push("Numbering (depth 3)");
+    }
+  }
+  if (config == null ? void 0 : config.coverPage) {
+    if (typeof config.coverPage === "object" && config.coverPage.enabled !== false) {
+      activeFeatures.push(`Cover (${config.coverPage.preset || "corporate"})`);
+    } else if (config.coverPage === true) {
+      activeFeatures.push("Cover (corporate)");
+    }
+  }
+  if (config == null ? void 0 : config.backCover) {
+    if (typeof config.backCover === "object" && config.backCover.enabled !== false) {
+      activeFeatures.push(`BackCover (${config.backCover.preset || "corporate"})`);
+    } else if (config.backCover === true) {
+      activeFeatures.push("BackCover (corporate)");
+    }
+  }
+  if (config == null ? void 0 : config.watermark) {
+    const wmText = typeof config.watermark === "object" ? config.watermark.text : config.watermark;
+    if (wmText) {
+      activeFeatures.push(`Watermark ("${wmText}")`);
+    }
+  }
+  if ((config == null ? void 0 : config.security) && (config.security.userPassword || config.security.ownerPassword)) {
+    activeFeatures.push("AES-256 Security");
+  }
+  if ((config == null ? void 0 : config.math) !== false) activeFeatures.push("KaTeX Math");
+  if (config == null ? void 0 : config.syntaxTheme) activeFeatures.push(`Syntax (${config.syntaxTheme})`);
+  const paperLabel = `${(config == null ? void 0 : config.paperSize) || "A4"} (${(config == null ? void 0 : config.orientation) || "portrait"})`;
+  const outputLabel = (config == null ? void 0 : config.outputDir) ? formatDisplayPath(config.outputDir) : "./ (default)";
+  const configLabel = configPath ? formatDisplayPath(configPath) : "(default auto-discovery)";
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginY: 1, children: /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 2,
+      paddingY: 1,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "MARKFORGE" }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: " | Document Publishing Engine" })
+          ] }),
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "black", backgroundColor: "cyan", bold: true, children: [
+            " ",
+            "v",
+            MARKFORGE_VERSION,
+            " "
+          ] }) })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Source:  " }),
+              /* @__PURE__ */ jsx(Text, { color: "white", bold: true, children: formatDisplayPath(inputFile) })
+            ] }),
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Config:  " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: configLabel })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", marginTop: 0, children: [
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Theme:   " }),
+              /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: themeLabel })
+            ] }),
+            targetFormats && targetFormats.length > 0 && /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Targets: " }),
+              /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: targetFormats.map((f) => f.toUpperCase()).join(", ") })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", marginTop: 0, children: [
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Layout:  " }),
+              /* @__PURE__ */ jsx(Text, { color: "green", children: paperLabel })
+            ] }),
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: "Output:  " }),
+              /* @__PURE__ */ jsx(Text, { color: "white", children: outputLabel })
+            ] })
+          ] }),
+          activeFeatures.length > 0 && /* @__PURE__ */ jsxs(Box, { marginTop: 0, children: [
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "Modules: " }),
+            /* @__PURE__ */ jsx(Text, { color: "blue", children: activeFeatures.join(" | ") })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "Author: " }),
+            /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "Ma'sum" }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: " (@masumrpg)" })
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "GitHub: " }),
+            /* @__PURE__ */ jsx(Text, { color: "blue", underline: true, children: "https://github.com/masumrpg" })
+          ] })
+        ] })
+      ]
+    }
+  ) });
+};
+
+// src/ui/LiveProgress.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var LiveProgress = ({ status, isCompiling }) => {
+  if (!isCompiling) return null;
+  return /* @__PURE__ */ jsxs2(Box2, { marginY: 1, alignItems: "center", children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) }),
+    /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "[COMPILING] " }),
+      /* @__PURE__ */ jsx2(Text2, { color: "white", children: status })
+    ] })
+  ] });
+};
+
+// src/ui/SummaryTable.tsx
+import * as path2 from "path";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function formatDisplayPath2(p) {
+  if (!p) return "";
+  try {
+    const rel = path2.relative(process.cwd(), p);
+    return rel && !rel.startsWith("..") && rel.length < p.length ? `./${rel}` : p;
+  } catch {
+    return p;
+  }
+}
+var SummaryTable = ({ result }) => {
+  if (!result) return null;
+  const hasErrors = result.errors.length > 0;
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginY: 1, children: /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      borderStyle: "round",
+      borderColor: hasErrors ? "red" : "green",
+      paddingX: 2,
+      paddingY: 1,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: hasErrors ? "red" : "green", children: hasErrors ? "[COMPILATION FAILED]" : "[COMPILATION SUCCESSFUL]" }) }),
+          /* @__PURE__ */ jsxs3(Box3, { children: [
+            /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "Duration: " }),
+            /* @__PURE__ */ jsxs3(Text3, { color: "yellow", bold: true, children: [
+              result.durationMs,
+              "ms"
+            ] })
+          ] })
+        ] }),
+        result.files.length > 0 && /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "white", children: [
+            "Generated Documents (",
+            result.files.length,
+            "):"
+          ] }),
+          result.files.map((f, i) => {
+            const formatColor = f.format === "docx" ? "blue" : f.format === "pdf" ? "red" : f.format === "html" ? "yellow" : f.format === "png" ? "magenta" : "green";
+            const paddedBadge = `[${f.format.toUpperCase()}]`.padEnd(7, " ");
+            return /* @__PURE__ */ jsxs3(Box3, { marginTop: 0, flexDirection: "column", marginLeft: 1, children: [
+              /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", alignItems: "center", children: [
+                /* @__PURE__ */ jsxs3(Box3, { children: [
+                  /* @__PURE__ */ jsx3(Text3, { color: formatColor, bold: true, children: paddedBadge }),
+                  /* @__PURE__ */ jsx3(Text3, { color: "white", bold: true, children: f.fileName })
+                ] }),
+                /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: formatBytes(f.sizeBytes) })
+              ] }),
+              /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+                "\u2514\u2500 ",
+                formatDisplayPath2(f.filePath)
+              ] }) })
+            ] }, i);
+          })
+        ] }),
+        hasErrors && /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, color: "red", children: "Errors:" }),
+          result.errors.map((err, i) => /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+            "- ",
+            err
+          ] }) }, i))
+        ] }),
+        /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsxs3(Box3, { children: [
+            /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "Author: " }),
+            /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "Ma'sum" }),
+            /* @__PURE__ */ jsx3(Text3, { color: "gray", children: " (@masumrpg)" })
+          ] }),
+          /* @__PURE__ */ jsxs3(Box3, { children: [
+            /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "GitHub: " }),
+            /* @__PURE__ */ jsx3(Text3, { color: "blue", underline: true, children: "https://github.com/masumrpg" })
+          ] })
+        ] })
+      ]
+    }
+  ) });
+};
+
+// src/core/engine.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+
+// 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 fs from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import { pathToFileURL } from "url";
+import { spawnSync } 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 = path3.join(
+    os.tmpdir(),
+    `markforge-png-${Date.now()}-${Math.random().toString(36).slice(2)}.html`
+  );
+  const tmpPng = path3.join(
+    os.tmpdir(),
+    `markforge-png-${Date.now()}-${Math.random().toString(36).slice(2)}.png`
+  );
+  try {
+    fs.writeFileSync(tmpHtml, htmlContent, "utf-8");
+    const fileUrl = pathToFileURL(tmpHtml).href;
+    const spawnResult = spawnSync(
+      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 (!fs.existsSync(tmpPng) || fs.statSync(tmpPng).size === 0) {
+      throw new Error("Chromium PNG export failed to generate output screenshot file.");
+    }
+    return fs.readFileSync(tmpPng);
+  } finally {
+    try {
+      if (fs.existsSync(tmpHtml)) fs.unlinkSync(tmpHtml);
+      if (fs.existsSync(tmpPng)) fs.unlinkSync(tmpPng);
+    } catch {
+    }
+  }
+}
+
+// src/core/engine.ts
+async function compileMarkdown(inputFilePathOrContent, userConfig = {}, onProgress) {
+  const startTime = Date.now();
+  const config = { ...DEFAULT_CONFIG, ...userConfig };
+  let rawMarkdown = "";
+  let baseDir = process.cwd();
+  let inputFileName = "document.md";
+  let isFilePath = false;
+  if (fs2.existsSync(inputFilePathOrContent)) {
+    isFilePath = true;
+    rawMarkdown = fs2.readFileSync(inputFilePathOrContent, "utf-8");
+    baseDir = path4.dirname(path4.resolve(inputFilePathOrContent));
+    inputFileName = path4.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 ? path4.isAbsolute(config.outputDir) ? config.outputDir : path4.resolve(process.cwd(), config.outputDir) : baseDir;
+  if (!fs2.existsSync(outputDir)) {
+    fs2.mkdirSync(outputDir, { recursive: true });
+  }
+  const formats = Array.isArray(config.to) ? config.to : [config.to || "docx", "pdf"];
+  const generatedFiles = [];
+  const errors = [];
+  for (const fmt of formats) {
+    try {
+      if (fmt === "docx") {
+        onProgress == null ? void 0 : onProgress(`Generating DOCX document: ${baseName}.docx...`);
+        const docxBuffer = await buildDocxDocument(parsedDoc, config, baseDir);
+        const docxPath = path4.join(outputDir, `${baseName}.docx`);
+        fs2.writeFileSync(docxPath, docxBuffer);
+        generatedFiles.push({
+          format: "docx",
+          filePath: docxPath,
+          fileName: `${baseName}.docx`,
+          sizeBytes: docxBuffer.length
+        });
+      } else if (fmt === "html") {
+        onProgress == null ? void 0 : onProgress(`Generating HTML document: ${baseName}.html...`);
+        const htmlString = await buildHtmlDocument(parsedDoc, config, baseDir);
+        const htmlPath = path4.join(outputDir, `${baseName}.html`);
+        fs2.writeFileSync(htmlPath, htmlString, "utf-8");
+        generatedFiles.push({
+          format: "html",
+          filePath: htmlPath,
+          fileName: `${baseName}.html`,
+          sizeBytes: Buffer.byteLength(htmlString, "utf-8")
+        });
+      } else if (fmt === "pdf") {
+        onProgress == null ? void 0 : onProgress(`Generating PDF document: ${baseName}.pdf...`);
+        const pdfBuffer = await buildPdfDocument(parsedDoc, config, baseDir);
+        const pdfPath = path4.join(outputDir, `${baseName}.pdf`);
+        fs2.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 = path4.join(outputDir, `${baseName}.txt`);
+        fs2.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 = path4.join(outputDir, `${baseName}.png`);
+        fs2.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);
+      errors.push(`Failed to generate ${fmt}: ${errMsg}`);
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  return {
+    inputFile: isFilePath ? inputFilePathOrContent : "inline-string",
+    durationMs,
+    metadata: parsedDoc.metadata,
+    files: generatedFiles,
+    errors
+  };
+}
+
+// src/ui/App.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var App = ({ inputFile, config, configPath, onComplete }) => {
+  const [status, setStatus] = useState("Initializing...");
+  const [isCompiling, setIsCompiling] = useState(true);
+  const [result, setResult] = useState(null);
+  useEffect(() => {
+    async function run() {
+      try {
+        const res = await compileMarkdown(inputFile, config, (msg) => setStatus(msg));
+        setResult(res);
+        setIsCompiling(false);
+        onComplete == null ? void 0 : onComplete(res);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const errResult = {
+          inputFile,
+          durationMs: 0,
+          metadata: {},
+          files: [],
+          errors: [errMsg]
+        };
+        setResult(errResult);
+        setIsCompiling(false);
+        onComplete == null ? void 0 : onComplete(errResult);
+      }
+    }
+    run();
+  }, [inputFile, config, onComplete]);
+  const targetFormats = Array.isArray(config.to) ? config.to : config.to ? [String(config.to)] : ["docx", "pdf"];
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(
+      Header,
+      {
+        inputFile,
+        configPath,
+        config,
+        theme: config.theme,
+        targetFormats
+      }
+    ),
+    /* @__PURE__ */ jsx4(LiveProgress, { status, isCompiling }),
+    /* @__PURE__ */ jsx4(SummaryTable, { result })
+  ] });
+};
+export {
+  App
+};