mermaid-render 0.7.0__py3-none-any.whl

mermaid_render/__init__.py

@@ -0,0 +1,6 @@
+"""Cross-platform Mermaid to SVG / PNG / PDF / connected Visio conversion."""
+from .api import convert, mermaid_to_vsdx, mermaid_to_svg, mermaid_to_png, mermaid_to_pdf, svg_to_vsdx
+from .vsdx import build_vsdx
+from .semantic import build_connected_vsdx
+
+__all__ = ["convert", "mermaid_to_vsdx", "mermaid_to_svg", "mermaid_to_png", "mermaid_to_pdf", "svg_to_vsdx", "build_vsdx", "build_connected_vsdx"]

mermaid_render/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

mermaid_render/api.py

@@ -0,0 +1,220 @@
+"""Mermaid rendering in bundled Chromium: SVG, PNG, PDF and connected Visio."""
+from __future__ import annotations
+
+import math
+from importlib.resources import files
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+from .assets import ensure_browser, ensure_mermaid
+from .semantic import build_connected_vsdx
+from .vsdx import build_vsdx
+
+LOCAL_MERMAID_ORIGIN = "https://mermaid-render.local"
+
+
+def _serve_local_mermaid(page, dist: Path) -> str:
+    """Resolve virtual HTTPS ES module URLs to runtime files (offline)."""
+    dist = dist.resolve()
+
+    def serve(route):
+        relative = unquote(urlsplit(route.request.url).path).lstrip("/")
+        target = (dist / relative).resolve()
+        try:
+            target.relative_to(dist)
+        except ValueError:
+            route.abort("blockedbyclient")
+            return
+        if not target.is_file():
+            route.fulfill(status=404, body="Module not found", headers={"Access-Control-Allow-Origin": "*"})
+            return
+        content_type = (
+            "text/javascript" if target.suffix in (".js", ".mjs") else
+            "application/json" if target.suffix == ".json" else
+            "application/octet-stream"
+        )
+        route.fulfill(path=str(target), content_type=content_type,
+                      headers={"Access-Control-Allow-Origin": "*"})
+
+    page.route(f"{LOCAL_MERMAID_ORIGIN}/**", serve)
+    return f"{LOCAL_MERMAID_ORIGIN}/mermaid.esm.min.mjs"
+
+
+def _browser(playwright):
+    return playwright.chromium.launch(headless=True, executable_path=str(ensure_browser()))
+
+
+def svg_to_vsdx(
+    svg: str, output: str | Path | None = None, *, title: str = "SVG Diagram",
+) -> bytes:
+    """Geometry-only SVG to VSDX. SVG does not provide semantic glue relationships."""
+    from playwright.sync_api import sync_playwright
+
+    with sync_playwright() as p:
+        browser = _browser(p)
+        try:
+            page = browser.new_page(viewport={"width": 1600, "height": 1200})
+            page.set_content("<!doctype html><html><body><div id='root'></div></body></html>")
+            page.locator("#root").evaluate("(el, svg) => { el.innerHTML = svg; }", svg)
+            capture = files("mermaid_render").joinpath("capture.js").read_text(encoding="utf-8")
+            drawing = page.evaluate(capture)
+            if not drawing or not drawing.get("items"):
+                raise ValueError("SVG contained no supported visible shapes or text")
+            result = build_vsdx(drawing, title=title)
+        finally:
+            browser.close()
+    if output is not None:
+        Path(output).write_bytes(result)
+    return result
+
+
+
+def _render_image(page, *, output_format: str, background: str, scale: float) -> bytes:
+    """Render the Mermaid SVG using Chromium, like mermaid-cli.
+
+    PNG is a screenshot of the SVG at the requested device pixel ratio.
+    PDF uses Chromium's vector-aware print-to-PDF, sized to the SVG viewBox.
+    """
+    if not background or not isinstance(background, str):
+        raise ValueError("background must be a non-empty CSS color or 'transparent'")
+    dimensions = page.locator("#mount svg").evaluate("""svg => {
+        const vb = svg.viewBox.baseVal;
+        const box = svg.getBBox();
+        const width = vb && vb.width > 0 ? vb.width : box.width;
+        const height = vb && vb.height > 0 ? vb.height : box.height;
+        if (!(width > 0 && height > 0)) throw new Error('Mermaid SVG has invalid dimensions');
+        svg.setAttribute('width', width.toString());
+        svg.setAttribute('height', height.toString());
+        svg.style.cssText += `;display:block;width:${width}px;height:${height}px;max-width:none;`;
+        return {width, height};
+    }""")
+    width, height = dimensions["width"], dimensions["height"]
+    # Print/screenshot must not inherit Chromium's default 8px body margin.
+    page.add_style_tag(content=(
+        "html,body,#mount{margin:0;padding:0;overflow:visible;} "
+        "*{-webkit-print-color-adjust:exact;print-color-adjust:exact;}"
+    ))
+    transparent = background.lower() == "transparent"
+    if not transparent:
+        page.locator("#mount svg").evaluate("(svg, color) => svg.style.backgroundColor = color", background)
+    if output_format == "png":
+        # Page context sets device_scale_factor before rendering Mermaid.
+        return page.locator("#mount svg").screenshot(
+            type="png", scale="device", omit_background=transparent,
+            animations="disabled",
+        )
+    # Page size uses CSS pixels (96 CSS px/in); SVG paths stay vector in PDF.
+    page.add_style_tag(content=(
+        f"@page {{ size: {width}px {height}px; margin: 0; }} "
+        "html,body,#mount { width: max-content; height: max-content; }"
+    ))
+    page.emulate_media(media="screen")
+    return page.pdf(prefer_css_page_size=True, print_background=True,
+                    margin={"top": "0", "bottom": "0", "left": "0", "right": "0"})
+
+
+def _render_mermaid(
+    source: str, *, format: str, title: str, theme: str,
+    background: str, scale: float,
+) -> bytes:
+    from playwright.sync_api import sync_playwright
+
+    dist = ensure_mermaid()
+    with sync_playwright() as p:
+        browser = _browser(p)
+        try:
+            page = browser.new_page(
+                viewport={"width": 1600, "height": 1200},
+                device_scale_factor=scale if format == "png" else 1.0,
+            )
+            page.set_content("<!doctype html><html><body><div id='mount'></div></body></html>")
+            page.route("**/*", lambda route: route.abort("blockedbyclient"))
+            engine = _serve_local_mermaid(page, dist)
+            page.evaluate("""(moduleUrl) => {
+                window.__mermaidReady = false;
+                window.__mermaidLoadError = null;
+                import(moduleUrl).then(m => {
+                    window.__mermaid = m.default;
+                    window.__mermaidReady = true;
+                }).catch(e => { window.__mermaidLoadError = String(e); });
+            }""", engine)
+            try:
+                page.wait_for_function("window.__mermaidReady || window.__mermaidLoadError", timeout=30000)
+            except Exception as exc:
+                raise RuntimeError("Mermaid could not load from its installed support files") from exc
+            error = page.evaluate("window.__mermaidLoadError")
+            if error:
+                raise RuntimeError(f"Mermaid renderer failed to load: {error}.")
+            svg = page.evaluate("""async ({source, theme}) => {
+                const m = window.__mermaid;
+                m.initialize({startOnLoad:false,securityLevel:'strict',theme,
+                    htmlLabels:false,flowchart:{htmlLabels:false}});
+                const {svg} = await m.render('mermaid_render_graph', source);
+                document.getElementById('mount').innerHTML = svg;
+                window.__mermaidSource = source;
+                return svg;
+            }""", {"source": source, "theme": theme})
+            if format == "svg":
+                result = svg.encode("utf-8")
+            elif format in {"png", "pdf"}:
+                result = _render_image(page, output_format=format, background=background, scale=scale)
+            else:
+                graph_js = files("mermaid_render").joinpath("graph_capture.js").read_text(encoding="utf-8")
+                graph = page.evaluate(graph_js)
+                # Do not silently emit a Visio drawing with disconnected nodes.
+                if not graph.get("nodes") or not graph.get("edges"):
+                    raise ValueError("Connected VSDX requires a flowchart containing nodes and edges")
+                result = build_connected_vsdx(graph["nodes"], graph["edges"], title=title)
+        finally:
+            browser.close()
+    return result
+
+
+def convert(
+    source: str, output: str | Path | None = None, *, format: str | None = None,
+    title: str = "Mermaid Diagram", theme: str = "default",
+    background: str = "white", scale: float = 1.0,
+) -> bytes:
+    """Render Mermaid to SVG, PNG, PDF or editable connected Visio VSDX.
+
+    The extension selects the format unless explicitly specified. Without an
+    output path, connected VSDX remains the default. PNG uses ``scale`` as a
+    pixel density factor (1 = 96 dpi, 2 = 192 dpi). PDF remains vector based.
+    Connected VSDX currently supports Mermaid flowcharts only.
+    """
+    if not math.isfinite(scale) or not (0.1 <= scale <= 4):
+        raise ValueError("scale must be between 0.1 and 4")
+    if format is None:
+        format = Path(output).suffix.lower().lstrip(".") if output else "vsdx"
+    format = format.lower().lstrip(".")
+    if format == "visio":
+        format = "vsdx"
+    if format not in {"svg", "png", "pdf", "vsdx"}:
+        raise ValueError("format must be 'svg', 'png', 'pdf', 'visio', or 'vsdx'")
+    if output is not None and Path(output).suffix.lower() != f".{format}":
+        raise ValueError(f"Output filename must end with .{format}")
+    result = _render_mermaid(source, format=format, title=title, theme=theme,
+                             background=background, scale=scale)
+    if output is not None:
+        Path(output).write_bytes(result)
+    return result
+
+
+def mermaid_to_vsdx(source: str, output: str | Path | None = None, **kwargs) -> bytes:
+    """Convert Mermaid flowchart to VSDX with glued native Visio connectors."""
+    return convert(source, output, format="vsdx", **kwargs)
+
+
+def mermaid_to_svg(source: str, output: str | Path | None = None, **kwargs) -> bytes:
+    """Render Mermaid to SVG using the official browser-based Mermaid runtime."""
+    return convert(source, output, format="svg", **kwargs)
+
+
+def mermaid_to_png(source: str, output: str | Path | None = None, **kwargs) -> bytes:
+    """Render Mermaid to PNG in Chromium."""
+    return convert(source, output, format="png", **kwargs)
+
+
+def mermaid_to_pdf(source: str, output: str | Path | None = None, **kwargs) -> bytes:
+    """Render Mermaid to vector PDF via Chromium print-to-PDF."""
+    return convert(source, output, format="pdf", **kwargs)

mermaid_render/assets.py

@@ -0,0 +1,143 @@
+"""Resolve bundled runtimes or install them in persistent per-user support data."""
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Callable
+
+from filelock import FileLock
+from platformdirs import user_data_path
+
+from .vendor import DEFAULT_VERSION, download_mermaid
+
+RELEASES_URL = 'https://github.com/himbeles/mermaid-render/releases'
+SHELL_NAMES = {'chrome-headless-shell', 'chrome-headless-shell.exe', 'headless_shell'}
+
+
+class RuntimeSetupError(RuntimeError):
+    """Runtime installation failed, with an actionable offline alternative."""
+
+
+def data_root() -> Path:
+    return user_data_path('mermaid-render', appauthor=False)
+
+
+def package_root() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def browser_version() -> str:
+    return importlib.metadata.version('playwright')
+
+
+def find_shell(browsers: Path) -> Path:
+    candidates = sorted(p for p in browsers.glob('chromium_headless_shell-*/*/*')
+                        if p.is_file() and p.name in SHELL_NAMES)
+    if len(candidates) != 1:
+        raise RuntimeError(f'Expected exactly one Chromium Headless Shell in {browsers}, got: {candidates}')
+    return candidates[0]
+
+
+def browser_in(directory: Path) -> Path | None:
+    manifest = directory / 'BROWSER_INFO.json'
+    if not manifest.is_file():
+        return None
+    info = json.loads(manifest.read_text(encoding='utf-8'))
+    relative = Path(info['executable'])
+    if relative.is_absolute() or '..' in relative.parts:
+        raise ValueError('Invalid Chromium executable path')
+    executable = (directory / relative).resolve()
+    executable.relative_to(directory.resolve())
+    if info.get('playwright_version') != browser_version() or not executable.is_file():
+        return None
+    if os.name != 'nt' and not os.access(executable, os.X_OK):
+        return None
+    return executable
+
+
+def bundled_browser() -> Path | None:
+    return browser_in(package_root() / 'browsers')
+
+
+def mermaid_in(directory: Path) -> Path | None:
+    manifest = directory / 'VERSION.json'
+    if not manifest.is_file() or not (directory / 'mermaid.esm.min.mjs').is_file():
+        return None
+    info = json.loads(manifest.read_text(encoding='utf-8'))
+    return directory if info.get('version') == DEFAULT_VERSION else None
+
+
+def install_browser(destination: Path) -> None:
+    env = os.environ.copy()
+    env['PLAYWRIGHT_BROWSERS_PATH'] = str(destination)
+    env['PLAYWRIGHT_SKIP_BROWSER_GC'] = '1'
+    result = subprocess.run(
+        [sys.executable, '-m', 'playwright', 'install', '--only-shell', 'chromium'],
+        env=env, capture_output=True, text=True, timeout=300,
+    )
+    if result.returncode:
+        raise RuntimeError((result.stderr or result.stdout).strip() or 'Playwright browser download failed')
+    shell = find_shell(destination)
+    if os.name != 'nt':
+        shell.chmod(shell.stat().st_mode | 0o111)
+    (destination / 'BROWSER_INFO.json').write_text(json.dumps({
+        'executable': shell.relative_to(destination).as_posix(),
+        'playwright_version': browser_version(),
+    }, indent=2) + '\n', encoding='utf-8')
+
+
+def _ensure(name: str, bundled: Path, target: Path, ready: Callable, install: Callable) -> Path:
+    try:
+        found = ready(bundled) or ready(target)
+        if found:
+            return found
+        root = data_root()
+        root.mkdir(parents=True, exist_ok=True)
+        with FileLock(str(root / '.setup.lock'), timeout=360):
+            # Another process may have finished while we waited for its lock.
+            found = ready(bundled) or ready(target)
+            if found:
+                return found
+            target.parent.mkdir(parents=True, exist_ok=True)
+            print(f'Installing {name} support files in {target}...', file=sys.stderr)
+            with tempfile.TemporaryDirectory(prefix='.install-', dir=target.parent) as temporary:
+                staged = Path(temporary) / 'payload'
+                staged.mkdir()
+                install(staged)
+                if not ready(staged):
+                    raise RuntimeError(f'{name} installation is incomplete')
+                # Only an incomplete installation can reach this point. Keep it
+                # until the replacement is fully downloaded and validated.
+                if target.exists():
+                    shutil.rmtree(target)
+                staged.replace(target)
+            return ready(target)
+    except (OSError, RuntimeError, ValueError, KeyError, tarfile.TarError, subprocess.SubprocessError) as exc:
+        raise RuntimeSetupError(
+            f'Could not prepare {name}: {exc}\n'
+            f'For offline use, download the bundled wheel for your OS from {RELEASES_URL} '
+            'and install it with: uv tool install --force /path/to/bundled.whl'
+        ) from exc
+
+
+def ensure_mermaid() -> Path:
+    return _ensure('Mermaid', package_root() / 'runtime',
+                   data_root() / 'mermaid' / DEFAULT_VERSION, mermaid_in, download_mermaid)
+
+
+def ensure_browser() -> Path:
+    key = f'playwright-{browser_version()}-{platform.system().lower()}-{platform.machine().lower()}'
+    return _ensure('Chromium', package_root() / 'browsers',
+                   data_root() / 'browsers' / key, browser_in, install_browser)
+
+
+def setup_runtime() -> tuple[Path, Path]:
+    return ensure_mermaid(), ensure_browser()

mermaid_render/capture.js

@@ -0,0 +1,139 @@
+/* SVG DOM -> serializable display list. Port of mermaid-to-visio/svgCapture.ts
+ * Executes in a real browser where getBBox/getCTM/getComputedStyle work.
+ */
+(() => {
+  const SKIP = new Set(['defs','marker','clippath','symbol','pattern','mask']);
+  const f = (n, fallback=0) => Number.isFinite(parseFloat(n)) ? parseFloat(n) : fallback;
+  const num = (el, key) => f(el.getAttribute(key));
+  function color(s) {
+    if (!s || s === 'none' || s === 'transparent') return null;
+    if (s.startsWith('#')) {
+      if (s.length === 4) return '#' + [...s.slice(1)].map(x=>x+x).join('').toUpperCase();
+      return s.toUpperCase();
+    }
+    const match = s.match(/^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,\s/]+([\d.]+))?\s*\)/);
+    if (match) {
+      if (match[4] !== undefined && Number(match[4]) === 0) return null;
+      return '#' + match.slice(1,4).map(x => Math.max(0,Math.min(255, Math.round(Number(x)))).toString(16).padStart(2,'0')).join('').toUpperCase();
+    }
+    return s; // Visio may not accept named colors; browser normally resolves to rgb
+  }
+  const pt = (x,y) => ({x,y});
+  function xyToRoot(el, x, y) {
+    const m = el.getCTM();
+    return m ? pt(m.a*x+m.c*y+m.e, m.b*x+m.d*y+m.f) : pt(x,y);
+  }
+  function simplify(points, tolerance=0.35) {
+    if (points.length<=2) return points;
+    const out=[points[0]];
+    for (let i=1;i<points.length-1;i++) {
+      const a=out[out.length-1], b=points[i], c=points[i+1];
+      const dx=c.x-a.x, dy=c.y-a.y, length=Math.hypot(dx,dy)||1;
+      if (Math.abs((b.x-a.x)*dy-(b.y-a.y)*dx)/length>tolerance) out.push(b);
+    }
+    out.push(points[points.length-1]);
+    return out;
+  }
+  function ellipse(cx,cy,rx,ry) {
+    return Array.from({length:48},(_,i)=>{
+      const a=i/48*2*Math.PI;
+      return pt(cx+rx*Math.cos(a),cy+ry*Math.sin(a));
+    });
+  }
+  function pathPoints(el) {
+    let total;
+    try { total=el.getTotalLength(); } catch { return null; }
+    if (!(total>0) || !Number.isFinite(total)) return null;
+    const step=Math.max(1.5,total/600), pts=[];
+    for (let t=0;t<total;t+=step) {
+      const p=el.getPointAtLength(t); pts.push(pt(p.x,p.y));
+    }
+    const end=el.getPointAtLength(total);
+    pts.push(pt(end.x,end.y));
+    return pts;
+  }
+  function hidden(el) {
+    const s=getComputedStyle(el);
+    return s.display==='none'||s.visibility==='hidden'||f(s.opacity,1)===0;
+  }
+  function poly(el) {
+    const name=el.tagName.toLowerCase();
+    let local=null, closed=false;
+    if (name==='rect') {
+      const x=num(el,'x'), y=num(el,'y'), w=num(el,'width'), h=num(el,'height');
+      if(w<=0||h<=0) return null;
+      local=[pt(x,y),pt(x+w,y),pt(x+w,y+h),pt(x,y+h)];closed=true;
+    } else if(name==='circle') {
+      const r=num(el,'r');if(r<=0)return null;
+      local=ellipse(num(el,'cx'),num(el,'cy'),r,r);closed=true;
+    } else if(name==='ellipse') {
+      const rx=num(el,'rx'),ry=num(el,'ry');if(rx<=0||ry<=0)return null;
+      local=ellipse(num(el,'cx'),num(el,'cy'),rx,ry);closed=true;
+    } else if(name==='line') {
+      local=[pt(num(el,'x1'),num(el,'y1')),pt(num(el,'x2'),num(el,'y2'))];
+    } else if(name==='polyline'||name==='polygon') {
+      const raw=el.getAttribute('points')||'';
+      const nums=raw.trim().split(/[\s,]+/).map(Number).filter(Number.isFinite);
+      local=[];for(let i=0;i+1<nums.length;i+=2)local.push(pt(nums[i],nums[i+1]));
+      closed=name==='polygon';
+    } else if(name==='path') {
+      local=pathPoints(el);closed=/z\s*$/i.test(el.getAttribute('d')||'');
+    }
+    if(!local||local.length<2)return null;
+    const s=getComputedStyle(el), fill=color(s.fill), stroke=color(s.stroke);
+    if(!fill&&!stroke)return null;
+    const points=simplify(local.map(p=>xyToRoot(el,p.x,p.y)));
+    if(points.length<2)return null;
+    return {kind:'poly',points,closed,fill,stroke,strokeWidthPx:f(s.strokeWidth,1),
+      dash: !!s.strokeDasharray && s.strokeDasharray!=='none'&&s.strokeDasharray!=='0',
+      beginArrow: !!s.markerStart && s.markerStart !== 'none',
+      endArrow: !!s.markerEnd && s.markerEnd !== 'none'};
+  }
+  function textItem(el, value) {
+    value=value.replace(/\s+/g,' ').trim();if(!value)return null;
+    let bbox;
+    try {bbox=el.getBBox();}catch{return null;}
+    if(bbox.width===0&&bbox.height===0)return null;
+    const corners=[xyToRoot(el,bbox.x,bbox.y),xyToRoot(el,bbox.x+bbox.width,bbox.y),
+      xyToRoot(el,bbox.x+bbox.width,bbox.y+bbox.height),xyToRoot(el,bbox.x,bbox.y+bbox.height)];
+    const xs=corners.map(p=>p.x), ys=corners.map(p=>p.y);
+    const s=getComputedStyle(el);
+    let leaf=el;
+    while(true) {
+      const inner=[...leaf.children].find(c=>c.tagName.toLowerCase()==='tspan');
+      if(!inner)break;leaf=inner;
+    }
+    const ls=getComputedStyle(leaf);
+    const weight=ls.fontWeight||s.fontWeight||'400';
+    return {kind:'text',text:value,x:Math.min(...xs),y:Math.min(...ys),
+      width:Math.max(...xs)-Math.min(...xs),height:Math.max(...ys)-Math.min(...ys),
+      fontPx:f(s.fontSize,12),fontFamily:(s.fontFamily||'Arial').split(',')[0].replace(/["']/g,'').trim(),
+      bold:weight==='bold'||parseInt(weight,10)>=600,italic:(ls.fontStyle||s.fontStyle)==='italic',
+      anchor:['middle','end'].includes(s.textAnchor)?s.textAnchor:'start',fill:color(ls.fill)||color(s.fill)||'#000000'};
+  }
+  function capture(svg) {
+    const vb=(svg.getAttribute('viewBox')||'').trim().split(/[\s,]+/).map(Number);
+    const b=vb.length===4 && vb.every(Number.isFinite) ? {width:vb[2],height:vb[3]} : svg.getBBox();
+    svg.setAttribute('width',String(b.width));svg.setAttribute('height',String(b.height));
+    Object.assign(svg.style,{width:`${b.width}px`,height:`${b.height}px`,maxWidth:'none'});
+    const items=[];
+    function walk(el) {
+      const name=el.tagName.toLowerCase();
+      if(SKIP.has(name) || (el instanceof SVGGraphicsElement && hidden(el)))return;
+      if(name==='text') {
+        const lines=[...el.children].filter(c=>c.tagName.toLowerCase()==='tspan'&&c.hasAttribute('x'));
+        if(lines.length>=2) {
+          for(const l of lines){const t=textItem(l,l.textContent||'');if(t)items.push(t);}
+        } else {
+          const t=textItem(el,el.textContent||'');if(t)items.push(t);
+        }
+        return;
+      }
+      const p=poly(el);if(p)items.push(p);
+      for(const child of el.children)walk(child);
+    }
+    for(const child of svg.children)walk(child);
+    return {width:b.width,height:b.height,items};
+  }
+  return capture(document.querySelector('svg'));
+})()

mermaid_render/cli.py

@@ -0,0 +1,48 @@
+"""Cross-platform command-line entry point."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .api import convert
+from .assets import RuntimeSetupError, setup_runtime
+
+
+def main() -> None:
+    import sys
+
+    if sys.argv[1:] == ["setup"]:
+        try:
+            mermaid, browser = setup_runtime()
+        except RuntimeSetupError as exc:
+            raise SystemExit(str(exc)) from exc
+        print(f"Runtime ready: Mermaid at {mermaid}; Chromium at {browser}")
+        return
+    parser = argparse.ArgumentParser(description="Render Mermaid as SVG, PNG, PDF or connected Visio VSDX",
+                                     epilog="Missing runtime files install automatically. Use mermaid-render setup to prepare them in advance.")
+    parser.add_argument("input", type=Path, help="Mermaid .mmd/.mermaid file")
+    parser.add_argument("-o", "--output", type=Path, help="Output .svg, .png, .pdf or .vsdx file")
+    parser.add_argument("-f", "--format", choices=["svg", "png", "pdf", "visio", "vsdx"], help="Output format (otherwise inferred from -o, default vsdx)")
+    parser.add_argument("--title", help="Diagram title for Visio")
+    parser.add_argument("--theme", default="default", help="Mermaid theme")
+    parser.add_argument("--background", default="white", help="PNG/PDF background color or transparent (PNG)")
+    parser.add_argument("--scale", type=float, default=1.0, help="PNG pixel density factor (default 1 = 96 dpi)")
+    args = parser.parse_args()
+    fmt = args.format or (args.output.suffix.lower().lstrip(".") if args.output else "vsdx")
+    fmt = "vsdx" if fmt == "visio" else fmt
+    if fmt not in {"svg", "png", "pdf", "vsdx"}:
+        parser.error("output extension must be .svg, .png, .pdf or .vsdx")
+    output = args.output or args.input.with_suffix(f".{fmt}")
+    if args.input.suffix.lower() not in {".mmd", ".mermaid"}:
+        parser.error("input must be Mermaid (.mmd/.mermaid)")
+    try:
+        convert(args.input.read_text(encoding="utf-8"), output, format=fmt,
+                title=args.title or args.input.stem, theme=args.theme,
+                background=args.background, scale=args.scale)
+    except RuntimeSetupError as exc:
+        parser.exit(1, f"{exc}\n")
+    print(f"Created {output}")
+
+
+if __name__ == "__main__":
+    main()

mermaid_render/graph_capture.js

@@ -0,0 +1,95 @@
+/* Recover graph structure from Mermaid's own flowchart DB and geometry from SVG.
+ * Evaluated in Chromium after mermaid.render() has inserted an SVG in #mount.
+ * A missing node mapping is an error: never silently return disconnected shapes.
+ */
+(async () => {
+  const m = window.__mermaid;
+  const source = window.__mermaidSource;
+  const diagram = await m.mermaidAPI.getDiagramFromText(source);
+  if (!/^flowchart/.test(diagram.type)) {
+    throw new Error(`Connected VSDX export supports Mermaid flowcharts, not ${diagram.type}`);
+  }
+  const db = diagram.db;
+  const data = typeof db.getData === 'function' ? db.getData() : {
+    nodes: [...db.getVertices().values()],
+    edges: db.getEdges().map(e => ({start:e.start,end:e.end,label:e.text,type:e.type}))
+  };
+  if (!data.nodes?.length) throw new Error('Mermaid flowchart has no nodes');
+  const svg = document.querySelector('#mount svg');
+  if (!svg) throw new Error('Mermaid did not render an SVG');
+  const vb = (svg.getAttribute('viewBox') || '').trim().split(/[\s,]+/).map(Number);
+  if (vb.length === 4 && vb.every(Number.isFinite)) {
+    svg.setAttribute('width', String(vb[2]));
+    svg.setAttribute('height', String(vb[3]));
+    Object.assign(svg.style, {width:`${vb[2]}px`,height:`${vb[3]}px`,maxWidth:'none'});
+  }
+  const geometry = (el) => {
+    const b = el.getBBox(), t = el.getCTM();
+    if (!t) throw new Error('Could not measure SVG node');
+    const corners = [[b.x,b.y],[b.x+b.width,b.y],[b.x+b.width,b.y+b.height],[b.x,b.y+b.height]];
+    const pts = corners.map(([x,y]) => ({x:t.a*x+t.c*y+t.e,y:t.b*x+t.d*y+t.f}));
+    const xs = pts.map(p=>p.x), ys=pts.map(p=>p.y);
+    return {x:Math.min(...xs),y:Math.min(...ys),width:Math.max(...xs)-Math.min(...xs),height:Math.max(...ys)-Math.min(...ys)};
+  };
+  const candidates = [...svg.querySelectorAll('g.node, g.cluster, [data-id]')].filter(el => el instanceof SVGGraphicsElement);
+  function elementFor(id) {
+    const matches = candidates.filter(el => {
+      const domId = el.getAttribute('id') || '';
+      // Mermaid 12 prefixes generated IDs with the containing SVG's ID.
+      // Remove that exact prefix before matching; node IDs can contain dashes.
+      const prefix = `${svg.id}-`;
+      const localId = svg.id && domId.startsWith(prefix) ? domId.slice(prefix.length) : domId;
+      return el.getAttribute('data-id') === id || domId === id ||
+        localId.match(/^flowchart-(.*)-\d+$/)?.[1] === id;
+    });
+    return matches.find(el => el.classList.contains('node')) ||
+      matches.find(el => el.classList.contains('cluster')) || matches[0];
+  }
+  function formatLabel(x, fallback) {
+    if (typeof x === 'string') return x;
+    if (typeof x === 'number') return String(x);
+    if (x && typeof x === 'object' && typeof x.text === 'string') return x.text;
+    return fallback;
+  }
+  const cssColor = (value, fallback) => {
+    if (!value || value === 'none' || value === 'transparent') return fallback;
+    if (value.startsWith('#')) return value;
+    const parts = value.match(/^rgba?\(\s*(\d+)[,\s]+(\d+)[,\s]+(\d+)/);
+    if (parts) return '#' + parts.slice(1,4).map(n => (+n).toString(16).padStart(2,'0')).join('').toUpperCase();
+    return fallback;
+  };
+  const nodes = data.nodes.map(n => {
+    const id = String(n.id), el = elementFor(id);
+    if (!el) throw new Error(`Cannot locate SVG element for Mermaid node '${id}'`);
+    const dim = geometry(el);
+    if (!(dim.width > 0 && dim.height > 0)) throw new Error(`Invalid bounds for Mermaid node '${id}'`);
+    const glyph = el.querySelector('.basic, .label-container, rect, polygon, ellipse, circle, path');
+    const cs = getComputedStyle(glyph || el);
+    const textEl = el.querySelector('text, foreignObject');
+    const fontCss = textEl ? getComputedStyle(textEl) : cs;
+    const label = (el.querySelector('.nodeLabel, .label, text')?.textContent || '').trim() ||
+      formatLabel(n.label, id);
+    return {
+      id, ...dim, text:label, shape: String(n.shape || n.type || ''),
+      corner_radius: glyph?.tagName.toLowerCase() === 'rect' ? glyph.rx.baseVal.value : 0,
+      fill: cssColor(cs.fill, '#E5EFFA'),
+      stroke: cssColor(cs.stroke, '#4472C4'),
+      font_color: cssColor(fontCss.fill, '#172D4A'),
+      font_size: Number.parseFloat(fontCss.fontSize) || 14,
+      is_group: Boolean(n.isGroup)
+    };
+  });
+  const edges = (data.edges || []).map(e => {
+    const source = String(e.start ?? e.source ?? ''), target = String(e.end ?? e.target ?? '');
+    return {
+      source, target, text:formatLabel(e.label, ''),
+      // Mermaid getData supplies arrowTypeEnd or arrowTypeStart for actual directedness.
+      // 'arrow_open' is an undirected line in older diagram models.
+      arrow: e.arrowTypeEnd !== undefined ? e.arrowTypeEnd !== 'none' : e.type !== 'arrow_open',
+      start_arrow: e.arrowTypeStart !== undefined && e.arrowTypeStart !== 'none',
+      dash: e.pattern === 'dotted' || e.pattern === 'dashed',
+      stroke: '#4472C4'
+    };
+  });
+  return {nodes,edges};
+})()