markdownfly 0.1.0

package/dist/cli.js

@@ -0,0 +1,2756 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/parser/index.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+
+// src/parser/frontmatter.ts
+import { parse as parseYaml } from "yaml";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  theme: "clean"
+};
+
+// src/utils/progress.ts
+import ora from "ora";
+import chalk from "chalk";
+var quiet = false;
+function setQuiet(value) {
+  quiet = value;
+}
+var ProgressReporter = class {
+  spinner;
+  constructor() {
+    this.spinner = ora();
+  }
+  start(text) {
+    if (quiet) return;
+    this.spinner.start(text);
+  }
+  update(text) {
+    if (quiet) return;
+    this.spinner.text = text;
+  }
+  succeed(text) {
+    if (quiet) return;
+    this.spinner.succeed(text);
+  }
+  fail(text) {
+    if (quiet) return;
+    this.spinner.fail(text);
+  }
+  info(text) {
+    if (quiet) return;
+    this.spinner.info(text);
+  }
+};
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2714"), msg),
+  warn: (msg) => console.error(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2716"), msg)
+};
+
+// src/parser/frontmatter.ts
+function extractFrontmatter(tree) {
+  const yamlNode = tree.children.find((node) => node.type === "yaml");
+  if (!yamlNode) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const parsed = parseYaml(yamlNode.value);
+    const { resource_dir, ...parsedOnly } = parsed;
+    const merged = {
+      ...DEFAULT_CONFIG,
+      ...parsedOnly
+    };
+    if (resource_dir && !merged.resourceDir) {
+      merged.resourceDir = resource_dir;
+    }
+    return merged;
+  } catch {
+    log.warn("Failed to parse frontmatter YAML, using defaults");
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+// src/parser/splitter.ts
+var DIAGRAM_LANGUAGES = /* @__PURE__ */ new Set(["mermaid", "dot", "graphviz", "echarts"]);
+var CALLOUT_VARIANTS = /* @__PURE__ */ new Set([
+  "note",
+  "info",
+  "tip",
+  "success",
+  "warning",
+  "caution",
+  "danger"
+]);
+function extractText(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "softbreak") {
+    return "\n";
+  }
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children.map(extractText).join("");
+  }
+  return "";
+}
+function parseComment(value) {
+  const match = value.match(/<!--\s*mfly:(row|col|dir)\s*(.*?)\s*-->/s);
+  if (!match) return null;
+  if (match[1] === "row" || match[1] === "col") {
+    return { type: "break", direction: match[1] };
+  }
+  if (match[1] === "dir") {
+    const raw = decodeURIComponent(match[2]);
+    return { directives: parseDirectiveString(raw) };
+  }
+  return null;
+}
+function parseDirectiveString(input) {
+  const inner = input.replace(/^@\(/, "").replace(/\)$/, "").trim();
+  const result = {};
+  if (!inner) return result;
+  const re = /([A-Za-z][A-Za-z0-9_-]*)\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^,)]+)/g;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    let value = m[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[m[1]] = value;
+  }
+  return result;
+}
+function toDirectives(raw) {
+  const d = {};
+  if (raw.layout) d.layout = raw.layout;
+  if (raw.notes) d.notes = raw.notes;
+  if (raw.chart) d.chart = raw.chart;
+  if (raw.highlight) d.highlight = raw.highlight;
+  if (raw.background) d.background = raw.background;
+  if (raw.steps) d.steps = raw.steps === "true" || raw.steps === "yes" || raw.steps === "1";
+  return d;
+}
+function parseHighlightRanges(spec) {
+  const lines = /* @__PURE__ */ new Set();
+  for (const part of spec.split(",")) {
+    const range = part.trim().match(/^(\d+)\s*-\s*(\d+)$/);
+    if (range) {
+      const from = Number(range[1]);
+      const to = Number(range[2]);
+      for (let n = Math.min(from, to); n <= Math.max(from, to); n++) lines.add(n);
+    } else {
+      const single = part.trim().match(/^\d+$/);
+      if (single) lines.add(Number(single));
+    }
+  }
+  return [...lines].sort((a, b) => a - b);
+}
+function parseCallout(content) {
+  const lines = content.split("\n");
+  const markerMatch = lines[0]?.match(/^\s*\[!(.*?)\]\s*(.*?)\s*$/);
+  if (!markerMatch) return null;
+  const variant = markerMatch[1].toLowerCase();
+  if (!CALLOUT_VARIANTS.has(variant)) return null;
+  const title = markerMatch[2].trim() || void 0;
+  return {
+    type: "callout",
+    variant,
+    title,
+    content: lines.slice(1).join("\n").trim()
+  };
+}
+function parseImageParams(text) {
+  const result = {};
+  const body = text.replace(/^\{\s*|\s*\}$/g, "");
+  for (const part of body.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim().toLowerCase();
+    const value = part.slice(eq + 1).trim();
+    switch (key) {
+      case "w":
+      case "width": {
+        const normalized = normalizeImageSize(value);
+        if (normalized) result.width = normalized;
+        break;
+      }
+      case "h":
+      case "height": {
+        const normalized = normalizeImageSize(value);
+        if (normalized) result.height = normalized;
+        break;
+      }
+      case "align": {
+        if (value === "left" || value === "center" || value === "right") {
+          result.align = value;
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+function normalizeImageSize(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)(px|pt|cm|mm|in|inch|%)?$/i);
+  if (!match) return void 0;
+  const n = parseFloat(match[1]);
+  if (!(n > 0)) return void 0;
+  const unit = (match[2] || "px").toLowerCase();
+  if (unit === "%") return `${n}%`;
+  const inches = unit === "px" ? n / 96 : unit === "pt" ? n / 72 : unit === "cm" ? n / 2.54 : unit === "mm" ? n / 25.4 : n;
+  return `${Math.round(inches * 100) / 100}in`;
+}
+function nodeToElement(node) {
+  switch (node.type) {
+    case "heading": {
+      return {
+        type: "heading",
+        content: node.children.map(extractText).join(""),
+        level: node.depth
+      };
+    }
+    case "paragraph": {
+      const first = node.children[0];
+      if (first?.type === "image") {
+        const rest = node.children.slice(1);
+        const paramsFromText = (() => {
+          if (rest.length === 0) return {};
+          if (!rest.every((c) => c.type === "text")) return null;
+          const suffix = rest.map((c) => c.type === "text" ? c.value : "").join("").trim();
+          const match = suffix.match(/^\{.*\}$/);
+          return match ? parseImageParams(match[0]) : null;
+        })();
+        if (paramsFromText !== null) {
+          return {
+            type: "image",
+            src: first.url,
+            alt: first.alt ?? void 0,
+            ...paramsFromText
+          };
+        }
+      }
+      return {
+        type: "text",
+        content: node.children.map(extractText).join("")
+      };
+    }
+    case "list": {
+      const hasCheckboxes = node.children.some(
+        (item) => typeof item.checked === "boolean"
+      );
+      const items = node.children.map((item) => {
+        return item.children.map((child) => extractText(child)).join("");
+      });
+      const result = {
+        type: "list",
+        items,
+        ordered: node.ordered ?? false
+      };
+      if (hasCheckboxes) {
+        result.checked = node.children.map(
+          (item) => typeof item.checked === "boolean" ? item.checked : false
+        );
+      }
+      return result;
+    }
+    case "code": {
+      const lang = node.lang?.toLowerCase() ?? "";
+      if (DIAGRAM_LANGUAGES.has(lang)) {
+        return {
+          type: "diagram",
+          diagramType: lang === "graphviz" ? "dot" : lang,
+          content: node.value
+        };
+      }
+      const element = {
+        type: "code",
+        content: node.value,
+        language: node.lang ?? void 0
+      };
+      return element;
+    }
+    case "image": {
+      return {
+        type: "image",
+        src: node.url,
+        alt: node.alt ?? void 0
+      };
+    }
+    case "table": {
+      const rows = node.children.map(
+        (row) => row.children.map(
+          (cell) => cell.children.map(extractText).join("")
+        )
+      );
+      const headers = rows.length > 0 ? rows[0] : [];
+      const bodyRows = rows.slice(1);
+      return {
+        type: "table",
+        headers,
+        rows: bodyRows
+      };
+    }
+    case "blockquote": {
+      const content = node.children.map((child) => extractText(child)).join("\n");
+      const callout = parseCallout(content);
+      if (callout) return callout;
+      return {
+        type: "blockquote",
+        content
+      };
+    }
+    case "html": {
+      const parsed = parseComment(node.value);
+      if (parsed === null) return null;
+      if ("direction" in parsed) return parsed;
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function detectLayout(title, elements, isFirstSlide, headingLevel) {
+  if (isFirstSlide && headingLevel === 1) {
+    return "title";
+  }
+  if (headingLevel === 2 && elements.length === 0) {
+    return "section";
+  }
+  const nonEmptyElements = elements.filter(
+    (e) => e.type !== "text" || e.content.trim() !== ""
+  );
+  if (nonEmptyElements.length > 0 && nonEmptyElements.every((e) => e.type === "code")) {
+    return "code";
+  }
+  if (nonEmptyElements.length > 0 && nonEmptyElements.every((e) => e.type === "blockquote")) {
+    return "quote";
+  }
+  return "content";
+}
+function splitIntoSlides(tree, defaultLayout) {
+  const slides = [];
+  let currentTitle;
+  let currentSubtitle;
+  let currentElements = [];
+  let currentDirectives = {};
+  let currentHeadingLevel = 0;
+  let isFirstSlide = true;
+  function flushSlide() {
+    if (!currentTitle && currentElements.length === 0 && Object.keys(currentDirectives).length === 0) {
+      return;
+    }
+    if (currentDirectives.highlight && currentElements.length > 0) {
+      const ranges = parseHighlightRanges(currentDirectives.highlight);
+      if (ranges.length > 0) {
+        const code = currentElements.find(
+          (e) => e.type === "code" && !e.highlightLines
+        );
+        if (code) code.highlightLines = ranges;
+      }
+    }
+    const autoLayout = detectLayout(
+      currentTitle,
+      currentElements,
+      isFirstSlide && slides.length === 0,
+      currentHeadingLevel
+    );
+    const layout = currentDirectives.layout ?? (autoLayout === "content" ? defaultLayout : autoLayout) ?? "content";
+    slides.push({
+      layout,
+      title: currentTitle,
+      subtitle: currentSubtitle,
+      elements: currentElements,
+      notes: currentDirectives.notes,
+      directives: toDirectives(currentDirectives)
+    });
+    currentTitle = void 0;
+    currentSubtitle = void 0;
+    currentElements = [];
+    currentDirectives = {};
+    currentHeadingLevel = 0;
+    isFirstSlide = false;
+  }
+  for (const node of tree.children) {
+    if (node.type === "yaml") continue;
+    if (node.type === "thematicBreak") {
+      flushSlide();
+      continue;
+    }
+    if (node.type === "heading" && (node.depth === 1 || node.depth === 2)) {
+      flushSlide();
+      currentTitle = node.children.map(extractText).join("");
+      currentHeadingLevel = node.depth;
+      continue;
+    }
+    if (node.type === "html") {
+      const parsed = parseComment(node.value);
+      if (parsed !== null) {
+        if ("direction" in parsed) {
+          currentElements.push(parsed);
+        } else {
+          Object.assign(currentDirectives, parsed.directives);
+        }
+      }
+      continue;
+    }
+    const element = nodeToElement(node);
+    if (element) {
+      currentElements.push(element);
+    }
+  }
+  flushSlide();
+  return slides;
+}
+
+// src/parser/preprocess.ts
+var ROW_RE = /^={3,}$/;
+var COL_RE = /^<->$/;
+var DIR_RE = /^@\(.+\)$/;
+var COMMENT_RE = /^%%/;
+function preprocessMarkdown(markdown) {
+  const lines = markdown.split("\n");
+  const out = [];
+  let inFence = false;
+  let fenceChar = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const fenceMatch = trimmed.match(/^(`{3,}|~{3,})/);
+    if (!inFence) {
+      if (fenceMatch) {
+        inFence = true;
+        fenceChar = fenceMatch[1][0];
+        out.push(line);
+        continue;
+      }
+      if (COMMENT_RE.test(trimmed)) {
+        out.push("");
+        continue;
+      }
+      if (COL_RE.test(trimmed)) {
+        out.push("<!-- mfly:col -->");
+        continue;
+      }
+      if (ROW_RE.test(trimmed)) {
+        out.push("<!-- mfly:row -->");
+        continue;
+      }
+      if (DIR_RE.test(trimmed)) {
+        out.push(`<!-- mfly:dir:${encodeURIComponent(trimmed)} -->`);
+        continue;
+      }
+      out.push(line);
+      continue;
+    }
+    out.push(line);
+    if (fenceMatch && trimmed.startsWith(fenceChar)) {
+      inFence = false;
+    }
+  }
+  return out.join("\n");
+}
+
+// src/parser/index.ts
+function parseMarkdown(markdown) {
+  const processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm);
+  const tree = processor.parse(preprocessMarkdown(markdown));
+  const config = extractFrontmatter(tree);
+  const slides = splitIntoSlides(tree, config.layout);
+  return { config, slides };
+}
+
+// src/renderer/pptx-renderer.ts
+import PptxGenJS from "pptxgenjs";
+
+// src/renderer/layouts/title.ts
+function renderTitleSlide(slide, node, theme) {
+  const textColor = theme.colors.titleText ?? "FFFFFF";
+  const subtitleColor = textColor === "FFFFFF" ? "FFFFFFCC" : theme.colors.secondary;
+  const metaColor = textColor === "FFFFFF" ? "FFFFFF99" : theme.colors.secondary;
+  const bgColor = theme.colors.backgroundGradient ? void 0 : theme.colors.titleBackground ?? theme.colors.primary;
+  if (bgColor) {
+    slide.background = { color: bgColor };
+  }
+  if (node.title) {
+    slide.addText(node.title, {
+      x: 0.8,
+      y: 2,
+      w: 11.7,
+      h: 1.5,
+      fontSize: theme.fontSize.title,
+      fontFace: theme.fonts.heading,
+      color: textColor,
+      bold: true,
+      align: "center",
+      valign: "middle"
+    });
+  }
+  if (node.subtitle) {
+    slide.addText(node.subtitle, {
+      x: 0.8,
+      y: 3.8,
+      w: 11.7,
+      h: 0.8,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: subtitleColor,
+      align: "center",
+      valign: "middle"
+    });
+  }
+  const textElements = node.elements.filter((e) => e.type === "text");
+  if (textElements.length > 0) {
+    const metaText = textElements.map((e) => e.content).join(" \xB7 ");
+    slide.addText(metaText, {
+      x: 0.8,
+      y: 5.5,
+      w: 11.7,
+      h: 0.6,
+      fontSize: theme.fontSize.small,
+      fontFace: theme.fonts.body,
+      color: metaColor,
+      align: "center"
+    });
+  }
+}
+
+// src/renderer/layouts/section.ts
+function renderSectionSlide(slide, node, theme) {
+  slide.addShape("rect", {
+    x: 0,
+    y: 0,
+    w: 0.15,
+    h: 7.5,
+    fill: { color: theme.colors.accent }
+  });
+  if (node.title) {
+    slide.addText(node.title, {
+      x: 1,
+      y: 2.5,
+      w: 11.3,
+      h: 2,
+      fontSize: theme.fontSize.heading + 4,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.text,
+      bold: true,
+      align: "left",
+      valign: "middle"
+    });
+  }
+}
+
+// src/utils/png-size.ts
+function getPngSize(data) {
+  if (data.length < 24) return null;
+  if (data.readUInt32BE(0) !== 2303741511) return null;
+  const width = data.readUInt32BE(16);
+  const height = data.readUInt32BE(20);
+  if (!(width > 0 && height > 0)) return null;
+  return { width, height };
+}
+
+// src/utils/image-fit.ts
+function fitInBox(img, maxWidth, maxHeight) {
+  if (!(img.width > 0 && img.height > 0) || !(maxWidth > 0 && maxHeight > 0)) {
+    return { width: maxWidth, height: maxHeight };
+  }
+  const ar = img.height / img.width;
+  let width = maxWidth;
+  let height = width * ar;
+  if (height > maxHeight) {
+    height = maxHeight;
+    width = height / ar;
+  }
+  return { width, height };
+}
+function resolveImageSize(value, of) {
+  if (!value) return void 0;
+  if (value.endsWith("%")) {
+    const pct = parseFloat(value);
+    if (Number.isNaN(pct) || pct <= 0) return void 0;
+    return of * pct / 100;
+  }
+  const n = parseFloat(value);
+  if (Number.isNaN(n) || n <= 0) return void 0;
+  return n;
+}
+function resolveSizes(img, box, widthStr, heightStr) {
+  const width = resolveImageSize(widthStr, box.width);
+  const height = resolveImageSize(heightStr, box.height);
+  const ar = img.height > 0 && img.width > 0 ? img.height / img.width : 0.5;
+  if (width === void 0 && height === void 0) {
+    return fitInBox(
+      { width: img.width > 0 ? img.width : 6, height: img.height > 0 ? img.height : 3 },
+      box.width,
+      box.height
+    );
+  }
+  if (height === void 0) {
+    return { width, height: width * ar };
+  }
+  if (width === void 0) {
+    return { width: height / ar, height };
+  }
+  return { width, height };
+}
+function fitImageWithOptions(img, box, options = {}) {
+  let { width, height } = resolveSizes(img, box, options.width, options.height);
+  if (width > box.width || height > box.height) {
+    const fitted = fitInBox({ width, height }, box.width, box.height);
+    width = fitted.width;
+    height = fitted.height;
+  }
+  const align = options.align ?? "center";
+  const x = align === "left" ? 0 : align === "right" ? box.width - width : (box.width - width) / 2;
+  return { x, width, height };
+}
+
+// src/utils/table-chart.ts
+function tableToChartOption(table, type) {
+  const { headers, rows } = table;
+  if (headers.length < 2 || rows.length === 0) {
+    throw new Error("chart: table needs at least 2 columns and 1 data row");
+  }
+  if (type === "pie") {
+    const series2 = {
+      name: headers[1],
+      type: "pie",
+      radius: "55%",
+      data: rows.map((r) => ({ name: r[0], value: Number(r[1]) || 0 }))
+    };
+    return JSON.stringify({
+      toolbox: { show: false },
+      series: [series2]
+    });
+  }
+  const categories = rows.map((r) => r[0]);
+  const series = headers.slice(1).map((name, i) => ({
+    name,
+    type,
+    data: rows.map((r) => Number(r[i + 1]) || 0)
+  }));
+  return JSON.stringify({
+    xAxis: { type: "category", data: categories, axisLabel: { hideOverlap: true } },
+    yAxis: { type: "value" },
+    series
+  });
+}
+
+// src/renderer/layouts/content.ts
+import { readFileSync } from "fs";
+var SLIDE_W = 13.33;
+var SLIDE_H = 7.5;
+var MARGIN = 0.6;
+var CONTENT_W = SLIDE_W - MARGIN * 2;
+var TITLE_H = 0.9;
+var BOTTOM_MARGIN = 0.45;
+var GRID_GAP = 0.25;
+var IMAGE_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  svg: "image/svg+xml"
+};
+function contentAreaInsets(node) {
+  return {
+    top: node.title ? 0.3 + TITLE_H + 0.2 : 0.3,
+    bottom: BOTTOM_MARGIN
+  };
+}
+function splitGrid(elements) {
+  const rows = [];
+  let currentRow = [];
+  for (const el of elements) {
+    if (el.type === "break" && el.direction === "row") {
+      rows.push(currentRow);
+      currentRow = [];
+      continue;
+    }
+    currentRow.push(el);
+  }
+  rows.push(currentRow);
+  return rows.map((row) => {
+    const columns = [];
+    let currentCol = [];
+    for (const el of row) {
+      if (el.type === "break" && el.direction === "col") {
+        columns.push(currentCol);
+        currentCol = [];
+        continue;
+      }
+      currentCol.push(el);
+    }
+    columns.push(currentCol);
+    return columns;
+  });
+}
+async function renderContentSlide(slide, node, theme, ctx) {
+  const { top } = contentAreaInsets(node);
+  if (node.title) {
+    slide.addShape("rect", {
+      x: MARGIN,
+      y: 0.3 + TITLE_H - 0.05,
+      w: CONTENT_W,
+      h: 0.04,
+      fill: { color: theme.colors.primary }
+    });
+    slide.addText(node.title, {
+      x: MARGIN,
+      y: 0.3,
+      w: CONTENT_W,
+      h: TITLE_H,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true,
+      valign: "bottom"
+    });
+  }
+  const grid = splitGrid(prepareElements(node));
+  const rows = grid.length;
+  const availH = SLIDE_H - top - BOTTOM_MARGIN - GRID_GAP * (rows - 1);
+  const ests = grid.map(
+    (columns) => Math.max(
+      0.8,
+      ...columns.map((c) => estimateColumnHeight(c, (CONTENT_W - GRID_GAP * (columns.length - 1)) / columns.length))
+    )
+  );
+  const totalEst = ests.reduce((a, b) => a + b, 0);
+  const scale = totalEst > availH ? availH / totalEst : 1;
+  let y = top;
+  for (let r = 0; r < rows; r++) {
+    const columns = grid[r];
+    const cols = columns.length;
+    const colW = (CONTENT_W - GRID_GAP * (cols - 1)) / cols;
+    const rowH = ests[r] * scale;
+    for (let c = 0; c < cols; c++) {
+      await renderColumn(
+        slide,
+        columns[c],
+        { x: MARGIN + c * (colW + GRID_GAP), y, w: colW, h: rowH },
+        node,
+        theme,
+        ctx
+      );
+    }
+    y += rowH + GRID_GAP;
+  }
+}
+function prepareElements(node) {
+  const chart = node.directives?.chart;
+  if (!chart) return node.elements;
+  const elements = [...node.elements];
+  const idx = elements.findIndex((e) => e.type === "table");
+  if (idx === -1) return elements;
+  const table = elements[idx];
+  try {
+    elements[idx] = {
+      type: "diagram",
+      diagramType: "echarts",
+      content: tableToChartOption(table, chart)
+    };
+  } catch {
+  }
+  return elements;
+}
+function estimateTextLines(content, w) {
+  const charsPerLine = Math.max(20, Math.floor(w * 60));
+  return Math.max(1, Math.ceil(content.length / charsPerLine));
+}
+function estimateColumnHeight(elements, w) {
+  let h = 0;
+  for (const el of elements) {
+    switch (el.type) {
+      case "text":
+        h += Math.max(0.5, Math.ceil(el.content.length / Math.max(20, Math.floor(w * 60))) * 0.35);
+        break;
+      case "heading":
+        h += 0.7;
+        break;
+      case "list":
+        h += el.items.length * 0.5;
+        break;
+      case "code":
+        h += Math.max(1, el.content.split("\n").length * 0.25);
+        break;
+      case "diagram":
+      case "image":
+        if (el.type === "image" && el.height && !el.height.endsWith("%")) {
+          h += parseFloat(el.height) + 0.2;
+        } else if (el.type === "image" && el.width && !el.width.endsWith("%")) {
+          h += parseFloat(el.width) * 0.5 + 0.2;
+        } else {
+          h += Math.min(4.5, Math.max(1.2, w * 0.5));
+        }
+        break;
+      case "table":
+        h += (el.rows.length + 1) * 0.4;
+        break;
+      case "callout":
+        h += Math.min(4.5, 0.72 + estimateTextLines(el.content, w) * 0.3);
+        break;
+      case "blockquote":
+        h += 1;
+        break;
+      case "break":
+        break;
+      default:
+        h += 0.5;
+    }
+  }
+  return h;
+}
+async function renderColumn(slide, elements, box, node, theme, ctx) {
+  const est = estimateColumnHeight(elements, box.w);
+  const yPos = box.h > est ? box.y + (box.h - est) / 2 : box.y;
+  let cursor = yPos;
+  for (const element of elements) {
+    const consumed = await renderElement(slide, element, cursor, box, node, theme, ctx);
+    cursor += consumed;
+  }
+}
+async function renderElement(slide, element, yPos, box, node, theme, ctx) {
+  const { x, w } = box;
+  const maxH = Math.max(0.5, box.y + box.h - yPos);
+  switch (element.type) {
+    case "text": {
+      if (!element.content.trim()) return 0;
+      slide.addText(element.content, {
+        x,
+        y: yPos,
+        w,
+        h: 0.6,
+        fontSize: theme.fontSize.body,
+        fontFace: theme.fonts.body,
+        color: theme.colors.text,
+        bold: element.bold,
+        italic: element.italic,
+        valign: "top",
+        wrap: true
+      });
+      const charsPerLine = Math.max(20, Math.floor(w * 60));
+      const lines = Math.ceil(element.content.length / charsPerLine);
+      return Math.max(0.5, lines * 0.35);
+    }
+    case "heading": {
+      slide.addText(element.content, {
+        x,
+        y: yPos,
+        w,
+        h: 0.6,
+        fontSize: theme.fontSize.heading - (element.level - 2) * 4,
+        fontFace: theme.fonts.heading,
+        color: theme.colors.primary,
+        bold: true
+      });
+      return 0.7;
+    }
+    case "list": {
+      const items = element.items.map((item, i) => {
+        const checked = element.checked?.[i];
+        const isTask = checked !== void 0;
+        let text = item;
+        const options = {
+          // Task items have no bullet, so they need an explicit break line;
+          // bulleted items break lines on their own.
+          breakLine: isTask ? true : void 0,
+          bullet: element.ordered ? { type: "number", startAt: i + 1 } : isTask ? false : true,
+          color: theme.colors.text,
+          fontSize: theme.fontSize.body,
+          fontFace: theme.fonts.body,
+          paraSpaceBefore: 4,
+          paraSpaceAfter: 4
+        };
+        if (isTask) {
+          text = `${checked ? "\u2611" : "\u2610"}  ${item}`;
+          if (checked) options.color = theme.colors.secondary;
+        }
+        return { text, options };
+      });
+      const height = Math.max(0.8, Math.min(maxH, items.length * 0.5));
+      slide.addText(items, {
+        x,
+        y: yPos,
+        w,
+        h: height,
+        valign: "top"
+      });
+      return height + 0.15;
+    }
+    case "code": {
+      const runs = await ctx.highlightCode(
+        element.content,
+        element.language ?? "text",
+        element.highlightLines
+      );
+      const lines = element.content.split("\n").length;
+      const height = Math.min(maxH, Math.max(1, lines * 0.25));
+      slide.addText(runs, {
+        x,
+        y: yPos,
+        w,
+        h: height,
+        fill: { color: theme.colors.codeBackground },
+        fontFace: theme.fonts.code,
+        fontSize: theme.fontSize.code,
+        color: theme.colors.codeText,
+        valign: "top",
+        margin: [8, 12, 8, 12]
+      });
+      return height + 0.2;
+    }
+    case "diagram": {
+      try {
+        const pngBuffer = await ctx.renderDiagram(element.diagramType, element.content);
+        const imgSize = getPngSize(pngBuffer) ?? { width: 8, height: 3.5 };
+        const boxH = Math.max(1.2, maxH);
+        const fitted = fitInBox(imgSize, w, boxH);
+        const base64 = pngBuffer.toString("base64");
+        slide.addImage({
+          data: `image/png;base64,${base64}`,
+          x: x + (w - fitted.width) / 2,
+          y: yPos,
+          w: fitted.width,
+          h: fitted.height
+        });
+        return fitted.height + 0.2;
+      } catch (err) {
+        slide.addText(`[Diagram render error: ${err instanceof Error ? err.message : "unknown"}]`, {
+          x,
+          y: yPos,
+          w,
+          h: 0.5,
+          fontSize: theme.fontSize.small,
+          color: "FF0000",
+          italic: true
+        });
+        return 0.6;
+      }
+    }
+    case "image": {
+      try {
+        const resolved = await ctx.resolveImage(element.src);
+        if (!resolved.ok) {
+          log.warn(`[${node.title ?? "slide"}] ${resolved.error}`);
+          return 0;
+        }
+        const imgSize = getPngSize(readFileSync(resolved.path)) ?? { width: 6, height: 3 };
+        const boxH = Math.max(1.2, maxH);
+        const placed = fitImageWithOptions(
+          imgSize,
+          { width: w, height: boxH },
+          { width: element.width, height: element.height, align: element.align }
+        );
+        const ext = resolved.path.split(".").pop()?.toLowerCase() ?? "png";
+        const mime = IMAGE_MIME[ext] ?? "image/png";
+        const data = `${mime};base64,${readFileSync(resolved.path).toString("base64")}`;
+        slide.addImage({
+          data,
+          path: "preencoded.png",
+          x: x + placed.x,
+          y: yPos,
+          w: placed.width,
+          h: placed.height
+        });
+        return placed.height + 0.2;
+      } catch (err) {
+        log.warn(
+          `Failed to embed image ${element.src}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      return 0;
+    }
+    case "table": {
+      const headerRow = element.headers.map((h) => ({
+        text: h,
+        options: {
+          bold: true,
+          color: "FFFFFF",
+          fill: { color: theme.colors.primary },
+          fontSize: theme.fontSize.body - 2,
+          fontFace: theme.fonts.body,
+          align: "center",
+          border: { type: "solid", pt: 0.5, color: theme.colors.primary }
+        }
+      }));
+      const bodyRows = element.rows.map(
+        (row) => row.map((cell) => ({
+          text: cell,
+          options: {
+            fontSize: theme.fontSize.body - 2,
+            fontFace: theme.fonts.body,
+            color: theme.colors.text,
+            border: { type: "solid", pt: 0.5, color: "D1D5DB" }
+          }
+        }))
+      );
+      const allRows = [headerRow, ...bodyRows];
+      const tableH = Math.min(maxH, allRows.length * 0.4);
+      slide.addTable(allRows, {
+        x,
+        y: yPos,
+        w,
+        h: tableH,
+        colW: Array(element.headers.length).fill(w / element.headers.length),
+        margin: [4, 6, 4, 6],
+        border: { type: "solid", pt: 0.5, color: "D1D5DB" },
+        autoPage: false
+      });
+      return tableH + 0.2;
+    }
+    case "blockquote": {
+      slide.addShape("rect", {
+        x,
+        y: yPos,
+        w: 0.06,
+        h: Math.min(0.8, maxH),
+        fill: { color: theme.colors.accent }
+      });
+      slide.addText(element.content, {
+        x: x + 0.2,
+        y: yPos,
+        w: w - 0.2,
+        h: Math.min(0.8, maxH),
+        fontSize: theme.fontSize.body,
+        fontFace: theme.fonts.body,
+        color: theme.colors.secondary,
+        italic: true,
+        valign: "middle"
+      });
+      return 1;
+    }
+    case "callout": {
+      const palette = {
+        note: theme.colors.primary,
+        info: theme.colors.primary,
+        tip: theme.colors.accent,
+        success: theme.colors.accent,
+        warning: "EAB308",
+        caution: "EAB308",
+        danger: "DC2626"
+      };
+      const color = palette[element.variant] ?? theme.colors.primary;
+      const label = element.title ?? element.variant.toUpperCase();
+      const textLines = estimateTextLines(element.content, w);
+      const cardH = Math.min(maxH, 0.72 + textLines * 0.3);
+      const textH = cardH - 0.44;
+      slide.addShape("roundRect", {
+        x,
+        y: yPos,
+        w,
+        h: cardH,
+        fill: { color, transparency: 88 },
+        line: { color, width: 0.75, transparency: 70 },
+        rectRadius: 0.08
+      });
+      slide.addShape("rect", {
+        x,
+        y: yPos + 0.12,
+        w: 0.07,
+        h: cardH - 0.24,
+        fill: { color }
+      });
+      slide.addText(label, {
+        x: x + 0.2,
+        y: yPos + 0.08,
+        w: w - 0.4,
+        h: 0.3,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.heading,
+        color,
+        bold: true
+      });
+      slide.addText(element.content, {
+        x: x + 0.2,
+        y: yPos + 0.4,
+        w: w - 0.4,
+        h: textH,
+        fontSize: theme.fontSize.body - 1,
+        fontFace: theme.fonts.body,
+        color: theme.colors.text,
+        valign: "top",
+        wrap: true
+      });
+      return cardH + 0.1;
+    }
+    default:
+      return 0;
+  }
+}
+
+// src/renderer/layouts/code.ts
+async function renderCodeSlide(slide, node, theme, ctx) {
+  let yPos = 0.3;
+  if (node.title) {
+    slide.addText(node.title, {
+      x: 0.5,
+      y: yPos,
+      w: 12.3,
+      h: 0.7,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true
+    });
+    yPos += 0.9;
+  }
+  for (const element of node.elements) {
+    if (element.type === "code") {
+      const runs = await ctx.highlightCode(
+        element.content,
+        element.language ?? "text",
+        element.highlightLines
+      );
+      slide.addText(runs, {
+        x: 0.5,
+        y: yPos,
+        w: 12.3,
+        h: 7.5 - yPos - 0.5,
+        fill: { color: theme.colors.codeBackground },
+        color: theme.colors.codeText,
+        fontFace: theme.fonts.code,
+        fontSize: theme.fontSize.code,
+        valign: "top",
+        paraSpaceAfter: 2,
+        margin: [10, 15, 10, 15]
+      });
+      yPos += 5;
+    }
+  }
+}
+
+// src/renderer/layouts/quote.ts
+function renderQuoteSlide(slide, node, theme) {
+  slide.addText("\u201C", {
+    x: 1.5,
+    y: 1,
+    w: 2,
+    h: 1.5,
+    fontSize: 72,
+    fontFace: "Georgia",
+    color: theme.colors.accent,
+    bold: true
+  });
+  const quoteElement = node.elements.find((e) => e.type === "blockquote");
+  if (quoteElement && quoteElement.type === "blockquote") {
+    let quoteText = quoteElement.content;
+    let attribution = "";
+    const attrMatch = quoteText.match(/\n?\s*[—\u2014-]\s*(.+)$/);
+    if (attrMatch) {
+      attribution = attrMatch[1].trim();
+      quoteText = quoteText.slice(0, attrMatch.index).trim();
+    }
+    slide.addText(quoteText, {
+      x: 1.8,
+      y: 2.5,
+      w: 9.7,
+      h: 2.5,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.body,
+      color: theme.colors.text,
+      italic: true,
+      align: "center",
+      valign: "middle"
+    });
+    if (attribution) {
+      slide.addText(`\u2014 ${attribution}`, {
+        x: 1.8,
+        y: 5.2,
+        w: 9.7,
+        h: 0.6,
+        fontSize: theme.fontSize.body,
+        fontFace: theme.fonts.body,
+        color: theme.colors.secondary,
+        align: "right"
+      });
+    }
+  }
+}
+
+// src/renderer/layouts/index.ts
+async function renderSlideLayout(slide, node, theme, ctx) {
+  if (node.directives?.background) {
+    const resolved = await ctx.resolveImage(node.directives.background);
+    if (resolved.ok && resolved.path) {
+      slide.background = { path: resolved.path };
+    } else if (node.directives.background.startsWith("#")) {
+      slide.background = { color: node.directives.background.replace(/^#/, "") };
+    } else if (!resolved.ok) {
+      log.warn(`[${node.title ?? "slide"}] ${resolved.error}`);
+    }
+  }
+  switch (node.layout) {
+    case "title":
+      renderTitleSlide(slide, node, theme);
+      break;
+    case "section":
+      renderSectionSlide(slide, node, theme);
+      break;
+    case "code":
+      await renderCodeSlide(slide, node, theme, ctx);
+      break;
+    case "quote":
+      renderQuoteSlide(slide, node, theme);
+      break;
+    case "content":
+    default:
+      await renderContentSlide(slide, node, theme, ctx);
+      break;
+  }
+  if (node.notes) {
+    slide.addNotes(node.notes);
+  }
+  if (node.layout !== "title" && node.layout !== "closing" && node.layout !== "blank") {
+    const footerText = renderFooter(node, theme, ctx);
+    if (footerText) {
+      slide.addText(footerText, {
+        x: 0.6,
+        y: 7.16,
+        w: 12.13,
+        h: 0.28,
+        fontSize: theme.fontSize.small - 1,
+        fontFace: theme.fonts.body,
+        color: theme.colors.secondary,
+        align: "right",
+        valign: "middle"
+      });
+    }
+  }
+}
+function renderFooter(node, theme, ctx) {
+  const template = ctx.footerTemplate;
+  if (!template) return "";
+  return template.replace("{page}", String(ctx.pageNumber)).replace("{total}", String(ctx.totalSlides)).replace("{section}", ctx.currentSection || "").replace("{title}", node.title ?? "");
+}
+
+// src/renderer/code-highlighter.ts
+import { createHighlighter } from "shiki";
+var highlighterInstance = null;
+async function getHighlighter() {
+  if (!highlighterInstance) {
+    highlighterInstance = await createHighlighter({
+      themes: ["github-dark", "dracula"],
+      langs: [
+        "javascript",
+        "typescript",
+        "python",
+        "java",
+        "c",
+        "cpp",
+        "csharp",
+        "go",
+        "rust",
+        "ruby",
+        "php",
+        "swift",
+        "kotlin",
+        "bash",
+        "shell",
+        "sql",
+        "html",
+        "css",
+        "json",
+        "yaml",
+        "markdown",
+        "xml",
+        "docker"
+      ]
+    });
+  }
+  return highlighterInstance;
+}
+function cleanColor(color) {
+  if (!color) return "E2E8F0";
+  return color.replace(/^#/, "");
+}
+async function highlightCode(code, language, theme, highlightLines = []) {
+  const highlighter = await getHighlighter();
+  const runs = [];
+  const shikiThemeName = theme.shikiTheme ?? "github-dark";
+  const highlightColor = theme.colors.highlightBackground ?? "FFF3C4";
+  try {
+    const loadedLangs = highlighter.getLoadedLanguages();
+    if (!loadedLangs.includes(language)) {
+      try {
+        await highlighter.loadLanguage(language);
+      } catch {
+        return [
+          {
+            text: code,
+            options: {
+              color: theme.colors.codeText,
+              fontFace: theme.fonts.code,
+              fontSize: theme.fontSize.code
+            }
+          }
+        ];
+      }
+    }
+    const loadedThemes = highlighter.getLoadedThemes();
+    if (!loadedThemes.includes(shikiThemeName)) {
+      try {
+        await highlighter.loadTheme(shikiThemeName);
+      } catch {
+      }
+    }
+    const effectiveTheme = highlighter.getLoadedThemes().includes(shikiThemeName) ? shikiThemeName : "github-dark";
+    const result = highlighter.codeToTokens(code, {
+      lang: language,
+      theme: effectiveTheme
+    });
+    for (let i = 0; i < result.tokens.length; i++) {
+      const lineNumber = i + 1;
+      const line = result.tokens[i];
+      const isHighlighted = highlightLines.includes(lineNumber);
+      for (const token of line) {
+        const options = {
+          color: cleanColor(token.color),
+          fontFace: theme.fonts.code,
+          fontSize: theme.fontSize.code
+        };
+        if (isHighlighted) {
+          options.highlight = highlightColor;
+        }
+        runs.push({ text: token.content, options });
+      }
+      if (i < result.tokens.length - 1) {
+        runs.push({
+          text: "\n",
+          options: {
+            fontFace: theme.fonts.code,
+            fontSize: theme.fontSize.code
+          }
+        });
+      }
+    }
+  } catch {
+    runs.push({
+      text: code,
+      options: {
+        color: theme.colors.codeText,
+        fontFace: theme.fonts.code,
+        fontSize: theme.fontSize.code
+      }
+    });
+  }
+  return runs;
+}
+
+// src/renderer/image-handler.ts
+import { existsSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var REMOTE_FETCH_TIMEOUT_MS = 1e4;
+async function resolveImage(src, basePath) {
+  try {
+    if (src.startsWith("data:")) {
+      const match = src.match(/^data:image\/(\w+);base64,(.+)/);
+      if (match) {
+        const ext = match[1];
+        const base64 = match[2];
+        const tmpPath = join(tmpdir(), `mfly-${randomUUID().slice(0, 8)}.${ext}`);
+        writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+        return { ok: true, path: tmpPath };
+      }
+      return { ok: false, error: `Unsupported data URI: ${src.slice(0, 48)}` };
+    }
+    if (src.startsWith("http://") || src.startsWith("https://")) {
+      let response;
+      try {
+        response = await fetch(src, { signal: AbortSignal.timeout(REMOTE_FETCH_TIMEOUT_MS) });
+      } catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        const reason = name === "TimeoutError" || name === "AbortError" ? `request timed out after ${REMOTE_FETCH_TIMEOUT_MS / 1e3}s` : err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `Failed to fetch ${src}: ${reason}` };
+      }
+      if (!response.ok) {
+        return { ok: false, error: `Failed to fetch ${src}: HTTP ${response.status}` };
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      const ext = src.split(".").pop()?.split("?")[0] ?? "png";
+      const tmpPath = join(tmpdir(), `mfly-${randomUUID().slice(0, 8)}.${ext}`);
+      writeFileSync(tmpPath, buffer);
+      return { ok: true, path: tmpPath };
+    }
+    const absolutePath = resolve(basePath, src);
+    if (existsSync(absolutePath)) {
+      return { ok: true, path: absolutePath };
+    }
+    return { ok: false, error: `Image not found: ${src} (resolved to ${absolutePath})` };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/diagrams/svg-to-png.ts
+function normalizeSvg(svg) {
+  let clean = svg.trim();
+  if (!clean.includes("xmlns=")) {
+    clean = clean.replace(/<svg\b([^>]*)>/i, '<svg xmlns="http://www.w3.org/2000/svg" $1>');
+  }
+  clean = clean.replace(/(<svg\b[^>]*)\s+width=["'][^"']*["']/gi, "$1");
+  clean = clean.replace(/(<svg\b[^>]*)\s+height=["'][^"']*["']/gi, "$1");
+  clean = clean.replace(/<marker\b[\s\S]*?<\/marker>/gi, "");
+  clean = clean.replace(/\s+marker-(end|start|mid)=["'][^"']*["']/gi, "");
+  const viewBoxMatch = clean.match(/viewBox\s*=\s*["']([^"']+)["']/i);
+  if (viewBoxMatch) {
+    const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
+      const w = parts[2];
+      const h = parts[3];
+      clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="${w}" height="${h}" $1>`);
+    }
+  } else {
+    clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="800" height="600" viewBox="0 0 800 600" $1>`);
+  }
+  return clean;
+}
+async function svgToPng(svg, width = 800) {
+  const normalized = normalizeSvg(svg);
+  const { Resvg } = await import("@resvg/resvg-js");
+  const resvg = new Resvg(normalized, {
+    fitTo: { mode: "width", value: width }
+  });
+  const pngData = resvg.render();
+  return Buffer.from(pngData.asPng());
+}
+
+// src/diagrams/theme.ts
+function isDarkColor(hex) {
+  const clean = hex.replace(/^#/, "");
+  if (clean.length < 6) return false;
+  const r = parseInt(clean.slice(0, 2), 16);
+  const g = parseInt(clean.slice(2, 4), 16);
+  const b = parseInt(clean.slice(4, 6), 16);
+  if ([r, g, b].some((n) => Number.isNaN(n))) return false;
+  return 0.299 * r + 0.587 * g + 0.114 * b < 128;
+}
+function isDarkTheme(theme) {
+  return theme ? isDarkColor(theme.colors.background) : false;
+}
+function diagramFontFamily(theme) {
+  if (!theme) return '"trebuchet ms", sans-serif';
+  return `"${theme.fonts.cjk}", "${theme.fonts.body}", sans-serif`;
+}
+
+// src/diagrams/mermaid-renderer.ts
+var initialized = false;
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+var SKIP_TAGS = /* @__PURE__ */ new Set([
+  "style",
+  "script",
+  "defs",
+  "clippath",
+  "marker",
+  "filter",
+  "mask",
+  "pattern",
+  "foreignobject"
+]);
+function mul(m1, m2) {
+  return [
+    m1[0] * m2[0] + m1[2] * m2[1],
+    m1[1] * m2[0] + m1[3] * m2[1],
+    m1[0] * m2[2] + m1[2] * m2[3],
+    m1[1] * m2[2] + m1[3] * m2[3],
+    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+  ];
+}
+function parseTransform(attr) {
+  if (!attr) return IDENTITY;
+  let m = IDENTITY;
+  const re = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+  let mt;
+  while (mt = re.exec(attr)) {
+    const name = mt[1];
+    const args = mt[2].trim().split(/[\s,]+/).filter(Boolean).map(Number);
+    if (args.some((n) => !Number.isFinite(n))) continue;
+    let next = null;
+    switch (name) {
+      case "matrix":
+        if (args.length >= 6) next = [args[0], args[1], args[2], args[3], args[4], args[5]];
+        break;
+      case "translate":
+        next = [1, 0, 0, 1, args[0] || 0, args[1] || 0];
+        break;
+      case "scale": {
+        const sx = args[0] || 1;
+        const sy = args.length > 1 ? args[1] || 1 : sx;
+        next = [sx, 0, 0, sy, 0, 0];
+        break;
+      }
+      case "rotate": {
+        const rad = (args[0] || 0) * Math.PI / 180;
+        const cos = Math.cos(rad);
+        const sin = Math.sin(rad);
+        const rot = [cos, sin, -sin, cos, 0, 0];
+        next = args.length >= 3 ? mul(mul([1, 0, 0, 1, args[1], args[2]], rot), [1, 0, 0, 1, -args[1], -args[2]]) : rot;
+        break;
+      }
+      case "skewX":
+        next = [1, 0, Math.tan((args[0] || 0) * Math.PI / 180), 1, 0, 0];
+        break;
+      case "skewY":
+        next = [1, Math.tan((args[0] || 0) * Math.PI / 180), 0, 1, 0, 0];
+        break;
+    }
+    if (next) m = mul(m, next);
+  }
+  return m;
+}
+function expandedBox(m, b) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const pts = [
+    [b.x, b.y],
+    [b.x + b.width, b.y],
+    [b.x, b.y + b.height],
+    [b.x + b.width, b.y + b.height]
+  ];
+  for (const [px, py] of pts) {
+    const x = m[0] * px + m[2] * py + m[4];
+    const y = m[1] * px + m[3] * py + m[5];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function textWidth(el) {
+  let width = 0;
+  const collect = (e) => {
+    for (const child of Array.from(e.childNodes)) {
+      if (child.nodeType === 3) {
+        for (const ch of child.textContent ?? "") {
+          width += (ch.codePointAt(0) ?? 0) > 11904 ? 16 : 9;
+        }
+      } else if (child.nodeType === 1) {
+        collect(child);
+      }
+    }
+  };
+  collect(el);
+  return width;
+}
+function pathBounds(d) {
+  const re = /([a-zA-Z])|(-?\d*\.?\d+(?:e[-+]?\d+)?)/gi;
+  const toks = [];
+  let m;
+  while (m = re.exec(d)) toks.push(m[1] ?? parseFloat(m[2]));
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const add = (x2, y2) => {
+    if (x2 < minX) minX = x2;
+    if (y2 < minY) minY = y2;
+    if (x2 > maxX) maxX = x2;
+    if (y2 > maxY) maxY = y2;
+  };
+  let i = 0;
+  let x = 0;
+  let y = 0;
+  let sx = 0;
+  let sy = 0;
+  let lastCmd = "";
+  let lastRel = false;
+  const nums = (count) => {
+    const out = [];
+    while (count-- > 0) {
+      const t = toks[i++];
+      if (typeof t !== "number") return null;
+      out.push(t);
+    }
+    return out;
+  };
+  while (i < toks.length) {
+    let cmd = toks[i];
+    let rel;
+    if (typeof cmd === "string") {
+      rel = cmd === cmd.toLowerCase();
+      cmd = cmd.toUpperCase();
+      lastCmd = cmd;
+      lastRel = rel;
+      i++;
+    } else {
+      cmd = lastCmd;
+      rel = lastRel;
+    }
+    switch (cmd) {
+      case "M": {
+        const v = nums(2);
+        if (!v) return null;
+        x = rel ? x + v[0] : v[0];
+        y = rel ? y + v[1] : v[1];
+        sx = x;
+        sy = y;
+        add(x, y);
+        lastCmd = "L";
+        lastRel = rel;
+        break;
+      }
+      case "L": {
+        const v = nums(2);
+        if (!v) return null;
+        x = rel ? x + v[0] : v[0];
+        y = rel ? y + v[1] : v[1];
+        add(x, y);
+        break;
+      }
+      case "H": {
+        const v = nums(1);
+        if (!v) return null;
+        x = rel ? x + v[0] : v[0];
+        add(x, y);
+        break;
+      }
+      case "V": {
+        const v = nums(1);
+        if (!v) return null;
+        y = rel ? y + v[0] : v[0];
+        add(x, y);
+        break;
+      }
+      case "C": {
+        const v = nums(6);
+        if (!v) return null;
+        add(rel ? x + v[0] : v[0], rel ? y + v[1] : v[1]);
+        add(rel ? x + v[2] : v[2], rel ? y + v[3] : v[3]);
+        x = rel ? x + v[4] : v[4];
+        y = rel ? y + v[5] : v[5];
+        add(x, y);
+        break;
+      }
+      case "S":
+      case "Q": {
+        const v = nums(4);
+        if (!v) return null;
+        add(rel ? x + v[0] : v[0], rel ? y + v[1] : v[1]);
+        x = rel ? x + v[2] : v[2];
+        y = rel ? y + v[3] : v[3];
+        add(x, y);
+        break;
+      }
+      case "T": {
+        const v = nums(2);
+        if (!v) return null;
+        x = rel ? x + v[0] : v[0];
+        y = rel ? y + v[1] : v[1];
+        add(x, y);
+        break;
+      }
+      case "A": {
+        const v = nums(7);
+        if (!v) return null;
+        x = rel ? x + v[5] : v[5];
+        y = rel ? y + v[6] : v[6];
+        add(x, y);
+        break;
+      }
+      case "Z":
+        x = sx;
+        y = sy;
+        break;
+      default:
+        return null;
+    }
+  }
+  if (!Number.isFinite(minX)) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function elementLocalBox(el) {
+  const tag = el.tagName ? el.tagName.toLowerCase() : "";
+  const num = (name) => {
+    const v = parseFloat(el.getAttribute(name) ?? "");
+    return Number.isFinite(v) ? v : 0;
+  };
+  switch (tag) {
+    case "rect": {
+      const w = num("width");
+      const h = num("height");
+      if (!(w > 0 && h > 0)) return null;
+      return { x: num("x"), y: num("y"), width: w, height: h };
+    }
+    case "circle": {
+      const r = num("r");
+      if (!(r > 0)) return null;
+      return { x: num("cx") - r, y: num("cy") - r, width: 2 * r, height: 2 * r };
+    }
+    case "ellipse": {
+      const rx = num("rx");
+      const ry = num("ry");
+      if (!(rx > 0 && ry > 0)) return null;
+      return { x: num("cx") - rx, y: num("cy") - ry, width: 2 * rx, height: 2 * ry };
+    }
+    case "line": {
+      const x1 = num("x1");
+      const y1 = num("y1");
+      const x2 = num("x2");
+      const y2 = num("y2");
+      return { x: Math.min(x1, x2), y: Math.min(y1, y2), width: Math.abs(x2 - x1), height: Math.abs(y2 - y1) };
+    }
+    case "polygon":
+    case "polyline": {
+      const pts = (el.getAttribute("points") ?? "").split(/[\s,]+/).filter(Boolean).map(Number);
+      if (pts.length < 4 || pts.some((n) => !Number.isFinite(n))) return null;
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (let k = 0; k + 1 < pts.length; k += 2) {
+        const px = pts[k];
+        const py = pts[k + 1];
+        if (px < minX) minX = px;
+        if (py < minY) minY = py;
+        if (px > maxX) maxX = px;
+        if (py > maxY) maxY = py;
+      }
+      return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+    }
+    case "path":
+      return pathBounds(el.getAttribute("d") ?? "");
+    case "text":
+    case "tspan": {
+      const w = textWidth(el);
+      if (w <= 4) return null;
+      return { x: num("x") - w / 2, y: num("y") - 14, width: w, height: 24 };
+    }
+    default:
+      return null;
+  }
+}
+function contentBBox(root) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const accumulate = (b) => {
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    if (b.x + b.width > maxX) maxX = b.x + b.width;
+    if (b.y + b.height > maxY) maxY = b.y + b.height;
+  };
+  const walk = (el, m) => {
+    for (const child of Array.from(el.children)) {
+      const tag = child.tagName ? child.tagName.toLowerCase() : "";
+      if (SKIP_TAGS.has(tag)) continue;
+      const cm = mul(m, parseTransform(child.getAttribute("transform")));
+      const local = elementLocalBox(child);
+      if (local) {
+        const b = expandedBox(cm, local);
+        if (b.width > 0.5 || b.height > 0.5) accumulate(b);
+      }
+      walk(child, cm);
+    }
+  };
+  walk(root, IDENTITY);
+  if (!Number.isFinite(minX)) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+var MermaidDiagramRenderer = class {
+  type = "mermaid";
+  renderCounter = 0;
+  async initialize() {
+    if (initialized) return;
+    const { JSDOM } = await import("jsdom");
+    const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+      pretendToBeVisual: true
+    });
+    const assignGlobal = (key, value) => {
+      try {
+        Object.defineProperty(globalThis, key, {
+          value,
+          configurable: true,
+          writable: true
+        });
+      } catch {
+        globalThis[key] = value;
+      }
+    };
+    assignGlobal("window", dom.window);
+    assignGlobal("document", dom.window.document);
+    assignGlobal("navigator", dom.window.navigator);
+    assignGlobal("DOMParser", dom.window.DOMParser);
+    assignGlobal("XMLSerializer", dom.window.XMLSerializer);
+    assignGlobal("HTMLElement", dom.window.HTMLElement);
+    assignGlobal("SVGElement", dom.window.SVGElement);
+    assignGlobal("Element", dom.window.Element);
+    assignGlobal("Node", dom.window.Node);
+    assignGlobal("Text", dom.window.Text);
+    assignGlobal("getComputedStyle", dom.window.getComputedStyle);
+    assignGlobal("CustomEvent", dom.window.CustomEvent);
+    assignGlobal("Event", dom.window.Event);
+    assignGlobal("EventTarget", dom.window.EventTarget);
+    assignGlobal("HTMLCollection", dom.window.HTMLCollection);
+    assignGlobal("NodeList", dom.window.NodeList);
+    assignGlobal("MutationObserver", dom.window.MutationObserver);
+    if (dom.window.CSSStyleSheet) {
+      assignGlobal("CSSStyleSheet", dom.window.CSSStyleSheet);
+    } else {
+      class MockCSSStyleSheet {
+        cssRules = [];
+        insertRule() {
+          return 0;
+        }
+        deleteRule() {
+        }
+        replaceSync() {
+        }
+        replace() {
+          return Promise.resolve(this);
+        }
+      }
+      assignGlobal("CSSStyleSheet", MockCSSStyleSheet);
+    }
+    const getDirectText = (el) => {
+      const tag = el.tagName ? el.tagName.toLowerCase() : "";
+      if (tag === "style" || tag === "script" || tag === "defs" || tag === "marker") return "";
+      let text = "";
+      for (const child of Array.from(el.childNodes)) {
+        if (child.nodeType === 3) {
+          text += child.textContent || "";
+        } else if (child.nodeType === 1) {
+          const ctag = child.tagName.toLowerCase();
+          if (ctag === "tspan" || ctag === "text" || ctag === "span" || ctag === "div" || ctag === "p") {
+            text += getDirectText(child);
+          }
+        }
+      }
+      return text;
+    };
+    const toRect = (b) => ({
+      x: b.x,
+      y: b.y,
+      width: b.width,
+      height: b.height,
+      top: b.y,
+      right: b.x + b.width,
+      bottom: b.y + b.height,
+      left: b.x,
+      toJSON: () => ({})
+    });
+    const polyfillBBox = function() {
+      const tag = this.tagName ? this.tagName.toLowerCase() : "";
+      if (tag === "style" || tag === "script" || tag === "defs" || tag === "clippath" || tag === "marker") {
+        return toRect({ x: 0, y: 0, width: 0, height: 0 });
+      }
+      if (tag === "svg") {
+        const box = contentBBox(this);
+        if (box) return toRect(box);
+      }
+      const text = getDirectText(this);
+      const width = text ? Math.max(30, text.length * 9 + 20) : 80;
+      const height = text ? 28 : 40;
+      return toRect({ x: 0, y: 0, width, height });
+    };
+    if (!dom.window.SVGElement.prototype.getBBox) {
+      dom.window.SVGElement.prototype.getBBox = polyfillBBox;
+    }
+    if (!dom.window.Element.prototype.getBBox) {
+      dom.window.Element.prototype.getBBox = polyfillBBox;
+    }
+    if (!dom.window.Element.prototype.getBoundingClientRect) {
+      dom.window.Element.prototype.getBoundingClientRect = polyfillBBox;
+    }
+    const computeTextLength = function() {
+      const text = getDirectText(this);
+      return text.length * 9;
+    };
+    dom.window.Element.prototype.getComputedTextLength = computeTextLength;
+    dom.window.SVGElement.prototype.getComputedTextLength = computeTextLength;
+    dom.window.HTMLElement.prototype.getComputedTextLength = computeTextLength;
+    if (dom.window.HTMLCanvasElement) {
+      dom.window.HTMLCanvasElement.prototype.getContext = (() => ({
+        measureText: (text) => ({ width: text.length * 8 }),
+        fillRect: () => {
+        },
+        clearRect: () => {
+        },
+        getImageData: () => ({ data: new Array(4) }),
+        putImageData: () => {
+        },
+        createImageData: () => [],
+        setTransform: () => {
+        },
+        drawImage: () => {
+        },
+        save: () => {
+        },
+        fillText: () => {
+        },
+        restore: () => {
+        },
+        beginPath: () => {
+        },
+        moveTo: () => {
+        },
+        lineTo: () => {
+        },
+        closePath: () => {
+        },
+        stroke: () => {
+        },
+        translate: () => {
+        },
+        scale: () => {
+        },
+        rotate: () => {
+        },
+        arc: () => {
+        },
+        fill: () => {
+        }
+      }));
+    }
+    if (dom.window.SVGSVGElement) {
+      if (!dom.window.SVGSVGElement.prototype.createSVGMatrix) {
+        dom.window.SVGSVGElement.prototype.createSVGMatrix = () => ({
+          a: 1,
+          b: 0,
+          c: 0,
+          d: 1,
+          e: 0,
+          f: 0,
+          multiply: function() {
+            return this;
+          },
+          inverse: function() {
+            return this;
+          },
+          translate: function() {
+            return this;
+          },
+          scale: function() {
+            return this;
+          },
+          rotate: function() {
+            return this;
+          }
+        });
+      }
+      if (!dom.window.SVGSVGElement.prototype.createSVGPoint) {
+        dom.window.SVGSVGElement.prototype.createSVGPoint = () => ({
+          x: 0,
+          y: 0,
+          matrixTransform: function() {
+            return this;
+          }
+        });
+      }
+    }
+    if (!dom.window.matchMedia) {
+      dom.window.matchMedia = () => ({
+        matches: false,
+        media: "",
+        onchange: null,
+        addListener: () => {
+        },
+        removeListener: () => {
+        },
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        },
+        dispatchEvent: () => false
+      });
+    }
+    const mermaid = (await import("mermaid")).default;
+    mermaid.initialize(this.buildConfig());
+    initialized = true;
+  }
+  buildConfig(theme) {
+    return {
+      startOnLoad: false,
+      securityLevel: "loose",
+      // Top-level htmlLabels is required: flowchart-v2 reads it (the
+      // flowchart.htmlLabels key is ignored) and html labels rely on real DOM
+      // layout (scrollWidth) that jsdom does not provide — with them on, nodes
+      // collapse to 60x30 stubs and resvg drops the HTML content entirely.
+      htmlLabels: false,
+      theme: isDarkTheme(theme) ? "dark" : "default",
+      themeVariables: {
+        fontFamily: diagramFontFamily(theme),
+        background: "transparent"
+      },
+      flowchart: { htmlLabels: false, curve: "basis", useMaxWidth: false },
+      sequence: { useMaxWidth: false }
+    };
+  }
+  async render(code, theme) {
+    await this.initialize();
+    const mermaid = (await import("mermaid")).default;
+    const id = `mfly-mermaid-${Date.now()}-${this.renderCounter++}`;
+    mermaid.initialize(this.buildConfig(theme));
+    try {
+      const { svg } = await mermaid.render(id, code.trim());
+      return svgToPng(svg, 1200);
+    } catch (err) {
+      throw new Error(
+        `Mermaid render failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+
+// src/diagrams/graphviz-renderer.ts
+var GraphvizDiagramRenderer = class {
+  type = "dot";
+  viz = null;
+  async initialize() {
+    if (this.viz) return;
+    const vizModule = await import("@viz-js/viz");
+    this.viz = await vizModule.instance();
+  }
+  /**
+   * Dark theme support: prepend default node/edge/graph attributes so nodes,
+   * edges, and labels become light-on-dark. User-specified attrs in the DOT
+   * code still win because they appear after these defaults.
+   */
+  themeDefaults(code, dark) {
+    if (!dark) return code;
+    const prelude = '  graph [fontcolor="#c9d1d9" bgcolor="transparent"];\n  node [color="#8b949e" fontcolor="#c9d1d9"];\n  edge [color="#8b949e" fontcolor="#c9d1d9"];\n';
+    return code.replace(/\{/, `{
+${prelude}`);
+  }
+  async render(code, theme) {
+    await this.initialize();
+    try {
+      const dark = isDarkTheme(theme);
+      const svg = this.viz.renderString(this.themeDefaults(code.trim(), dark), {
+        format: "svg",
+        engine: "dot",
+        graphAttributes: {
+          bgcolor: "transparent"
+        }
+      });
+      return svgToPng(svg, 1200);
+    } catch (err) {
+      throw new Error(
+        `Graphviz render failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+
+// src/diagrams/echarts-renderer.ts
+var EChartsDiagramRenderer = class {
+  type = "echarts";
+  async initialize() {
+  }
+  async render(code, _theme) {
+    const echarts = await import("echarts");
+    let option;
+    try {
+      option = JSON.parse(code.trim());
+    } catch {
+      throw new Error("ECharts: invalid JSON option");
+    }
+    const width = typeof option.width === "number" ? option.width : 800;
+    const height = typeof option.height === "number" ? option.height : 450;
+    delete option.width;
+    delete option.height;
+    const chart = echarts.init(null, null, {
+      renderer: "svg",
+      ssr: true,
+      width,
+      height
+    });
+    try {
+      chart.setOption({
+        ...option,
+        animation: false
+      });
+      const svg = chart.renderToSVGString();
+      return svgToPng(svg, width * 2);
+    } finally {
+      chart.dispose();
+    }
+  }
+};
+
+// src/diagrams/index.ts
+var DIAGRAM_LANGUAGES2 = {
+  mermaid: () => new MermaidDiagramRenderer(),
+  dot: () => new GraphvizDiagramRenderer(),
+  graphviz: () => new GraphvizDiagramRenderer(),
+  echarts: () => new EChartsDiagramRenderer()
+};
+var instances = /* @__PURE__ */ new Map();
+function getOrCreate(language) {
+  const key = language === "graphviz" ? "dot" : language;
+  if (instances.has(key)) return instances.get(key);
+  const factory = DIAGRAM_LANGUAGES2[language];
+  if (!factory) return void 0;
+  const renderer = factory();
+  instances.set(key, renderer);
+  return renderer;
+}
+async function renderDiagram(language, code, theme) {
+  const renderer = getOrCreate(language.toLowerCase());
+  if (!renderer) {
+    throw new Error(`No diagram renderer for language: ${language}`);
+  }
+  await renderer.initialize();
+  return renderer.render(code, theme);
+}
+
+// src/utils/gradient.ts
+import { deflateSync } from "zlib";
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length);
+  const payload = Buffer.concat([Buffer.from(type, "latin1"), Buffer.from(data)]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(payload));
+  return Buffer.concat([length, payload, crc]);
+}
+function encodePngRgb(width, height, pixelAt) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  const raw = Buffer.alloc(height * (1 + width * 3));
+  let offset = 0;
+  for (let y = 0; y < height; y++) {
+    raw[offset++] = 0;
+    for (let x = 0; x < width; x++) {
+      const [r, g, b] = pixelAt(x, y);
+      raw[offset++] = r;
+      raw[offset++] = g;
+      raw[offset++] = b;
+    }
+  }
+  const idat = deflateSync(raw, { level: 9 });
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", new Uint8Array(idat)),
+    pngChunk("IEND", new Uint8Array(0))
+  ]);
+}
+function hexToRgb(hex) {
+  let s = hex.replace(/^#/, "");
+  if (s.length === 3) s = s.split("").map((ch) => ch + ch).join("");
+  if (!/^[0-9a-fA-F]{6}$/.test(s)) throw new Error(`Invalid hex color: ${hex}`);
+  return [
+    parseInt(s.slice(0, 2), 16),
+    parseInt(s.slice(2, 4), 16),
+    parseInt(s.slice(4, 6), 16)
+  ];
+}
+function createLinearGradientPng(from, to, angleDeg = 180, options = {}) {
+  const width = options.width ?? 192;
+  const height = options.height ?? 108;
+  const angle = angleDeg * Math.PI / 180;
+  const dx = Math.sin(angle);
+  const dy = -Math.cos(angle);
+  const extent = (Math.abs(dx) + Math.abs(dy)) / 2;
+  const c1 = hexToRgb(from);
+  const c2 = hexToRgb(to);
+  return encodePngRgb(width, height, (x, y) => {
+    const px = x / (width - 1) - 0.5;
+    const py = y / (height - 1) - 0.5;
+    let t = 0.5 + (px * dx + py * dy) / (2 * extent);
+    t = t < 0 ? 0 : t > 1 ? 1 : t;
+    return [
+      Math.round(c1[0] + (c2[0] - c1[0]) * t),
+      Math.round(c1[1] + (c2[1] - c1[1]) * t),
+      Math.round(c1[2] + (c2[2] - c1[2]) * t)
+    ];
+  });
+}
+
+// src/renderer/background.ts
+var cache = /* @__PURE__ */ new Map();
+function slideBackground(theme) {
+  const gradient = theme.colors.backgroundGradient;
+  if (!gradient) return { color: theme.colors.background };
+  const key = `${gradient.from}|${gradient.to}|${gradient.angle ?? 180}`;
+  let data = cache.get(key);
+  if (!data) {
+    const png = createLinearGradientPng(gradient.from, gradient.to, gradient.angle ?? 180, {
+      width: 192,
+      height: 108
+    });
+    data = `image/png;base64,${png.toString("base64")}`;
+    cache.set(key, data);
+  }
+  return { color: theme.colors.background, data };
+}
+
+// src/renderer/pptx-renderer.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+async function renderPresentation(presentation, theme, outputPath, inputPath = "") {
+  const pptx = new PptxGenJS();
+  pptx.layout = "LAYOUT_WIDE";
+  pptx.author = presentation.config.author ?? "MarkdownFly";
+  pptx.title = presentation.slides[0]?.title ?? "Presentation";
+  const { resourceDir } = presentation.config;
+  const resourceBase = resourceDir ? resolve2(dirname(inputPath), resourceDir) : dirname(inputPath);
+  const backgroundProps = slideBackground(theme);
+  const ctx = {
+    highlightCode: async (code, language, highlightLines = []) => {
+      return highlightCode(code, language, theme, highlightLines);
+    },
+    resolveImage: async (src) => {
+      return resolveImage(src, resourceBase);
+    },
+    renderDiagram: async (diagramType, code) => {
+      return renderDiagram(diagramType, code, theme);
+    },
+    footerTemplate: presentation.config.footer,
+    pageNumber: 0,
+    totalSlides: presentation.slides.length,
+    currentSection: ""
+  };
+  for (let i = 0; i < presentation.slides.length; i++) {
+    const node = presentation.slides[i];
+    const slide = pptx.addSlide();
+    slide.background = backgroundProps;
+    ctx.pageNumber = i + 1;
+    if (node.layout === "section" && node.title) {
+      ctx.currentSection = node.title;
+    }
+    await renderSlideLayout(slide, node, theme, ctx);
+  }
+  const buffer = await pptx.write({ outputType: "nodebuffer" });
+  writeFileSync2(outputPath, Buffer.from(buffer));
+}
+
+// src/themes/clean.ts
+var cleanTheme = {
+  name: "clean",
+  colors: {
+    primary: "2563EB",
+    secondary: "4B5563",
+    background: "FFFFFF",
+    text: "1F2937",
+    accent: "10B981",
+    codeBackground: "1E293B",
+    codeText: "E2E8F0",
+    titleBackground: "2563EB",
+    titleText: "FFFFFF"
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/academic.ts
+var academicTheme = {
+  name: "academic",
+  colors: {
+    primary: "003366",
+    secondary: "4A5568",
+    background: "FFFFFF",
+    text: "111827",
+    accent: "991B1B",
+    codeBackground: "1E293B",
+    codeText: "E2E8F0",
+    titleBackground: "003366",
+    titleText: "FFFFFF"
+  },
+  fonts: {
+    heading: "Times New Roman",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5B8B\u4F53"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/dark.ts
+var darkTheme = {
+  name: "dark",
+  colors: {
+    primary: "38BDF8",
+    secondary: "94A3B8",
+    background: "0F172A",
+    text: "F8FAFC",
+    accent: "A855F7",
+    codeBackground: "020617",
+    codeText: "38BDF8",
+    titleBackground: "0F172A",
+    titleText: "38BDF8",
+    highlightBackground: "334155",
+    backgroundGradient: { from: "0F172A", to: "1E293B", angle: 135 }
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "dracula"
+};
+
+// src/themes/business.ts
+var businessTheme = {
+  name: "business",
+  colors: {
+    primary: "1E3A8A",
+    secondary: "64748B",
+    background: "F8FAFC",
+    text: "0F172A",
+    accent: "D97706",
+    codeBackground: "0F172A",
+    codeText: "E2E8F0",
+    titleBackground: "1E3A8A",
+    titleText: "FFFFFF"
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/warm.ts
+var warmTheme = {
+  name: "warm",
+  colors: {
+    primary: "065F46",
+    secondary: "78716C",
+    background: "FDFBF7",
+    text: "292524",
+    accent: "C2410C",
+    codeBackground: "292524",
+    codeText: "FDFBF7",
+    titleBackground: "065F46",
+    titleText: "292524",
+    backgroundGradient: { from: "FDFBF7", to: "F5EEDF", angle: 180 }
+  },
+  fonts: {
+    heading: "Georgia",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/aurora.ts
+var auroraTheme = {
+  name: "aurora",
+  colors: {
+    primary: "7AA2FF",
+    secondary: "8FA3C9",
+    background: "06091C",
+    text: "E8F0FF",
+    accent: "5EF2C6",
+    codeBackground: "0B1128",
+    codeText: "AECAF5",
+    titleText: "F4F8FF",
+    highlightBackground: "233152",
+    backgroundGradient: { from: "101A3A", to: "05060F", angle: 135 }
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "dracula"
+};
+
+// src/themes/neon.ts
+var neonTheme = {
+  name: "neon",
+  colors: {
+    primary: "00E5FF",
+    secondary: "9AA4B5",
+    background: "121212",
+    text: "FFFFFF",
+    accent: "FF4081",
+    codeBackground: "0C0C0C",
+    codeText: "85E7F7",
+    titleBackground: "121212",
+    titleText: "00E5FF",
+    highlightBackground: "2A2A32"
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "dracula"
+};
+
+// src/themes/nord.ts
+var nordTheme = {
+  name: "nord",
+  colors: {
+    primary: "88C0D0",
+    secondary: "81A1C1",
+    background: "2E3440",
+    text: "D8DEE9",
+    accent: "EBCB8B",
+    codeBackground: "272C36",
+    codeText: "A9BBD3",
+    titleBackground: "2E3440",
+    titleText: "88C0D0",
+    highlightBackground: "3B4252"
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "nord"
+};
+
+// src/themes/dracula.ts
+var draculaTheme = {
+  name: "dracula",
+  colors: {
+    primary: "BD93F9",
+    secondary: "6272A4",
+    background: "282A36",
+    text: "F8F8F2",
+    accent: "FF79C6",
+    codeBackground: "21222C",
+    codeText: "F8F8F2",
+    titleBackground: "282A36",
+    titleText: "BD93F9",
+    highlightBackground: "44475A"
+  },
+  fonts: {
+    heading: "Segoe UI",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "dracula"
+};
+
+// src/themes/beige.ts
+var beigeTheme = {
+  name: "beige",
+  colors: {
+    primary: "8B6F3D",
+    secondary: "6B6455",
+    background: "F7F3DE",
+    text: "2F2A1F",
+    accent: "C0563C",
+    codeBackground: "3A352B",
+    codeText: "E8E0CC",
+    titleBackground: "8B6F3D",
+    titleText: "2F2A1F",
+    highlightBackground: "F0E2B8",
+    backgroundGradient: { from: "F7F3DE", to: "F1E8D2", angle: 180 }
+  },
+  fonts: {
+    heading: "Georgia",
+    body: "Segoe UI",
+    code: "Consolas",
+    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/ink.ts
+var inkTheme = {
+  name: "ink",
+  colors: {
+    primary: "2F3530",
+    secondary: "6F6A5E",
+    background: "F7F4EC",
+    text: "262626",
+    accent: "C0272D",
+    codeBackground: "2B2924",
+    codeText: "D8D2C0",
+    titleBackground: "30352F",
+    titleText: "262626",
+    highlightBackground: "EBDDCD",
+    backgroundGradient: { from: "F7F4EC", to: "EFE8DA", angle: 180 }
+  },
+  fonts: {
+    heading: "KaiTi",
+    body: "KaiTi",
+    code: "Consolas",
+    cjk: "KaiTi"
+  },
+  fontSize: {
+    title: 36,
+    heading: 28,
+    body: 18,
+    code: 14,
+    small: 12
+  },
+  shikiTheme: "github-dark"
+};
+
+// src/themes/default.ts
+var defaultTheme = {
+  ...cleanTheme,
+  name: "default"
+};
+
+// src/themes/index.ts
+var themes = {
+  clean: cleanTheme,
+  academic: academicTheme,
+  dark: darkTheme,
+  business: businessTheme,
+  warm: warmTheme,
+  aurora: auroraTheme,
+  neon: neonTheme,
+  nord: nordTheme,
+  dracula: draculaTheme,
+  beige: beigeTheme,
+  ink: inkTheme,
+  default: defaultTheme
+};
+function getTheme(name) {
+  if (!name) {
+    return cleanTheme;
+  }
+  if (typeof name !== "string") {
+    throw new Error(`Invalid theme value: expected a string, got ${typeof name}`);
+  }
+  const theme = themes[name.toLowerCase()];
+  if (!theme) {
+    console.warn(`Theme "${name}" not found, using "clean"`);
+    return cleanTheme;
+  }
+  return theme;
+}
+
+// src/utils/output-namer.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, extname, dirname as dirname2, join as join2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function getOutputPath(inputPath, specifiedOutput) {
+  if (specifiedOutput) return specifiedOutput;
+  const dir = dirname2(inputPath);
+  const name = basename(inputPath, extname(inputPath));
+  const simple = join2(dir, `${name}.pptx`);
+  if (!existsSync2(simple)) return simple;
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, "0") + String(now.getDate()).padStart(2, "0") + "-" + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0");
+  const withTimestamp = join2(dir, `${name}-${ts}.pptx`);
+  if (!existsSync2(withTimestamp)) return withTimestamp;
+  const uuid = randomUUID2().slice(0, 4);
+  return join2(dir, `${name}-${ts}-${uuid}.pptx`);
+}
+
+// src/index.ts
+async function convert(inputPath, options = {}) {
+  const absInput = resolve3(inputPath);
+  const markdown = readFileSync2(absInput, "utf-8");
+  const presentation = parseMarkdown(markdown);
+  if (options.theme) presentation.config.theme = options.theme;
+  const theme = getTheme(presentation.config.theme);
+  const outputPath = resolve3(getOutputPath(absInput, options.output));
+  await renderPresentation(presentation, theme, outputPath, absInput);
+  return outputPath;
+}
+
+// src/utils/glob.ts
+import fg from "fast-glob";
+async function expandGlob(patterns) {
+  const normalized = patterns.map((p) => p.replace(/\\/g, "/"));
+  const files = await fg(normalized, {
+    absolute: true,
+    onlyFiles: true
+  });
+  return files.filter((f) => f.toLowerCase().endsWith(".md")).sort();
+}
+
+// src/cli.ts
+var pkg = JSON.parse(
+  readFileSync3(new URL("../package.json", import.meta.url), "utf-8")
+);
+var program = new Command();
+program.name("mfly").description("Markdown to PowerPoint (PPTX)").version(pkg.version ?? "0.0.0");
+var themeChoices = Object.keys(themes).filter((name) => name !== "default");
+program.argument("<files...>", "Markdown files to convert (supports glob)").option("-o, --output <path>", "Output file path (single file only)").option("-t, --theme <name>", `Theme name (${themeChoices.join(", ")})`).option("--quiet", "Suppress per-file progress output").option("--json", "Print machine-readable JSON result to stdout").action(async (filePatterns, options) => {
+  const jsonMode = Boolean(options.json);
+  if (jsonMode || options.quiet) setQuiet(true);
+  const usageError = (msg) => {
+    log.error(msg);
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    process.exit(1);
+  };
+  try {
+    const files = await expandGlob(filePatterns);
+    if (files.length === 0) {
+      usageError("No .md files found matching the given pattern(s)");
+    }
+    if (options.output && files.length > 1) {
+      usageError("--output can only be used with a single input file");
+    }
+    if (options.theme && !themes[options.theme.toLowerCase()]) {
+      usageError(`Unknown theme "${options.theme}". Available themes: ${themeChoices.join(", ")}`);
+    }
+    const startTime = Date.now();
+    const results = [];
+    for (const file of files) {
+      const progress = new ProgressReporter();
+      const fileName = file.split(/[\\/]/).pop() ?? file;
+      progress.start(`Converting ${chalk2.cyan(fileName)}...`);
+      try {
+        const outputPath = await convert(file, {
+          output: options.output,
+          theme: options.theme
+        });
+        const outName = outputPath.split(/[\\/]/).pop() ?? outputPath;
+        progress.succeed(`${chalk2.cyan(fileName)} \u2192 ${chalk2.green(outName)}`);
+        results.push({ input: file, output: outputPath, ok: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        progress.fail(`${chalk2.cyan(fileName)}: ${chalk2.red(msg)}`);
+        results.push({ input: file, ok: false, error: msg });
+      }
+    }
+    const failed = results.filter((r) => !r.ok);
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        ok: failed.length === 0,
+        durationMs: Date.now() - startTime,
+        files: results
+      }));
+    } else {
+      if (failed.length > 0) {
+        log.error(`${failed.length} of ${files.length} file(s) failed`);
+      }
+      const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+      log.info(`Done in ${elapsed}s`);
+    }
+    if (failed.length > 0) {
+      process.exit(1);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error(msg);
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map