@masumdev/markforge 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2439 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/engine.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+
+// src/core/parser.ts
+import matter from "gray-matter";
+function parseInlineSpans(text) {
+  const spans = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    const imgMatch = remaining.match(/^!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)(?:\{([^}]+)\})?/);
+    if (imgMatch) {
+      const alt = imgMatch[1];
+      const url = imgMatch[2];
+      const title = imgMatch[3];
+      const attrStr = imgMatch[4] || "";
+      let width;
+      let height;
+      if (attrStr) {
+        const wMatch = attrStr.match(/width=([^\s}]+)/i);
+        const hMatch = attrStr.match(/height=([^\s}]+)/i);
+        if (wMatch) width = wMatch[1];
+        if (hMatch) height = hMatch[1];
+      }
+      spans.push({
+        type: "image",
+        content: alt,
+        url,
+        alt,
+        title,
+        width,
+        height
+      });
+      remaining = remaining.slice(imgMatch[0].length);
+      continue;
+    }
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)/);
+    if (linkMatch) {
+      spans.push({
+        type: "link",
+        content: linkMatch[1],
+        url: linkMatch[2],
+        title: linkMatch[3],
+        children: parseInlineSpans(linkMatch[1])
+      });
+      remaining = remaining.slice(linkMatch[0].length);
+      continue;
+    }
+    const boldItalicMatch = remaining.match(/^(\*\*\*|___)(.+?)\1/);
+    if (boldItalicMatch) {
+      spans.push({
+        type: "bold",
+        content: boldItalicMatch[2],
+        children: [
+          {
+            type: "italic",
+            content: boldItalicMatch[2],
+            children: parseInlineSpans(boldItalicMatch[2])
+          }
+        ]
+      });
+      remaining = remaining.slice(boldItalicMatch[0].length);
+      continue;
+    }
+    const boldMatch = remaining.match(/^(\*\*|__)(.+?)\1/);
+    if (boldMatch) {
+      spans.push({
+        type: "bold",
+        content: boldMatch[2],
+        children: parseInlineSpans(boldMatch[2])
+      });
+      remaining = remaining.slice(boldMatch[0].length);
+      continue;
+    }
+    const italicMatch = remaining.match(/^(\*|_)([^*_]+?)\1/);
+    if (italicMatch) {
+      spans.push({
+        type: "italic",
+        content: italicMatch[2],
+        children: parseInlineSpans(italicMatch[2])
+      });
+      remaining = remaining.slice(italicMatch[0].length);
+      continue;
+    }
+    const strikeMatch = remaining.match(/^~~(.+?)~~/);
+    if (strikeMatch) {
+      spans.push({
+        type: "strikethrough",
+        content: strikeMatch[1],
+        children: parseInlineSpans(strikeMatch[1])
+      });
+      remaining = remaining.slice(strikeMatch[0].length);
+      continue;
+    }
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch) {
+      spans.push({
+        type: "code",
+        content: codeMatch[1]
+      });
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const htmlTagMatch = remaining.match(/^<(\w+)([^>]*)>(.*?)<\/\1>/i) || remaining.match(/^<(\w+)([^>]*)\/?>/i);
+    if (htmlTagMatch) {
+      const fullTag = htmlTagMatch[0];
+      const tag = htmlTagMatch[1].toLowerCase();
+      const attrs = htmlTagMatch[2] || "";
+      const innerText = htmlTagMatch[3] || "";
+      if (tag === "img") {
+        const srcMatch = attrs.match(/src=["']([^"']+)["']/i);
+        const altMatch = attrs.match(/alt=["']([^"']+)["']/i);
+        const widthMatch = attrs.match(/width=["']?(\d+%?|\d+px)?["']?/i);
+        const heightMatch = attrs.match(/height=["']?(\d+%?|\d+px)?["']?/i);
+        if (srcMatch) {
+          spans.push({
+            type: "image",
+            content: altMatch ? altMatch[1] : "",
+            url: srcMatch[1],
+            alt: altMatch ? altMatch[1] : "",
+            width: widthMatch ? widthMatch[1] : void 0,
+            height: heightMatch ? heightMatch[1] : void 0
+          });
+          remaining = remaining.slice(fullTag.length);
+          continue;
+        }
+      }
+      spans.push({
+        type: "htmlInline",
+        content: innerText || fullTag,
+        children: innerText ? parseInlineSpans(innerText) : void 0
+      });
+      remaining = remaining.slice(fullTag.length);
+      continue;
+    }
+    const nextSpecial = remaining.search(/[\*\_\[\!`~<]/);
+    if (nextSpecial === -1) {
+      spans.push({
+        type: "text",
+        content: remaining
+      });
+      break;
+    } else if (nextSpecial === 0) {
+      spans.push({
+        type: "text",
+        content: remaining[0]
+      });
+      remaining = remaining.slice(1);
+    } else {
+      spans.push({
+        type: "text",
+        content: remaining.slice(0, nextSpecial)
+      });
+      remaining = remaining.slice(nextSpecial);
+    }
+  }
+  return spans;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseMarkdownDocument(rawMarkdown) {
+  const { data: frontmatter, content } = matter(rawMarkdown);
+  const metadata = frontmatter || {};
+  const inlinedStyles = [];
+  const cleanContent = content.replace(/<style[^>]*>([\s\S]*?)<\/style>/gi, (_, css) => {
+    inlinedStyles.push(css.trim());
+    return "";
+  });
+  const lines = cleanContent.split(/\r?\n/);
+  const nodes = [];
+  const tocEntries = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const text = headingMatch[2].trim();
+      const id = slugify(text);
+      nodes.push({
+        type: "heading",
+        level,
+        id,
+        text,
+        inlines: parseInlineSpans(text)
+      });
+      tocEntries.push({ id, text, level });
+      i++;
+      continue;
+    }
+    if (/^(\*{3,}|-{3,}|_{3,})\s*$/.test(line)) {
+      nodes.push({ type: "thematicBreak" });
+      i++;
+      continue;
+    }
+    const codeBlockMatch = line.match(/^```(\w+)?/);
+    if (codeBlockMatch) {
+      const language = (codeBlockMatch[1] || "text").trim().toLowerCase();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) i++;
+      const codeText = codeLines.join("\n");
+      if (language === "mermaid") {
+        nodes.push({
+          type: "mermaid",
+          language: "mermaid",
+          text: codeText
+        });
+      } else {
+        nodes.push({
+          type: "codeBlock",
+          language,
+          text: codeText
+        });
+      }
+      continue;
+    }
+    const calloutMatch = line.match(/^>\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*$/i);
+    if (calloutMatch) {
+      const calloutType = calloutMatch[1].toUpperCase();
+      const blockLines = [];
+      i++;
+      while (i < lines.length && lines[i].startsWith(">")) {
+        blockLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      const blockText = blockLines.join("\n");
+      nodes.push({
+        type: "callout",
+        calloutType,
+        text: blockText,
+        inlines: parseInlineSpans(blockText)
+      });
+      continue;
+    }
+    if (line.startsWith(">")) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].startsWith(">")) {
+        quoteLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      const quoteText = quoteLines.join("\n");
+      nodes.push({
+        type: "blockquote",
+        text: quoteText,
+        inlines: parseInlineSpans(quoteText)
+      });
+      continue;
+    }
+    if (line.trim().startsWith("|") && line.includes("|")) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].trim().startsWith("|")) {
+        tableLines.push(lines[i].trim());
+        i++;
+      }
+      if (tableLines.length >= 2) {
+        const headerRow = tableLines[0].split("|").slice(1, -1).map((c) => c.trim());
+        const alignRow = tableLines[1].split("|").slice(1, -1).map((c) => c.trim());
+        const align = alignRow.map((col) => {
+          if (col.startsWith(":") && col.endsWith(":")) return "center";
+          if (col.endsWith(":")) return "right";
+          if (col.startsWith(":")) return "left";
+          return null;
+        });
+        const rows = [];
+        rows.push({
+          type: "tableRow",
+          isHeader: true,
+          children: headerRow.map((cellText) => ({
+            type: "tableCell",
+            isHeader: true,
+            text: cellText,
+            inlines: parseInlineSpans(cellText)
+          }))
+        });
+        for (let r = 2; r < tableLines.length; r++) {
+          const cells = tableLines[r].split("|").slice(1, -1).map((c) => c.trim());
+          rows.push({
+            type: "tableRow",
+            isHeader: false,
+            children: cells.map((cellText) => ({
+              type: "tableCell",
+              isHeader: false,
+              text: cellText,
+              inlines: parseInlineSpans(cellText)
+            }))
+          });
+        }
+        nodes.push({
+          type: "table",
+          align,
+          children: rows
+        });
+        continue;
+      }
+    }
+    const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.+)$/);
+    if (listMatch) {
+      const listItems = [];
+      const isOrdered = /^\d+\./.test(listMatch[2]);
+      while (i < lines.length) {
+        const itemMatch = lines[i].match(/^(\s*)([-*+]|\d+\.)\s+(.+)$/);
+        if (!itemMatch) break;
+        let itemText = itemMatch[3].trim();
+        let checked = void 0;
+        const taskMatch = itemText.match(/^\[([ xX])\]\s+(.*)$/);
+        if (taskMatch) {
+          checked = taskMatch[1].toLowerCase() === "x";
+          itemText = taskMatch[2];
+        }
+        listItems.push({
+          type: "listItem",
+          checked,
+          text: itemText,
+          inlines: parseInlineSpans(itemText)
+        });
+        i++;
+      }
+      nodes.push({
+        type: "list",
+        ordered: isOrdered,
+        children: listItems
+      });
+      continue;
+    }
+    if (line.trim().startsWith("<") && !line.trim().startsWith("<!--")) {
+      const htmlLines = [];
+      while (i < lines.length && lines[i].trim().length > 0) {
+        htmlLines.push(lines[i]);
+        i++;
+      }
+      const rawHtml = htmlLines.join("\n");
+      nodes.push({
+        type: "htmlBlock",
+        rawHtml,
+        text: rawHtml
+      });
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() && !lines[i].match(/^#{1,6}\s+/) && !lines[i].startsWith("```") && !lines[i].startsWith(">") && !lines[i].trim().startsWith("|") && !lines[i].match(/^(\s*)([-*+]|\d+\.)\s+/)) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    const paraText = paraLines.join(" ");
+    nodes.push({
+      type: "paragraph",
+      text: paraText,
+      inlines: parseInlineSpans(paraText)
+    });
+  }
+  return {
+    metadata,
+    content: cleanContent,
+    nodes,
+    tocEntries,
+    inlinedStyles
+  };
+}
+
+// src/core/docx/docxBuilder.ts
+import {
+  Document,
+  Paragraph,
+  TextRun,
+  HeadingLevel,
+  Table,
+  TableRow,
+  TableCell,
+  WidthType,
+  BorderStyle,
+  AlignmentType,
+  ImageRun,
+  Header,
+  Footer,
+  PageNumber,
+  Packer,
+  PageOrientation,
+  convertInchesToTwip,
+  convertMillimetersToTwip,
+  ShadingType,
+  ExternalHyperlink,
+  TabStopType
+} from "docx";
+
+// src/core/imageResolver.ts
+import * as fs from "fs";
+import * as path from "path";
+var memoryImageCache = /* @__PURE__ */ new Map();
+function getMimeType(filePathOrUrl) {
+  const clean = filePathOrUrl.split("?")[0].toLowerCase();
+  if (clean.endsWith(".png")) return "image/png";
+  if (clean.endsWith(".jpg") || clean.endsWith(".jpeg")) return "image/jpeg";
+  if (clean.endsWith(".gif")) return "image/gif";
+  if (clean.endsWith(".svg")) return "image/svg+xml";
+  if (clean.endsWith(".webp")) return "image/webp";
+  if (clean.endsWith(".bmp")) return "image/bmp";
+  return "image/png";
+}
+async function resolveImage(src, baseDir = process.cwd()) {
+  const cacheKey = `${baseDir}::${src}`;
+  if (memoryImageCache.has(cacheKey)) {
+    return memoryImageCache.get(cacheKey);
+  }
+  try {
+    if (src.startsWith("data:")) {
+      const parts = src.split(",");
+      const meta = parts[0];
+      const base64Data = parts[1];
+      const mimeMatch = meta.match(/data:([^;]+)/);
+      const mimeType2 = mimeMatch ? mimeMatch[1] : "image/png";
+      const buffer2 = Buffer.from(base64Data, "base64");
+      const isSvg2 = mimeType2 === "image/svg+xml";
+      const resolved2 = {
+        src,
+        buffer: buffer2,
+        mimeType: mimeType2,
+        dataUri: src,
+        isSvg: isSvg2
+      };
+      memoryImageCache.set(cacheKey, resolved2);
+      return resolved2;
+    }
+    if (src.startsWith("http://") || src.startsWith("https://")) {
+      const response = await fetch(src, { signal: AbortSignal.timeout(1e4) });
+      if (!response.ok) {
+        return null;
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer2 = Buffer.from(arrayBuffer);
+      const contentType = response.headers.get("content-type") || getMimeType(src);
+      const mimeType2 = contentType.split(";")[0].trim();
+      const dataUri2 = `data:${mimeType2};base64,${buffer2.toString("base64")}`;
+      const isSvg2 = mimeType2 === "image/svg+xml";
+      const resolved2 = {
+        src,
+        buffer: buffer2,
+        mimeType: mimeType2,
+        dataUri: dataUri2,
+        isSvg: isSvg2
+      };
+      memoryImageCache.set(cacheKey, resolved2);
+      return resolved2;
+    }
+    const localPath = path.isAbsolute(src) ? src : path.resolve(baseDir, src);
+    if (!fs.existsSync(localPath)) {
+      return null;
+    }
+    const buffer = fs.readFileSync(localPath);
+    const mimeType = getMimeType(localPath);
+    const dataUri = `data:${mimeType};base64,${buffer.toString("base64")}`;
+    const isSvg = mimeType === "image/svg+xml";
+    const resolved = {
+      src,
+      buffer,
+      mimeType,
+      dataUri,
+      isSvg
+    };
+    memoryImageCache.set(cacheKey, resolved);
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+async function inlineHtmlImages(html, baseDir = process.cwd()) {
+  const imgRegex = /<img([^>]+)src=["']([^"']+)["']([^>]*)>/gi;
+  const matches = Array.from(html.matchAll(imgRegex));
+  let inlinedHtml = html;
+  for (const match of matches) {
+    const fullTag = match[0];
+    const beforeSrc = match[1];
+    const src = match[2];
+    const afterSrc = match[3];
+    const resolved = await resolveImage(src, baseDir);
+    if (resolved) {
+      const replacement = `<img${beforeSrc}src="${resolved.dataUri}"${afterSrc}>`;
+      inlinedHtml = inlinedHtml.replace(fullTag, replacement);
+    }
+  }
+  return inlinedHtml;
+}
+
+// src/core/syntax/syntaxHighlighter.ts
+var SYNTAX_COLORS = {
+  keyword: "FF7B72",
+  // Bright coral-red  — keywords (import, def, return...)
+  string: "E07C4F",
+  // Warm orange       — strings (visible on dark bg)
+  comment: "8B949E",
+  // Muted gray        — comments (italic)
+  number: "79C0FF",
+  // Sky blue          — numbers
+  boolean: "FF9580",
+  // Salmon            — true / false / None
+  function: "D2A8FF",
+  // Soft purple       — function names
+  type: "7EE787",
+  // Bright green      — Types / Classes
+  operator: "FF7B72",
+  // Same as keyword   — = + - * / > <
+  punctuation: "8B9AC0",
+  // Steel blue-gray   — () [] {} , . ;
+  plain: "E2E8F0"
+  // Light gray        — identifiers / plain text
+};
+var SYNTAX_COLORS_LIGHT = {
+  keyword: "D73A49",
+  // Crimson red       — keywords
+  string: "0A7E5C",
+  // Forest teal       — strings (readable on white)
+  comment: "6A737D",
+  // Muted gray        — comments
+  number: "005CC5",
+  // Cobalt blue       — numbers
+  boolean: "D73A49",
+  // Crimson           — true/false/None
+  function: "6F42C1",
+  // Purple            — function names
+  type: "22863A",
+  // Forest green      — Types / Classes
+  operator: "D73A49",
+  // Crimson           — operators
+  punctuation: "586069",
+  // Dark gray         — punctuation
+  plain: "24292E"
+  // Near-black        — identifiers
+};
+var JS_KEYWORDS = /* @__PURE__ */ new Set([
+  "import",
+  "from",
+  "export",
+  "default",
+  "const",
+  "let",
+  "var",
+  "function",
+  "async",
+  "await",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "this",
+  "typeof",
+  "instanceof",
+  "class",
+  "extends",
+  "implements",
+  "interface",
+  "type",
+  "enum",
+  "as",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "void",
+  "yield",
+  "static",
+  "readonly",
+  "private",
+  "public",
+  "protected"
+]);
+var PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+  "def",
+  "class",
+  "import",
+  "from",
+  "as",
+  "return",
+  "if",
+  "elif",
+  "else",
+  "for",
+  "while",
+  "in",
+  "is",
+  "not",
+  "and",
+  "or",
+  "try",
+  "except",
+  "finally",
+  "raise",
+  "with",
+  "yield",
+  "lambda",
+  "global",
+  "nonlocal",
+  "pass",
+  "break",
+  "continue"
+]);
+var BASH_KEYWORDS = /* @__PURE__ */ new Set([
+  "echo",
+  "cd",
+  "ls",
+  "mkdir",
+  "rm",
+  "cp",
+  "mv",
+  "cat",
+  "grep",
+  "find",
+  "curl",
+  "wget",
+  "npm",
+  "bun",
+  "pnpm",
+  "yarn",
+  "git",
+  "export",
+  "source",
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "sudo",
+  "chmod",
+  "chown",
+  "exit"
+]);
+var SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  "select",
+  "from",
+  "where",
+  "insert",
+  "into",
+  "values",
+  "update",
+  "set",
+  "delete",
+  "create",
+  "table",
+  "drop",
+  "alter",
+  "join",
+  "inner",
+  "left",
+  "right",
+  "on",
+  "group",
+  "by",
+  "order",
+  "asc",
+  "desc",
+  "having",
+  "limit",
+  "and",
+  "or",
+  "not",
+  "null",
+  "primary",
+  "key",
+  "foreign",
+  "references"
+]);
+function tokenizeCodeLine(line, lang = "", theme = "dark") {
+  var _a;
+  const COLORS = theme === "light" ? SYNTAX_COLORS_LIGHT : SYNTAX_COLORS;
+  if (!line) {
+    return [{ text: " ", type: "plain", colorHex: COLORS.plain }];
+  }
+  const normalizedLang = (lang || "").toLowerCase().trim();
+  const tokens = [];
+  let pos = 0;
+  if (line.trimStart().startsWith("//") || line.trimStart().startsWith("#") || line.trimStart().startsWith("--")) {
+    const leadWs = ((_a = line.match(/^\s*/)) == null ? void 0 : _a[0]) || "";
+    if (leadWs) {
+      tokens.push({ text: leadWs, type: "plain", colorHex: COLORS.plain });
+    }
+    tokens.push({
+      text: line.slice(leadWs.length),
+      type: "comment",
+      colorHex: COLORS.comment,
+      italic: true
+    });
+    return tokens;
+  }
+  while (pos < line.length) {
+    if (/\s/.test(line[pos])) {
+      let ws = "";
+      while (pos < line.length && /\s/.test(line[pos])) {
+        ws += line[pos++];
+      }
+      tokens.push({ text: ws, type: "plain", colorHex: COLORS.plain });
+      continue;
+    }
+    if (line.slice(pos, pos + 2) === "//") {
+      tokens.push({
+        text: line.slice(pos),
+        type: "comment",
+        colorHex: COLORS.comment,
+        italic: true
+      });
+      break;
+    }
+    if (line[pos] === '"' || line[pos] === "'" || line[pos] === "`") {
+      const quote = line[pos];
+      let str = quote;
+      pos++;
+      while (pos < line.length) {
+        if (line[pos] === "\\" && pos + 1 < line.length) {
+          str += line[pos] + line[pos + 1];
+          pos += 2;
+          continue;
+        }
+        str += line[pos];
+        if (line[pos] === quote) {
+          pos++;
+          break;
+        }
+        pos++;
+      }
+      tokens.push({ text: str, type: "string", colorHex: COLORS.string });
+      continue;
+    }
+    if (/\d/.test(line[pos])) {
+      let num = "";
+      while (pos < line.length && /[\d.a-fA-FxX]/.test(line[pos])) {
+        num += line[pos++];
+      }
+      tokens.push({ text: num, type: "number", colorHex: COLORS.number });
+      continue;
+    }
+    if (/[a-zA-Z_$]/.test(line[pos])) {
+      let word = "";
+      while (pos < line.length && /[a-zA-Z0-9_$]/.test(line[pos])) {
+        word += line[pos++];
+      }
+      if (word === "true" || word === "false" || word === "null" || word === "undefined" || word === "True" || word === "False" || word === "None") {
+        tokens.push({ text: word, type: "boolean", colorHex: COLORS.boolean, bold: true });
+        continue;
+      }
+      const isJsKeyword = (!normalizedLang || ["ts", "typescript", "js", "javascript", "tsx", "jsx"].includes(normalizedLang)) && JS_KEYWORDS.has(word);
+      const isPyKeyword = ["py", "python"].includes(normalizedLang) && PYTHON_KEYWORDS.has(word);
+      const isBashKeyword = ["sh", "bash", "shell", "zsh"].includes(normalizedLang) && BASH_KEYWORDS.has(word);
+      const isSqlKeyword = ["sql"].includes(normalizedLang) && SQL_KEYWORDS.has(word.toLowerCase());
+      if (isJsKeyword || isPyKeyword || isBashKeyword || isSqlKeyword) {
+        tokens.push({ text: word, type: "keyword", colorHex: COLORS.keyword, bold: true });
+        continue;
+      }
+      let nextNonWs = pos;
+      while (nextNonWs < line.length && /\s/.test(line[nextNonWs])) {
+        nextNonWs++;
+      }
+      if (line[nextNonWs] === "(") {
+        tokens.push({ text: word, type: "function", colorHex: COLORS.function });
+        continue;
+      }
+      if (/^[A-Z][a-zA-Z0-9_$]*$/.test(word)) {
+        tokens.push({ text: word, type: "type", colorHex: COLORS.type });
+        continue;
+      }
+      tokens.push({ text: word, type: "plain", colorHex: COLORS.plain });
+      continue;
+    }
+    const char = line[pos++];
+    if (["=", "+", "-", "*", "/", "!", ">", "<", "&", "|", "?", ":"].includes(char)) {
+      tokens.push({ text: char, type: "operator", colorHex: COLORS.operator });
+    } else {
+      tokens.push({ text: char, type: "punctuation", colorHex: COLORS.punctuation });
+    }
+  }
+  return tokens;
+}
+function highlightCodeToHtml(code, lang = "") {
+  const lines = (code || "").split("\n");
+  const htmlLines = lines.map((line) => {
+    const tokens = tokenizeCodeLine(line, lang);
+    return tokens.map((t) => {
+      const escaped = t.text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+      if (t.type === "plain") return escaped;
+      return `<span style="color: #${t.colorHex};${t.bold ? " font-weight: bold;" : ""}${t.italic ? " font-style: italic;" : ""}">${escaped}</span>`;
+    }).join("");
+  });
+  return htmlLines.join("\n");
+}
+
+// src/core/mermaid/mermaidRenderer.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
+
+// src/core/pdf/pdfBuilder.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import { spawnSync } from "child_process";
+
+// src/core/html/htmlBuilder.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/core/html/htmlThemes.ts
+var THEME_COMPONENTS = `
+/* Fallback CSS variables \u2014 overridden by each named theme's :root block */
+:root {
+  --mf-bg: #ffffff;
+  --mf-text: #0f172a;
+  --mf-text-muted: #64748b;
+  --mf-primary: #33CDCF;
+  --mf-primary-dark: #009DA0;
+  --mf-primary-light: #ECFDFD;
+  --mf-border: #e2e8f0;
+  --mf-card-bg: #f8fafc;
+  --mf-code-bg: #0f172a;
+  --mf-code-text: #f8fafc;
+  --mf-font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  --mf-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+
+/* Document header */
+.document-header { margin-bottom: 2.5rem; padding-bottom: 1.5rem; border-bottom: 2px solid var(--mf-border); }
+.document-title { font-size: 2.5rem; font-weight: 800; margin: 0 0 0.5rem 0; }
+.document-subtitle { font-size: 1.25rem; color: var(--mf-text-muted); margin: 0 0 1rem 0; }
+.document-meta { font-size: 0.9rem; color: var(--mf-text-muted); display: flex; gap: 1.5rem; flex-wrap: wrap; }
+
+/* Table of Contents */
+.table-of-contents { background: var(--mf-card-bg); border: 1px solid var(--mf-border); border-radius: 8px; padding: 1.5rem 2rem; margin: 2rem 0; }
+.table-of-contents h2 { font-size: 1rem; text-transform: uppercase; letter-spacing: 0.08em; color: var(--mf-text-muted); margin: 0 0 1rem 0; }
+.table-of-contents ul { list-style: none; padding: 0; margin: 0; }
+.table-of-contents li { padding: 0.25rem 0; }
+.table-of-contents a { color: var(--mf-primary-dark); text-decoration: none; }
+.table-of-contents a:hover { text-decoration: underline; }
+
+/* Links */
+a { color: var(--mf-primary-dark); font-weight: 600; text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+/* Blockquote */
+blockquote { border-left: 4px solid var(--mf-primary); background-color: var(--mf-card-bg); margin: 1.2rem 0; padding: 0.8rem 1.2rem; border-radius: 0 8px 8px 0; color: #334155; font-style: italic; }
+
+/* Callout / Alert Boxes */
+.callout { border-left: 4px solid var(--mf-primary); background: var(--mf-card-bg); border-radius: 6px; padding: 1rem 1.2rem; margin: 1.2rem 0; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-title { font-weight: 700; font-size: 0.85rem; text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 0.4rem; }
+.callout-NOTE      { border-color: #33CDCF; background: #ECFDFD; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-NOTE      .callout-title { color: #009DA0; }
+.callout-TIP       { border-color: #10b981; background: #ecfdf5; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-TIP       .callout-title { color: #10b981; }
+.callout-WARNING   { border-color: #f59e0b; background: #fffbeb; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-WARNING   .callout-title { color: #f59e0b; }
+.callout-CAUTION   { border-color: #ef4444; background: #fef2f2; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-CAUTION   .callout-title { color: #ef4444; }
+.callout-IMPORTANT { border-color: #8b5cf6; background: #f5f3ff; -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+.callout-IMPORTANT .callout-title { color: #8b5cf6; }
+
+/* Inline Code */
+code { font-family: var(--mf-font-mono); font-size: 0.88em; background-color: #f1f5f9; padding: 0.2em 0.4em; border-radius: 4px; color: #0f172a; }
+
+/* Code Blocks */
+pre { background-color: var(--mf-code-bg); color: var(--mf-code-text); padding: 1.2rem; border-radius: 8px; overflow-x: auto; font-family: var(--mf-font-mono); font-size: 0.9rem; line-height: 1.5; margin: 1.2rem 0; }
+pre code { background-color: transparent; color: inherit; padding: 0; }
+
+/* Tables */
+table { width: 100%; border-collapse: collapse; margin: 1.5rem 0; font-size: 0.95rem; }
+th, td { border: 1px solid var(--mf-border); padding: 0.75rem 1rem; text-align: left; }
+th { background-color: var(--mf-card-bg); font-weight: 600; color: #0f172a; }
+tr:nth-child(even) { background-color: var(--mf-card-bg); }
+
+/* Images */
+img { max-width: 100%; height: auto; border-radius: 6px; margin: 1rem 0; }
+
+/* Dividers */
+hr { border: none; border-top: 1px solid var(--mf-border); margin: 2rem 0; }
+
+/* Print / PDF */
+@media print {
+  body { padding: 0; }
+  .document-container { max-width: 100%; }
+  pre, table, blockquote, .callout { break-inside: avoid; }
+  /* Remove scrollbars \u2014 PDF has no scrolling */
+  pre { overflow: visible; white-space: pre-wrap; word-break: break-all; }
+}
+`;
+var THEME_DEFAULT = `
+:root {
+  --mf-bg: #ffffff;
+  --mf-text: #0f172a;
+  --mf-text-muted: #64748b;
+  --mf-primary: #33CDCF;
+  --mf-primary-dark: #009DA0;
+  --mf-primary-light: #ECFDFD;
+  --mf-border: #e2e8f0;
+  --mf-card-bg: #f8fafc;
+  --mf-code-bg: #0f172a;
+  --mf-code-text: #f8fafc;
+  --mf-font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+  --mf-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+body { background-color: var(--mf-bg); color: var(--mf-text); font-family: var(--mf-font-family); font-size: 15px; line-height: 1.65; margin: 0; padding: 2.5rem; }
+.document-container { max-width: 860px; margin: 0 auto; }
+h1, h2, h3, h4, h5, h6 { color: var(--mf-text); font-weight: 700; margin-top: 1.8rem; margin-bottom: 0.8rem; line-height: 1.25; }
+h1 { font-size: 2.2rem; border-bottom: 2px solid #33CDCF; padding-bottom: 0.5rem; }
+h2 { font-size: 1.6rem; color: #009DA0; border-bottom: 1px solid #CCFBF1; padding-bottom: 0.4rem; }
+h3 { font-size: 1.3rem; }
+h4 { font-size: 1.1rem; }
+p  { margin: 0.8rem 0; }
+`;
+var THEME_ACADEMIC = `
+:root {
+  --mf-bg: #ffffff;
+  --mf-text: #1a1a1a;
+  --mf-text-muted: #555;
+  --mf-primary: #33CDCF;
+  --mf-primary-dark: #009DA0;
+  --mf-primary-light: #ECFDFD;
+  --mf-border: #ccc;
+  --mf-card-bg: #f9f9f9;
+  --mf-code-bg: #1e1e1e;
+  --mf-code-text: #d4d4d4;
+  --mf-font-family: "Merriweather", "Georgia", "Times New Roman", serif;
+  --mf-font-mono: "Courier New", Courier, monospace;
+}
+body { font-family: var(--mf-font-family); font-size: 16px; line-height: 1.8; padding: 3rem; color: var(--mf-text); }
+.document-container { max-width: 780px; margin: 0 auto; text-align: justify; }
+h1, h2, h3 { font-family: "Times New Roman", Times, serif; font-weight: bold; text-align: left; }
+h1 { font-size: 2rem; border-bottom: 1px solid #000; padding-bottom: 0.3rem; }
+h2 { font-size: 1.4rem; border-bottom: 1px solid #ccc; padding-bottom: 0.2rem; }
+h3 { font-size: 1.2rem; }
+p  { margin: 0.9rem 0; }
+`;
+var THEMES = {
+  default: THEME_DEFAULT,
+  academic: THEME_ACADEMIC,
+  github: THEME_DEFAULT,
+  corporate: THEME_DEFAULT,
+  minimal: THEME_DEFAULT,
+  dracula: THEME_DEFAULT
+};
+
+// src/core/html/htmlBuilder.ts
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+async function renderInlinesToHtml(spans = [], baseDir = process.cwd()) {
+  let result = "";
+  for (const span of spans) {
+    if (span.type === "image" && span.url) {
+      const resolved = await resolveImage(span.url, baseDir);
+      const src = resolved ? resolved.dataUri : span.url;
+      const alt = escapeHtml(span.alt || "");
+      const title = span.title ? ` title="${escapeHtml(span.title)}"` : "";
+      const width = span.width ? ` width="${span.width}"` : "";
+      const height = span.height ? ` height="${span.height}"` : "";
+      result += `<img src="${src}" alt="${alt}"${title}${width}${height} />`;
+      continue;
+    }
+    if (span.type === "link" && span.url) {
+      const inner = span.children ? await renderInlinesToHtml(span.children, baseDir) : escapeHtml(span.content);
+      const title = span.title ? ` title="${escapeHtml(span.title)}"` : "";
+      result += `<a href="${escapeHtml(span.url)}"${title}>${inner}</a>`;
+      continue;
+    }
+    if (span.type === "bold") {
+      const inner = span.children ? await renderInlinesToHtml(span.children, baseDir) : escapeHtml(span.content);
+      result += `<strong>${inner}</strong>`;
+      continue;
+    }
+    if (span.type === "italic") {
+      const inner = span.children ? await renderInlinesToHtml(span.children, baseDir) : escapeHtml(span.content);
+      result += `<em>${inner}</em>`;
+      continue;
+    }
+    if (span.type === "strikethrough") {
+      const inner = span.children ? await renderInlinesToHtml(span.children, baseDir) : escapeHtml(span.content);
+      result += `<del>${inner}</del>`;
+      continue;
+    }
+    if (span.type === "code") {
+      result += `<code>${escapeHtml(span.content)}</code>`;
+      continue;
+    }
+    if (span.type === "htmlInline") {
+      result += span.content;
+      continue;
+    }
+    result += escapeHtml(span.content);
+  }
+  return result;
+}
+async function buildHtmlDocument(doc, config, baseDir = process.cwd()) {
+  var _a;
+  const metadata = { ...config.metadata, ...doc.metadata };
+  const themeName = metadata.theme || config.theme || "default";
+  const baseThemeCss = THEMES[themeName] || THEMES.default;
+  let customCss = "";
+  if (config.css) {
+    const cssList = Array.isArray(config.css) ? config.css : [config.css];
+    for (const cssPath of cssList) {
+      const fullCssPath = path2.isAbsolute(cssPath) ? cssPath : path2.resolve(baseDir, cssPath);
+      if (fs2.existsSync(fullCssPath)) {
+        customCss += `
+/* Custom CSS: ${cssPath} */
+` + fs2.readFileSync(fullCssPath, "utf-8");
+      }
+    }
+  }
+  const inlinedCss = doc.inlinedStyles.join("\n");
+  let bodyHtml = "";
+  if (metadata.title) {
+    bodyHtml += `  <header class="document-header">
+`;
+    bodyHtml += `    <h1 class="document-title">${escapeHtml(metadata.title)}</h1>
+`;
+    if (metadata.subtitle) {
+      bodyHtml += `    <div class="document-subtitle">${escapeHtml(metadata.subtitle)}</div>
+`;
+    }
+    if (metadata.author || metadata.date) {
+      bodyHtml += `    <div class="document-meta">
+`;
+      if (metadata.author) {
+        const authors = Array.isArray(metadata.author) ? metadata.author.join(", ") : metadata.author;
+        bodyHtml += `      <span>Author: ${escapeHtml(authors)}</span>
+`;
+      }
+      if (metadata.date) {
+        bodyHtml += `      <span>Date: ${escapeHtml(metadata.date)}</span>
+`;
+      }
+      bodyHtml += `    </div>
+`;
+    }
+    bodyHtml += `  </header>
+`;
+  }
+  if (config.toc || metadata.toc) {
+    if (doc.tocEntries.length > 0) {
+      bodyHtml += `  <nav class="table-of-contents">
+`;
+      bodyHtml += `    <h2>Table of Contents</h2>
+    <ul>
+`;
+      for (const entry of doc.tocEntries) {
+        const indent = "  ".repeat(entry.level);
+        bodyHtml += `    ${indent}<li><a href="#${entry.id}">${escapeHtml(entry.text)}</a></li>
+`;
+      }
+      bodyHtml += `    </ul>
+  </nav>
+`;
+    }
+  }
+  for (const node of doc.nodes) {
+    if (node.type === "heading") {
+      const inner = await renderInlinesToHtml(node.inlines, baseDir);
+      bodyHtml += `  <h${node.level} id="${node.id}">${inner}</h${node.level}>
+`;
+      continue;
+    }
+    if (node.type === "paragraph") {
+      const inner = await renderInlinesToHtml(node.inlines, baseDir);
+      bodyHtml += `  <p>${inner}</p>
+`;
+      continue;
+    }
+    if (node.type === "codeBlock") {
+      const lang = node.language || "";
+      const langClass = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+      const highlighted = highlightCodeToHtml(node.text || "", lang);
+      bodyHtml += `  <pre><code${langClass}>${highlighted}</code></pre>
+`;
+      continue;
+    }
+    if (node.type === "mermaid") {
+      bodyHtml += `  <div class="mermaid">
+${escapeHtml(node.text || "")}
+  </div>
+`;
+      continue;
+    }
+    if (node.type === "callout") {
+      const inner = await renderInlinesToHtml(node.inlines, baseDir);
+      const CALLOUT_STYLES = {
+        NOTE: { bg: "#ECFDFD", border: "#33CDCF", titleColor: "#009DA0" },
+        TIP: { bg: "#ecfdf5", border: "#10b981", titleColor: "#10b981" },
+        WARNING: { bg: "#fffbeb", border: "#f59e0b", titleColor: "#f59e0b" },
+        CAUTION: { bg: "#fef2f2", border: "#ef4444", titleColor: "#ef4444" },
+        IMPORTANT: { bg: "#f5f3ff", border: "#8b5cf6", titleColor: "#8b5cf6" }
+      };
+      const cs = CALLOUT_STYLES[node.calloutType ?? "NOTE"] ?? CALLOUT_STYLES["NOTE"];
+      bodyHtml += `  <div class="callout callout-${node.calloutType}" style="border-left:4px solid ${cs.border};background:${cs.bg};border-radius:6px;padding:1rem 1.2rem;margin:1.2rem 0;">
+`;
+      bodyHtml += `    <div class="callout-title" style="font-weight:700;font-size:0.85rem;text-transform:uppercase;letter-spacing:0.05em;margin-bottom:0.4rem;color:${cs.titleColor};">${node.calloutType}</div>
+`;
+      bodyHtml += `    <div class="callout-body">${inner}</div>
+`;
+      bodyHtml += `  </div>
+`;
+      continue;
+    }
+    if (node.type === "blockquote") {
+      const inner = await renderInlinesToHtml(node.inlines, baseDir);
+      bodyHtml += `  <blockquote>${inner}</blockquote>
+`;
+      continue;
+    }
+    if (node.type === "table" && node.children) {
+      bodyHtml += `  <table>
+`;
+      for (const row of node.children) {
+        bodyHtml += `    <tr>
+`;
+        if (row.children) {
+          for (let colIdx = 0; colIdx < row.children.length; colIdx++) {
+            const cell = row.children[colIdx];
+            const tag = row.isHeader ? "th" : "td";
+            const align = ((_a = node.align) == null ? void 0 : _a[colIdx]) ? ` style="text-align: ${node.align[colIdx]}"` : "";
+            const cellInner = await renderInlinesToHtml(cell.inlines, baseDir);
+            bodyHtml += `      <${tag}${align}>${cellInner}</${tag}>
+`;
+          }
+        }
+        bodyHtml += `    </tr>
+`;
+      }
+      bodyHtml += `  </table>
+`;
+      continue;
+    }
+    if (node.type === "list" && node.children) {
+      const tag = node.ordered ? "ol" : "ul";
+      bodyHtml += `  <${tag}>
+`;
+      for (const item of node.children) {
+        const itemInner = await renderInlinesToHtml(item.inlines, baseDir);
+        let prefix = "";
+        if (item.checked !== void 0) {
+          prefix = `<input type="checkbox" disabled ${item.checked ? "checked" : ""}/> `;
+        }
+        bodyHtml += `    <li>${prefix}${itemInner}</li>
+`;
+      }
+      bodyHtml += `  </${tag}>
+`;
+      continue;
+    }
+    if (node.type === "htmlBlock") {
+      bodyHtml += `  ${node.rawHtml}
+`;
+      continue;
+    }
+    if (node.type === "thematicBreak") {
+      bodyHtml += `  <hr />
+`;
+      continue;
+    }
+  }
+  const wmConfig = config.watermark ?? metadata.watermark;
+  let watermarkHtml = "";
+  let watermarkCss = "";
+  if (wmConfig) {
+    const wmText = typeof wmConfig === "string" ? wmConfig : wmConfig.text;
+    const opacity = typeof wmConfig === "object" && wmConfig.opacity !== void 0 ? wmConfig.opacity : 0.12;
+    const rotate = typeof wmConfig === "object" && wmConfig.rotate !== void 0 ? wmConfig.rotate : -45;
+    const color = typeof wmConfig === "object" && wmConfig.color ? wmConfig.color : "#94A3B8";
+    const fontSize = typeof wmConfig === "object" && wmConfig.fontSize ? `${wmConfig.fontSize}pt` : "52pt";
+    watermarkCss = `
+  .document-watermark {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%) rotate(${rotate}deg);
+    font-size: ${fontSize};
+    font-weight: 800;
+    color: ${color};
+    opacity: ${opacity};
+    pointer-events: none;
+    user-select: none;
+    z-index: 9999;
+    text-transform: uppercase;
+    letter-spacing: 0.15em;
+    white-space: nowrap;
+  }
+  `;
+    watermarkHtml = `  <div class="document-watermark">${escapeHtml(wmText)}</div>
+`;
+  }
+  const hasMermaid = doc.nodes.some((n) => n.type === "mermaid");
+  const mermaidScript = hasMermaid ? `<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({
+      startOnLoad: true,
+      theme: 'neutral',
+      themeVariables: {
+        primaryColor: '#33CDCF',
+        primaryTextColor: '#0F172A',
+        primaryBorderColor: '#009DA0',
+        lineColor: '#009DA0',
+        secondaryColor: '#ECFDFD',
+        tertiaryColor: '#F8FAFC'
+      }
+    });
+  </script>` : "";
+  const documentTitle = metadata.title || "MarkForge Document";
+  return `<!DOCTYPE html>
+<html lang="${metadata.lang || "en"}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(documentTitle)}</title>
+  <style>
+${THEME_COMPONENTS}
+${baseThemeCss}
+${customCss}
+${inlinedCss}
+${watermarkCss}
+  </style>
+</head>
+<body>
+${watermarkHtml}  <div class="document-container">
+${bodyHtml}  </div>
+  ${mermaidScript}
+</body>
+</html>`;
+}
+
+// src/core/pdf/pdfBuilder.ts
+function findChromeExecutable() {
+  if (process.env.CHROME_PATH && fs3.existsSync(process.env.CHROME_PATH)) {
+    return process.env.CHROME_PATH;
+  }
+  if (process.env.PUPPETEER_EXECUTABLE_PATH && fs3.existsSync(process.env.PUPPETEER_EXECUTABLE_PATH)) {
+    return process.env.PUPPETEER_EXECUTABLE_PATH;
+  }
+  const candidates = [
+    // Linux
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    // macOS
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    // Windows
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (fs3.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  try {
+    const isWin = process.platform === "win32";
+    const cmd = isWin ? "where" : "which";
+    for (const name of ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]) {
+      const res = spawnSync(cmd, [name], { encoding: "utf-8" });
+      if (res.status === 0 && res.stdout.trim()) {
+        const binPath = res.stdout.split(/\r?\n/)[0].trim();
+        if (fs3.existsSync(binPath)) return binPath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function injectPagedMediaStyles(html, config, metadata) {
+  var _a, _b, _c, _d;
+  const merged = { ...config.metadata, ...metadata };
+  const orientation = merged.orientation || config.orientation || "portrait";
+  const size = merged.paperSize || config.paperSize || "A4";
+  const margins = merged.margins || config.margins || {};
+  const top = margins.top || ((_a = config.margins) == null ? void 0 : _a.top) || "2.5cm";
+  const bottom = margins.bottom || ((_b = config.margins) == null ? void 0 : _b.bottom) || "2.5cm";
+  const left = margins.left || ((_c = config.margins) == null ? void 0 : _c.left) || "2.5cm";
+  const right = margins.right || ((_d = config.margins) == null ? void 0 : _d.right) || "2.5cm";
+  const headerCfg = merged.header;
+  const footerCfg = merged.footer;
+  const headerLeft = (headerCfg == null ? void 0 : headerCfg.left) ?? "";
+  const headerCenter = (headerCfg == null ? void 0 : headerCfg.center) ?? "";
+  const headerRight = (headerCfg == null ? void 0 : headerCfg.right) ?? "";
+  const footerLeft = ((footerCfg == null ? void 0 : footerCfg.left) ?? "").replace("{page}", "").replace("{pages}", "").trim();
+  const esc = (s) => s.replace(/"/g, '"').replace(/\\/g, "\\\\");
+  const pagedCss = `
+  @page {
+    size: ${size} ${orientation};
+    margin-top: ${top};
+    margin-bottom: ${bottom};
+    margin-left: ${left};
+    margin-right: ${right};
+    ${headerLeft ? `@top-left { content: "${esc(headerLeft)}"; font-size: 9pt; color: #94a3b8; }` : ""}
+    ${headerCenter ? `@top-center { content: "${esc(headerCenter)}"; font-size: 9pt; color: #94a3b8; }` : ""}
+    ${headerRight ? `@top-right { content: "${esc(headerRight)}"; font-size: 9pt; color: #94a3b8; }` : ""}
+    ${footerLeft ? `@bottom-left { content: "${esc(footerLeft)}"; font-size: 9pt; color: #94a3b8; }` : ""}
+    @bottom-right {
+      content: "Page " counter(page) " of " counter(pages);
+      font-size: 9pt;
+      color: #94a3b8;
+    }
+  }
+  @media print {
+    body { padding: 0; }
+    h1, h2, h3, pre, table, blockquote, .callout {
+      break-inside: avoid;
+    }
+  }
+  `;
+  return html.replace("</head>", `<style>${pagedCss}</style></head>`);
+}
+function createFallbackPdfBuffer(title = "Document") {
+  const streamContent = `BT /F1 18 Tf 50 750 Td (${title}) Tj ET
+BT /F1 12 Tf 50 720 Td (Generated via MarkForge Fallback Renderer) Tj ET`;
+  const streamLength = Buffer.byteLength(streamContent, "utf-8");
+  const pdfBody = `%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+2 0 obj
+<< /Type /Pages /Kids [3 0 R] /Count 1 >>
+endobj
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595.28 841.89] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>
+endobj
+4 0 obj
+<< /Length ${streamLength} >>
+stream
+${streamContent}
+endstream
+endobj
+5 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+xref
+0 6
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000266 00000 n 
+0000000373 00000 n 
+trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+453
+%%EOF
+`;
+  return Buffer.from(pdfBody, "utf-8");
+}
+async function buildPdfDocument(doc, config, baseDir = process.cwd()) {
+  const baseHtml = await buildHtmlDocument(doc, config, baseDir);
+  const pagedHtml = injectPagedMediaStyles(baseHtml, config, doc.metadata);
+  const chromePath = findChromeExecutable();
+  if (chromePath) {
+    const tmpId = Math.random().toString(36).substring(2, 9);
+    const tmpDir = os.tmpdir();
+    const tmpHtml = path3.join(tmpDir, `markforge_${tmpId}.html`);
+    const tmpPdf = path3.join(tmpDir, `markforge_${tmpId}.pdf`);
+    try {
+      fs3.writeFileSync(tmpHtml, pagedHtml, "utf-8");
+      let res = spawnSync(
+        chromePath,
+        [
+          "--headless=new",
+          "--disable-gpu",
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--allow-file-access-from-files",
+          "--force-color-profile=srgb",
+          "--run-all-compositor-stages-before-draw",
+          "--virtual-time-budget=8000",
+          "--no-pdf-header-footer",
+          `--print-to-pdf=${tmpPdf}`,
+          tmpHtml
+        ],
+        { timeout: 3e4 }
+      );
+      if ((res.status !== 0 || !fs3.existsSync(tmpPdf)) && chromePath) {
+        res = spawnSync(
+          chromePath,
+          [
+            "--headless",
+            "--disable-gpu",
+            "--no-sandbox",
+            "--disable-setuid-sandbox",
+            "--allow-file-access-from-files",
+            "--force-color-profile=srgb",
+            "--no-pdf-header-footer",
+            `--print-to-pdf=${tmpPdf}`,
+            tmpHtml
+          ],
+          { timeout: 3e4 }
+        );
+      }
+      if (fs3.existsSync(tmpPdf) && fs3.statSync(tmpPdf).size > 0) {
+        const pdfBuffer = fs3.readFileSync(tmpPdf);
+        return pdfBuffer;
+      }
+    } catch {
+    } finally {
+      try {
+        if (fs3.existsSync(tmpHtml)) fs3.unlinkSync(tmpHtml);
+        if (fs3.existsSync(tmpPdf)) fs3.unlinkSync(tmpPdf);
+      } catch {
+      }
+    }
+  }
+  return createFallbackPdfBuffer(doc.metadata.title || "MarkForge Document");
+}
+
+// src/core/mermaid/mermaidRenderer.ts
+async function renderMermaidToPng(mermaidCode, _baseDir = process.cwd()) {
+  const chromePath = findChromeExecutable();
+  if (!chromePath) {
+    return null;
+  }
+  const tmpId = Math.random().toString(36).substring(2, 9);
+  const tmpDir = os2.tmpdir();
+  const tmpHtml = path4.join(tmpDir, `mermaid_${tmpId}.html`);
+  const tmpScreenshot = path4.join(tmpDir, `mermaid_${tmpId}.png`);
+  const htmlContent = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+  <style>
+    body {
+      margin: 0;
+      padding: 16px;
+      background: #ffffff;
+      display: inline-block;
+    }
+    .mermaid {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    }
+  </style>
+</head>
+<body>
+  <div id="container" class="mermaid">
+${mermaidCode}
+  </div>
+  <script>
+    mermaid.initialize({
+      startOnLoad: true,
+      theme: 'neutral',
+      themeVariables: {
+        primaryColor: '#33CDCF',
+        primaryTextColor: '#0F172A',
+        primaryBorderColor: '#009DA0',
+        lineColor: '#009DA0',
+        secondaryColor: '#ECFDFD',
+        tertiaryColor: '#F8FAFC'
+      }
+    });
+  </script>
+</body>
+</html>`;
+  try {
+    fs4.writeFileSync(tmpHtml, htmlContent, "utf-8");
+    const res = spawnSync2(
+      chromePath,
+      [
+        "--headless",
+        "--disable-gpu",
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--window-size=1200,800",
+        `--screenshot=${tmpScreenshot}`,
+        tmpHtml
+      ],
+      { timeout: 15e3 }
+    );
+    if (res.status === 0 && fs4.existsSync(tmpScreenshot)) {
+      const buffer = fs4.readFileSync(tmpScreenshot);
+      return buffer;
+    }
+  } catch {
+  } finally {
+    try {
+      if (fs4.existsSync(tmpHtml)) fs4.unlinkSync(tmpHtml);
+      if (fs4.existsSync(tmpScreenshot)) fs4.unlinkSync(tmpScreenshot);
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/core/docx/docxBuilder.ts
+function parseMarginToTwip(margin, defaultTwip = 1440) {
+  if (typeof margin === "number") return margin;
+  if (!margin) return defaultTwip;
+  const str = margin.trim().toLowerCase();
+  if (str.endsWith("cm")) {
+    const cm = parseFloat(str);
+    return Math.round(convertMillimetersToTwip(cm * 10));
+  }
+  if (str.endsWith("mm")) {
+    const mm = parseFloat(str);
+    return Math.round(convertMillimetersToTwip(mm));
+  }
+  if (str.endsWith("in") || str.endsWith("inch")) {
+    const inch = parseFloat(str);
+    return Math.round(convertInchesToTwip(inch));
+  }
+  if (str.endsWith("pt")) {
+    const pt = parseFloat(str);
+    return Math.round(pt * 20);
+  }
+  const val = parseFloat(str);
+  return isNaN(val) ? defaultTwip : Math.round(val);
+}
+async function convertInlinesToTextRuns(spans = [], baseDir = process.cwd()) {
+  const runs = [];
+  for (const span of spans) {
+    if (span.type === "image" && span.url) {
+      const resolved = await resolveImage(span.url, baseDir);
+      if (resolved) {
+        let width = 500;
+        let height = 300;
+        if (span.width) width = parseInt(String(span.width), 10) || 500;
+        if (span.height) height = parseInt(String(span.height), 10) || 300;
+        runs.push(
+          new ImageRun({
+            data: resolved.buffer,
+            transformation: {
+              width: Math.min(width, 550),
+              height: Math.min(height, 400)
+            },
+            type: "png"
+          })
+        );
+      }
+      continue;
+    }
+    if (span.type === "link" && span.url) {
+      runs.push(
+        new ExternalHyperlink({
+          children: [
+            new TextRun({
+              text: span.content,
+              style: "Hyperlink",
+              color: "0969DA",
+              underline: {}
+            })
+          ],
+          link: span.url
+        })
+      );
+      continue;
+    }
+    if (span.type === "bold") {
+      runs.push(
+        new TextRun({
+          text: span.content,
+          bold: true
+        })
+      );
+      continue;
+    }
+    if (span.type === "italic") {
+      runs.push(
+        new TextRun({
+          text: span.content,
+          italics: true
+        })
+      );
+      continue;
+    }
+    if (span.type === "strikethrough") {
+      runs.push(
+        new TextRun({
+          text: span.content,
+          strike: true
+        })
+      );
+      continue;
+    }
+    if (span.type === "code") {
+      runs.push(
+        new TextRun({
+          text: ` ${span.content} `,
+          font: "Consolas",
+          shading: {
+            type: ShadingType.CLEAR,
+            fill: "F1F5F9",
+            color: "0F172A"
+          }
+        })
+      );
+      continue;
+    }
+    if (span.type === "htmlInline") {
+      let colorHex;
+      let bgHex;
+      let isBold = false;
+      let isItalic = false;
+      if (span.style) {
+        if (span.style.color) {
+          colorHex = span.style.color.replace("#", "").trim();
+        }
+        if (span.style.background || span.style["background-color"]) {
+          bgHex = (span.style.background || span.style["background-color"]).replace("#", "").trim();
+        }
+        if (span.style["font-weight"] === "bold" || span.style["font-weight"] === "700") {
+          isBold = true;
+        }
+        if (span.style["font-style"] === "italic") {
+          isItalic = true;
+        }
+      }
+      if (span.children && span.children.length > 0) {
+        const childRuns = await convertInlinesToTextRuns(span.children, baseDir);
+        for (const child of childRuns) {
+          if (child instanceof TextRun) {
+            runs.push(child);
+          } else {
+            runs.push(child);
+          }
+        }
+        continue;
+      }
+      runs.push(
+        new TextRun({
+          text: span.content,
+          color: colorHex,
+          bold: isBold,
+          italics: isItalic,
+          shading: bgHex ? { type: ShadingType.CLEAR, fill: bgHex } : void 0
+        })
+      );
+      continue;
+    }
+    runs.push(
+      new TextRun({
+        text: span.content
+      })
+    );
+  }
+  return runs;
+}
+async function buildDocxDocument(doc, config, baseDir = process.cwd()) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const metadata = { ...config.metadata, ...doc.metadata };
+  const docElements = [];
+  if (metadata.title) {
+    docElements.push(
+      new Paragraph({
+        text: metadata.title,
+        heading: HeadingLevel.TITLE,
+        spacing: { before: 200, after: 120 }
+      })
+    );
+    if (metadata.subtitle) {
+      docElements.push(
+        new Paragraph({
+          children: [
+            new TextRun({
+              text: metadata.subtitle,
+              italics: true,
+              color: "64748B",
+              size: 24
+              // 12pt
+            })
+          ],
+          spacing: { after: 180 }
+        })
+      );
+    }
+    if (metadata.author || metadata.date) {
+      const metaParts = [];
+      if (metadata.author) metaParts.push(`Author: ${Array.isArray(metadata.author) ? metadata.author.join(", ") : metadata.author}`);
+      if (metadata.date) metaParts.push(`Date: ${metadata.date}`);
+      docElements.push(
+        new Paragraph({
+          children: [
+            new TextRun({
+              text: metaParts.join("  |  "),
+              color: "94A3B8",
+              size: 20
+              // 10pt
+            })
+          ],
+          spacing: { after: 360 },
+          border: {
+            bottom: {
+              color: "E2E8F0",
+              space: 10,
+              style: BorderStyle.SINGLE,
+              size: 6
+            }
+          }
+        })
+      );
+    }
+  }
+  for (const node of doc.nodes) {
+    if (node.type === "heading") {
+      let headingLevel = HeadingLevel.HEADING_1;
+      if (node.level === 2) headingLevel = HeadingLevel.HEADING_2;
+      if (node.level === 3) headingLevel = HeadingLevel.HEADING_3;
+      if (node.level === 4) headingLevel = HeadingLevel.HEADING_4;
+      if (node.level === 5) headingLevel = HeadingLevel.HEADING_5;
+      if (node.level === 6) headingLevel = HeadingLevel.HEADING_6;
+      const runs = await convertInlinesToTextRuns(node.inlines, baseDir);
+      docElements.push(
+        new Paragraph({
+          heading: headingLevel,
+          children: runs,
+          spacing: { before: 240, after: 120 }
+        })
+      );
+      continue;
+    }
+    if (node.type === "paragraph") {
+      const runs = await convertInlinesToTextRuns(node.inlines, baseDir);
+      docElements.push(
+        new Paragraph({
+          children: runs,
+          spacing: { before: 60, after: 140 }
+        })
+      );
+      continue;
+    }
+    if (node.type === "codeBlock") {
+      const codeLines = (node.text || "").split("\n");
+      const codeParagraphs = codeLines.map((l) => {
+        const tokens = tokenizeCodeLine(l, node.language, "light");
+        const textRuns = tokens.map(
+          (t) => new TextRun({
+            text: t.text,
+            font: "Consolas",
+            size: 19,
+            // 9.5pt
+            color: t.colorHex,
+            bold: t.bold,
+            italics: t.italic
+          })
+        );
+        return new Paragraph({
+          children: textRuns,
+          spacing: { before: 20, after: 20 }
+        });
+      });
+      const codeTable = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        columnWidths: [9e3],
+        rows: [
+          new TableRow({
+            children: [
+              new TableCell({
+                width: { size: 9e3, type: WidthType.DXA },
+                shading: { fill: "F8FAFC", type: ShadingType.CLEAR },
+                margins: { top: 140, bottom: 140, left: 180, right: 180 },
+                borders: {
+                  top: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" },
+                  bottom: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" },
+                  left: { style: BorderStyle.SINGLE, size: 8, color: "33CDCF" },
+                  right: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" }
+                },
+                children: codeParagraphs
+              })
+            ]
+          })
+        ]
+      });
+      docElements.push(codeTable);
+      docElements.push(new Paragraph({ spacing: { after: 120 } }));
+      continue;
+    }
+    if (node.type === "callout") {
+      let borderColor = "33CDCF";
+      let bgFill = "ECFDFD";
+      let title = "NOTE";
+      if (node.calloutType === "TIP") {
+        borderColor = "10B981";
+        bgFill = "ECFDF5";
+        title = "TIP";
+      } else if (node.calloutType === "WARNING") {
+        borderColor = "F59E0B";
+        bgFill = "FFFBEB";
+        title = "WARNING";
+      } else if (node.calloutType === "CAUTION") {
+        borderColor = "EF4444";
+        bgFill = "FEF2F2";
+        title = "CAUTION";
+      } else if (node.calloutType === "IMPORTANT") {
+        borderColor = "8B5CF6";
+        bgFill = "F5F3FF";
+        title = "IMPORTANT";
+      }
+      const runs = await convertInlinesToTextRuns(node.inlines, baseDir);
+      const calloutTable = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        columnWidths: [9e3],
+        rows: [
+          new TableRow({
+            children: [
+              new TableCell({
+                width: { size: 9e3, type: WidthType.DXA },
+                shading: { fill: bgFill, type: ShadingType.CLEAR },
+                margins: { top: 120, bottom: 120, left: 160, right: 160 },
+                borders: {
+                  top: { style: BorderStyle.NONE },
+                  bottom: { style: BorderStyle.NONE },
+                  right: { style: BorderStyle.NONE },
+                  left: { style: BorderStyle.SINGLE, size: 16, color: borderColor }
+                },
+                children: [
+                  new Paragraph({
+                    children: [
+                      new TextRun({
+                        text: `[${title}]`,
+                        bold: true,
+                        color: borderColor,
+                        size: 20
+                      })
+                    ],
+                    spacing: { after: 60 }
+                  }),
+                  new Paragraph({
+                    children: runs
+                  })
+                ]
+              })
+            ]
+          })
+        ]
+      });
+      docElements.push(calloutTable);
+      docElements.push(new Paragraph({ spacing: { after: 120 } }));
+      continue;
+    }
+    if (node.type === "blockquote") {
+      const quoteParagraphs = [];
+      const lines = (node.text || "").split("\n\n").filter(Boolean);
+      if (lines.length > 0) {
+        for (const lineText of lines) {
+          const spans = parseInlineSpans(lineText.replace(/^>\s?/, "").trim());
+          const lineRuns = await convertInlinesToTextRuns(spans, baseDir);
+          quoteParagraphs.push(
+            new Paragraph({
+              children: lineRuns,
+              spacing: { before: 40, after: 40 }
+            })
+          );
+        }
+      } else {
+        const runs = await convertInlinesToTextRuns(node.inlines, baseDir);
+        quoteParagraphs.push(new Paragraph({ children: runs }));
+      }
+      const quoteTable = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        columnWidths: [9e3],
+        rows: [
+          new TableRow({
+            children: [
+              new TableCell({
+                width: { size: 9e3, type: WidthType.DXA },
+                shading: { fill: "F8FAFC", type: ShadingType.CLEAR },
+                margins: { top: 100, bottom: 100, left: 140, right: 140 },
+                borders: {
+                  top: { style: BorderStyle.NONE },
+                  bottom: { style: BorderStyle.NONE },
+                  right: { style: BorderStyle.NONE },
+                  left: { style: BorderStyle.SINGLE, size: 12, color: "33CDCF" }
+                },
+                children: quoteParagraphs
+              })
+            ]
+          })
+        ]
+      });
+      docElements.push(quoteTable);
+      docElements.push(new Paragraph({ spacing: { after: 120 } }));
+      continue;
+    }
+    if (node.type === "mermaid") {
+      const pngBuffer = await renderMermaidToPng(node.text || "", baseDir);
+      if (pngBuffer) {
+        docElements.push(
+          new Paragraph({
+            alignment: AlignmentType.CENTER,
+            children: [
+              new ImageRun({
+                data: pngBuffer,
+                transformation: {
+                  width: 550,
+                  height: 320
+                },
+                type: "png"
+              })
+            ],
+            spacing: { before: 120, after: 120 }
+          })
+        );
+      } else {
+        docElements.push(
+          new Paragraph({
+            children: [
+              new TextRun({ text: "[Mermaid Diagram: " + (node.text || "").slice(0, 40) + "...]", bold: true, color: "33CDCF" })
+            ],
+            spacing: { before: 60, after: 60 }
+          })
+        );
+      }
+      continue;
+    }
+    if (node.type === "table" && node.children) {
+      const tableRows = [];
+      const numCols = ((_b = (_a = node.children[0]) == null ? void 0 : _a.children) == null ? void 0 : _b.length) || 1;
+      const colWidth = Math.floor(9e3 / numCols);
+      for (const rowNode of node.children) {
+        const cells = [];
+        if (rowNode.children) {
+          for (let colIdx = 0; colIdx < rowNode.children.length; colIdx++) {
+            const cellNode = rowNode.children[colIdx];
+            const align = (_c = node.align) == null ? void 0 : _c[colIdx];
+            let alignment = AlignmentType.LEFT;
+            if (align === "center") alignment = AlignmentType.CENTER;
+            if (align === "right") alignment = AlignmentType.RIGHT;
+            const runs = await convertInlinesToTextRuns(cellNode.inlines, baseDir);
+            cells.push(
+              new TableCell({
+                width: { size: colWidth, type: WidthType.DXA },
+                shading: rowNode.isHeader ? { fill: "F1F5F9", type: ShadingType.CLEAR } : void 0,
+                margins: { top: 100, bottom: 100, left: 120, right: 120 },
+                borders: {
+                  top: { style: BorderStyle.SINGLE, size: 4, color: "CBD5E1" },
+                  bottom: { style: BorderStyle.SINGLE, size: 4, color: "CBD5E1" },
+                  left: { style: BorderStyle.SINGLE, size: 4, color: "CBD5E1" },
+                  right: { style: BorderStyle.SINGLE, size: 4, color: "CBD5E1" }
+                },
+                children: [
+                  new Paragraph({
+                    alignment,
+                    children: rowNode.isHeader ? runs.map((r) => r instanceof TextRun ? new TextRun({ ...r, bold: true, color: "0F172A" }) : r) : runs
+                  })
+                ]
+              })
+            );
+          }
+        }
+        tableRows.push(
+          new TableRow({
+            tableHeader: rowNode.isHeader,
+            children: cells
+          })
+        );
+      }
+      const docxTable = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        columnWidths: Array(numCols).fill(colWidth),
+        rows: tableRows
+      });
+      docElements.push(docxTable);
+      docElements.push(new Paragraph({ spacing: { after: 140 } }));
+      continue;
+    }
+    if (node.type === "list" && node.children) {
+      for (const item of node.children) {
+        const runs = await convertInlinesToTextRuns(item.inlines, baseDir);
+        let prefix = "";
+        if (item.checked !== void 0) {
+          prefix = item.checked ? "[X] " : "[ ] ";
+        }
+        docElements.push(
+          new Paragraph({
+            bullet: node.ordered ? void 0 : { level: 0 },
+            children: [
+              ...prefix ? [new TextRun({ text: prefix, bold: true, font: "Consolas" })] : [],
+              ...runs
+            ],
+            spacing: { before: 40, after: 40 }
+          })
+        );
+      }
+      docElements.push(new Paragraph({ spacing: { after: 80 } }));
+      continue;
+    }
+    if (node.type === "thematicBreak") {
+      docElements.push(
+        new Paragraph({
+          spacing: { before: 180, after: 180 },
+          border: {
+            bottom: {
+              color: "E2E8F0",
+              space: 4,
+              style: BorderStyle.SINGLE,
+              size: 6
+            }
+          }
+        })
+      );
+      continue;
+    }
+    if (node.type === "htmlBlock" && node.rawHtml) {
+      const isCard = node.rawHtml.includes("card") || node.rawHtml.includes("box") || node.rawHtml.includes("metric");
+      const cleanInner = node.rawHtml.replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<\/p>/gi, "\n\n").replace(/<\/div>/gi, "\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/[ \t]+/g, " ").replace(/\n\s+/g, "\n").trim();
+      if (cleanInner) {
+        const innerParagraphs = cleanInner.split("\n\n").filter(Boolean);
+        const paraElements = [];
+        for (const p of innerParagraphs) {
+          const spans = parseInlineSpans(p.trim());
+          const runs = await convertInlinesToTextRuns(spans, baseDir);
+          if (runs.length > 0) {
+            paraElements.push(
+              new Paragraph({
+                children: runs,
+                spacing: { before: 30, after: 30 }
+              })
+            );
+          }
+        }
+        if (isCard && paraElements.length > 0) {
+          const cardTable = new Table({
+            width: { size: 100, type: WidthType.PERCENTAGE },
+            columnWidths: [9e3],
+            rows: [
+              new TableRow({
+                children: [
+                  new TableCell({
+                    width: { size: 9e3, type: WidthType.DXA },
+                    shading: { fill: "F8FAFC", type: ShadingType.CLEAR },
+                    margins: { top: 140, bottom: 140, left: 180, right: 180 },
+                    borders: {
+                      top: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" },
+                      bottom: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" },
+                      left: { style: BorderStyle.SINGLE, size: 8, color: "33CDCF" },
+                      right: { style: BorderStyle.SINGLE, size: 4, color: "E2E8F0" }
+                    },
+                    children: paraElements
+                  })
+                ]
+              })
+            ]
+          });
+          docElements.push(cardTable);
+          docElements.push(new Paragraph({ spacing: { after: 120 } }));
+        } else {
+          for (const pe of paraElements) {
+            docElements.push(pe);
+          }
+        }
+      }
+      continue;
+    }
+  }
+  const headerObj = metadata.header || config.header;
+  const footerObj = metadata.footer || config.footer;
+  const headerTabStops = [
+    { type: TabStopType.CENTER, position: 4513 },
+    { type: TabStopType.RIGHT, position: 9026 }
+  ];
+  const docHeader = headerObj ? new Header({
+    children: [
+      new Paragraph({
+        tabStops: headerTabStops,
+        children: [
+          // Left zone
+          ...headerObj.left ? [
+            new TextRun({
+              text: headerObj.left.replace("{title}", metadata.title || ""),
+              color: "94A3B8",
+              size: 18
+            })
+          ] : [],
+          // Center zone (tab + text)
+          ...headerObj.center ? [
+            new TextRun({ text: "	", color: "94A3B8", size: 18 }),
+            new TextRun({
+              text: headerObj.center.replace("{title}", metadata.title || ""),
+              color: "94A3B8",
+              size: 18
+            })
+          ] : [],
+          // Right zone (tab + text) — skip extra tab if center already used one
+          ...headerObj.right ? [
+            new TextRun({
+              text: headerObj.left || headerObj.center ? "	" : "",
+              color: "94A3B8",
+              size: 18
+            }),
+            new TextRun({
+              text: headerObj.right.replace("{title}", metadata.title || ""),
+              color: "94A3B8",
+              size: 18
+            })
+          ] : []
+        ]
+      })
+    ]
+  }) : void 0;
+  const docFooter = footerObj ? new Footer({
+    children: [
+      new Paragraph({
+        tabStops: headerTabStops,
+        children: [
+          // Left zone
+          ...footerObj.left ? [
+            new TextRun({
+              text: footerObj.left.replace("{page}", "").replace("{pages}", "").trim(),
+              color: "94A3B8",
+              size: 18
+            })
+          ] : [],
+          // Right zone: always includes page number if right is configured or footer exists
+          new TextRun({ text: "	", color: "94A3B8", size: 18 }),
+          new TextRun({ text: "Page ", color: "94A3B8", size: 18 }),
+          new TextRun({ children: [PageNumber.CURRENT], color: "94A3B8", size: 18 }),
+          new TextRun({ text: " of ", color: "94A3B8", size: 18 }),
+          new TextRun({ children: [PageNumber.TOTAL_PAGES], color: "94A3B8", size: 18 })
+        ]
+      })
+    ]
+  }) : void 0;
+  const topMargin = parseMarginToTwip(((_d = metadata.margins) == null ? void 0 : _d.top) || ((_e = config.margins) == null ? void 0 : _e.top), 1440);
+  const bottomMargin = parseMarginToTwip(((_f = metadata.margins) == null ? void 0 : _f.bottom) || ((_g = config.margins) == null ? void 0 : _g.bottom), 1440);
+  const leftMargin = parseMarginToTwip(((_h = metadata.margins) == null ? void 0 : _h.left) || ((_i = config.margins) == null ? void 0 : _i.left), 1440);
+  const rightMargin = parseMarginToTwip(((_j = metadata.margins) == null ? void 0 : _j.right) || ((_k = config.margins) == null ? void 0 : _k.right), 1440);
+  const isLandscape = (metadata.orientation || config.orientation) === "landscape";
+  const document = new Document({
+    styles: {
+      default: {
+        document: {
+          run: {
+            font: "Segoe UI",
+            size: 22,
+            // 11pt
+            color: "0F172A"
+          }
+        }
+      }
+    },
+    sections: [
+      {
+        properties: {
+          page: {
+            size: {
+              orientation: isLandscape ? PageOrientation.LANDSCAPE : PageOrientation.PORTRAIT
+            },
+            margin: {
+              top: topMargin,
+              bottom: bottomMargin,
+              left: leftMargin,
+              right: rightMargin,
+              header: 720,
+              footer: 720
+            }
+          }
+        },
+        headers: docHeader ? { default: docHeader } : void 0,
+        footers: docFooter ? { default: docFooter } : void 0,
+        children: docElements
+      }
+    ]
+  });
+  return await Packer.toBuffer(document);
+}
+
+// src/config/loadConfig.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { pathToFileURL } from "url";
+import * as YAML from "yaml";
+var DEFAULT_CONFIG_FILENAMES = [
+  "markforge.config.json",
+  ".markforgerc.json",
+  "markforge.config.yaml",
+  "markforge.config.yml",
+  ".markforgerc.yaml",
+  ".markforgerc.yml",
+  ".markforgerc",
+  "markforge.config.ts",
+  "markforge.config.js",
+  "markforge.config.mjs",
+  "markforge.config.cjs"
+];
+var DEFAULT_CONFIG = {
+  to: ["docx", "pdf"],
+  outputDir: void 0,
+  theme: "default",
+  css: void 0,
+  orientation: "portrait",
+  paperSize: "A4",
+  margins: {
+    top: "2.5cm",
+    bottom: "2.5cm",
+    left: "2.5cm",
+    right: "2.5cm"
+  },
+  header: void 0,
+  footer: {
+    right: "Page {page} of {pages}"
+  },
+  toc: false,
+  watermark: void 0,
+  embedImages: true,
+  metadata: void 0,
+  watch: false,
+  serve: false,
+  port: 4e3,
+  open: false,
+  bundleHtml: true,
+  syntaxTheme: "github-dark"
+};
+async function loadConfig(customPath, cwd = process.cwd()) {
+  let resolvedPath = null;
+  if (customPath) {
+    resolvedPath = path5.isAbsolute(customPath) ? customPath : path5.resolve(cwd, customPath);
+    if (!fs5.existsSync(resolvedPath)) {
+      throw new Error(`Configuration file not found: ${resolvedPath}`);
+    }
+  } else {
+    for (const filename of DEFAULT_CONFIG_FILENAMES) {
+      const candidate = path5.resolve(cwd, filename);
+      if (fs5.existsSync(candidate)) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+  }
+  if (!resolvedPath) {
+    return {
+      config: { ...DEFAULT_CONFIG },
+      configPath: null
+    };
+  }
+  const ext = path5.extname(resolvedPath).toLowerCase();
+  let userConfig = {};
+  if (ext === ".json" || resolvedPath.endsWith(".markforgerc")) {
+    const raw = fs5.readFileSync(resolvedPath, "utf-8");
+    userConfig = JSON.parse(raw);
+  } else if (ext === ".yaml" || ext === ".yml") {
+    const raw = fs5.readFileSync(resolvedPath, "utf-8");
+    userConfig = YAML.parse(raw);
+  } else if (ext === ".ts" || ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+    try {
+      const fileUrl = pathToFileURL(resolvedPath).href;
+      const mod = await import(fileUrl);
+      userConfig = mod.default || mod;
+    } catch {
+      const required = __require(resolvedPath);
+      userConfig = required.default || required;
+    }
+  }
+  const mergedConfig = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    margins: {
+      ...DEFAULT_CONFIG.margins,
+      ...userConfig.margins
+    },
+    header: userConfig.header || DEFAULT_CONFIG.header,
+    footer: userConfig.footer || DEFAULT_CONFIG.footer,
+    metadata: userConfig.metadata
+  };
+  return {
+    config: mergedConfig,
+    configPath: resolvedPath
+  };
+}
+
+// src/core/engine.ts
+function formatServerTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absOffsetHours = pad(Math.floor(Math.abs(offsetMinutes) / 60));
+  const absOffsetMinutes = pad(Math.abs(offsetMinutes) % 60);
+  const tzString = `GMT${sign}${absOffsetHours}:${absOffsetMinutes}`;
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} (${tzString})`;
+}
+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 (fs6.existsSync(inputFilePathOrContent)) {
+    isFilePath = true;
+    rawMarkdown = fs6.readFileSync(inputFilePathOrContent, "utf-8");
+    baseDir = path6.dirname(path6.resolve(inputFilePathOrContent));
+    inputFileName = path6.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 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 = path6.join(outputDir, `${baseName}.docx`);
+        fs6.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 = path6.join(outputDir, `${baseName}.html`);
+        fs6.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 = path6.join(outputDir, `${baseName}.pdf`);
+        fs6.writeFileSync(pdfPath, pdfBuffer);
+        generatedFiles.push({
+          format: "pdf",
+          filePath: pdfPath,
+          fileName: `${baseName}.pdf`,
+          sizeBytes: pdfBuffer.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/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/version.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+var MARKFORGE_VERSION = "0.1.0";
+function getMarkforgeVersion(fromDir = __dirname) {
+  try {
+    let currentDir = fromDir;
+    for (let i = 0; i < 5; i++) {
+      const pkgJsonPath = path7.join(currentDir, "package.json");
+      if (fs7.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkg.name === "@masumdev/markforge" && pkg.version) {
+          return pkg.version;
+        }
+      }
+      const parentDir = path7.dirname(currentDir);
+      if (parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+  } catch {
+  }
+  return MARKFORGE_VERSION;
+}
+export {
+  DEFAULT_CONFIG,
+  MARKFORGE_VERSION,
+  SYNTAX_COLORS,
+  THEMES,
+  THEME_ACADEMIC,
+  THEME_DEFAULT,
+  buildDocxDocument,
+  buildHtmlDocument,
+  buildPdfDocument,
+  compileMarkdown,
+  defineConfig,
+  escapeHtml,
+  findChromeExecutable,
+  formatServerTimestamp,
+  getMarkforgeVersion,
+  getMimeType,
+  highlightCodeToHtml,
+  injectPagedMediaStyles,
+  inlineHtmlImages,
+  loadConfig,
+  compileMarkdown as markforge,
+  parseInlineSpans,
+  parseMarginToTwip,
+  parseMarkdownDocument,
+  renderInlinesToHtml,
+  renderMermaidToPng,
+  resolveImage,
+  slugify,
+  tokenizeCodeLine
+};