mermaid-render 0.7.0__tar.gz

mermaid_render-0.7.0/.gitignore

@@ -0,0 +1,19 @@
+.venv/
+__pycache__/
+.pytest_cache/
+*.py[cod]
+dist/
+build/
+*.egg-info/
+.mypy_cache/
+.ruff_cache/
+.DS_Store
+src/mermaid_render/runtime/**
+!src/mermaid_render/runtime/README.txt
+
+src/mermaid_render/browsers/**
+!src/mermaid_render/browsers/README.txt
+
+src/mermaid_render/browsers
+
+mermaid-dist

mermaid_render-0.7.0/.python-version

@@ -0,0 +1 @@
+3.13

mermaid_render-0.7.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Mermaid Visio Python port contributors
+
+This project is a Python adaptation of the Mermaid-to-Visio implementation:
+Copyright (c) 2026 Freddy Beltran <freddy.beltran@klyra.tech>, Klyra (https://klyra.tech),
+and the Stratos platform (https://mystratos.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mermaid_render-0.7.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.5
+Name: mermaid-render
+Version: 0.7.0
+Summary: Render Mermaid diagrams to SVG, PNG, PDF or connected Visio VSDX
+Author: Python port contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: diagram,mermaid,pdf,png,svg,visio,vsdx
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Requires-Python: >=3.10
+Requires-Dist: filelock<4,>=3.16
+Requires-Dist: platformdirs<5,>=4
+Requires-Dist: playwright==1.63.0
+Description-Content-Type: text/markdown
+
+# mermaid-render
+
+Render **Mermaid → SVG, PNG and PDF**, and **Mermaid flowcharts → connected Visio VSDX** on Linux, Windows, and macOS. Python uses the official Mermaid.js renderer inside Chromium Headless Shell, controlled through Playwright. Node.js, a browser installation, and Microsoft Visio are **not required on the target machine** when installing a platform-specific **bundled wheel**.
+
+The converter is adapted from the MIT-licensed [FBklyra/mermaid-to-visio](https://github.com/FBklyra/mermaid-to-visio). Mermaid itself is MIT licensed; Chromium and Playwright have their own third-party notices and licenses. Keep those notices with redistributed binaries.
+
+## Prebuilt offline wheels via GitHub Actions
+
+The workflow [`.github/workflows/bundled-wheels.yml`](.github/workflows/bundled-wheels.yml) builds two distributions using uv:
+
+- **PyPI:** a small universal Python wheel and source archive, without Mermaid.js or browser binaries. The first render automatically installs the pinned runtime support files.
+- **GitHub Releases:** the exact PyPI artifacts plus four bundled wheels for Linux x86-64, Windows x86-64, macOS Apple Silicon, and macOS Intel. Bundled wheels contain Mermaid **12.1.0** and the Chromium Headless Shell matching Playwright **1.63.0**, so rendering needs no runtime downloads.
+
+A matching version tag (for example `v0.7.0`) attaches all six artifacts to a GitHub Release and publishes only the lightweight artifacts to PyPI through Trusted Publishing. Pull requests, pushes to `main`, and manual runs build and test without publishing.
+
+### Runtime support files
+
+Each asset is resolved independently: first from its bundled location inside the installed package (`mermaid_render/runtime` and `mermaid_render/browsers`), then from persistent per-user application data:
+
+| OS | Support directory |
+|---|---|
+| macOS | `~/Library/Application Support/mermaid-render` |
+| Linux | `$XDG_DATA_HOME/mermaid-render`, default `~/.local/share/mermaid-render` |
+| Windows | `%LOCALAPPDATA%\mermaid-render` |
+
+These are support files, not temporary or cache files. Mermaid uses a versioned `mermaid/<version>` subdirectory; Chromium uses `browsers/playwright-<version>-<os>-<architecture>`. Upgrades keep versions separate. Downloads are staged and validated before installation, and concurrent processes share an installation lock. Rendering reuses existing files without downloading them again.
+
+Missing assets install automatically on render. Optionally run `mermaid-render setup` beforehand. Runtime paths are managed internally; the CLI and rendering API have no Mermaid or browser path overrides. If automatic setup fails, the error links directly to the [GitHub Releases](https://github.com/himbeles/mermaid-render/releases) bundled wheels and explains how to install one for offline use.
+
+### Building from GitHub
+
+1. Push this repository to GitHub (including `.github/workflows/bundled-wheels.yml`).
+2. Select **Actions → mermaid-render distributions → Run workflow**.
+3. Download your platform's wheel from the run artifacts, or get all four wheels from the GitHub Release created when you push a `v*` tag.
+
+### Install and use (after downloading your platform wheel)
+
+```bash
+uv tool install ./mermaid_render-*-py3-none-macosx_*_arm64.whl
+mermaid-render diagram.mmd -o diagram.svg
+mermaid-render diagram.mmd -o diagram.png --scale 2
+mermaid-render diagram.mmd -o diagram.pdf
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+The example installs the macOS Apple Silicon wheel. Choose the wheel matching your operating system and architecture.
+
+For the lightweight PyPI installation:
+
+```bash
+uv tool install mermaid-render
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+```python
+from mermaid_render import convert
+
+source = """flowchart LR
+  A[Input] --> B{Valid?}
+  B -->|Yes| C[Process]
+  B -->|No| D[Reject]
+"""
+
+convert(source, "diagram.svg")
+convert(source, "diagram.png", scale=2, background="transparent")
+convert(source, "diagram.pdf")
+convert(source, "diagram.vsdx")
+```
+
+Visio VSDX generation creates editable flowchart shapes and *native connection relationships*, not generic disconnected SVG paths. Only flowcharts currently support connected VSDX export; other Mermaid diagram types can be exported as SVG, PNG or PDF. Connection behavior after editing/moving nodes in desktop Visio is not yet independently verified.
+
+## Output formats
+
+`mermaid-render` infers the format from the output extension; use `-f/--format`
+to choose explicitly (`svg`, `png`, `pdf`, `visio`/`vsdx`). The API returns
+bytes and optionally writes the output file:
+
+```bash
+mermaid-render diagram.mmd -o diagram.svg
+mermaid-render diagram.mmd -o diagram.png --scale 2 --background transparent
+mermaid-render diagram.mmd -o diagram.pdf --background white
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+- **SVG:** Original Mermaid-generated SVG markup, without rasterization.
+- **PNG:** Chromium screenshot at the Mermaid SVG viewBox size. `--scale 2`
+  doubles pixel dimensions (96 to 192 pixels per CSS inch). `--background`
+  accepts a CSS color or `transparent`.
+- **PDF:** Chromium print-to-PDF with a tight single diagram-sized page, zero
+  margins, and vector SVG content where supported. The `--scale` option applies
+  only to PNG. PDF transparency is not guaranteed by Chromium; use SVG or PNG
+  when an alpha channel is needed.
+- **VSDX:** Native Visio shapes and connection relationships for Mermaid flowcharts.
+  Other Mermaid types deliberately fail rather than writing disconnected shapes.
+
+All four formats use the *same official Mermaid.js runtime in headless Chromium*.
+No Node.js process or installed system browser is used by the offline wheels.
+
+## Development using uv
+
+```bash
+uv sync
+uv run pytest -q
+uv run mermaid-render examples/example.mmd --format png -o diagram.png
+```
+
+`uv sync` creates a `.venv` from the committed lockfile. Rendering and browser tests automatically prepare missing runtime support files. The project uses Hatchling with a PEP 621 `pyproject.toml` and `src/` layout.
+
+Default builds are always lightweight, even if the checkout contains old bundled files:
+
+```bash
+uv build --out-dir dist/pypi
+uv run python scripts/check_lightweight_dist.py dist/pypi
+```
+
+### Local platform-specific wheel build
+
+On a machine with internet access, with the same OS/architecture as your intended wheel:
+
+```bash
+uv sync
+uv run python scripts/build_platform_wheel.py --outdir dist/bundled
+uv run python scripts/test_wheel_install.py dist/bundled/*.whl
+```
+
+The platform tag is detected automatically. For Linux, install system browser libraries first (`uv run python -m playwright install-deps chromium`). The script downloads the pinned Mermaid distribution, installs the matching headless shell into temporary staging, writes a relative executable manifest, and builds a platform-specific wheel directly with `uv build` and a Hatchling hook. Staging is removed afterward and the source tree is never populated with runtime assets. The wheel retains native executable permissions and includes upstream license assets distributed in the payload.
+
+**Linux compatibility:** Linux wheels are available through GitHub Releases only. They use the `linux_x86_64` tag and bundle Chromium without vendoring its system libraries. Install compatible browser dependencies on the target system (`python -m playwright install-deps chromium`). The wheel is tested on Ubuntu 24.04 and is not audited for manylinux compatibility.
+
+**macOS caveat:** The wheel tag derives its minimum version from the bundled Mach-O binaries using `otool`; there is no project-defined macOS minimum. CI tests on macOS 15, so older versions are not independently tested. If Gatekeeper imposes restrictions on downloaded unsigned binaries, local signing or organizational policy may be needed.
+
+### Configure PyPI publishing
+
+Commit and push the release changes. Set `project.version` to the intended release version, then push the matching tag, for example:
+
+   ```bash
+   git tag v0.7.0
+   git push origin v0.7.0
+   ```
+
+The workflow also runs builds on pull requests and main-branch pushes, but those runs do not publish to PyPI. If a publish run stops after a partial upload, rerun the failed job: uv checks PyPI and skips identical files already uploaded. Published versions cannot be overwritten; use a new version for changed artifacts.
+
+After the first successful publication, on any supported operating system:
+
+```bash
+uv tool install mermaid-render
+mermaid-render examples/example.mmd -o diagram.vsdx
+```
+
+## Development/project structure
+
+- `src/mermaid_render/api.py` — Python API and SVG/PNG/PDF rendering
+- `src/mermaid_render/assets.py` — bundled lookup and persistent runtime support installation
+- `src/mermaid_render/graph_capture.js` — Mermaid graph semantics and SVG geometry extraction
+- `src/mermaid_render/semantic.py` — connected Visio shapes/edges with Glue formula references
+- `src/mermaid_render/vsdx.py` — geometry-only VSDX exporter for arbitrary SVG
+- `scripts/build_platform_wheel.py` — real platform wheel build with bundled Mermaid/Chromium
+- `hatch_build.py` and `scripts/wheel_platform.py` — native wheel metadata and binary-derived platform tags
+- `scripts/test_wheel_install.py` and `scripts/smoke_offline.py` — clean-venv install, offline SVG/Visio smoke test
+- `.github/workflows/bundled-wheels.yml` — four-platform build/test/release workflow
+
+## License
+
+MIT for the Python port and its source adaptation; see `LICENSE`. Mermaid and Chromium remain third-party projects with their own notices and copyright holders.

mermaid_render-0.7.0/README.md

@@ -0,0 +1,164 @@
+# mermaid-render
+
+Render **Mermaid → SVG, PNG and PDF**, and **Mermaid flowcharts → connected Visio VSDX** on Linux, Windows, and macOS. Python uses the official Mermaid.js renderer inside Chromium Headless Shell, controlled through Playwright. Node.js, a browser installation, and Microsoft Visio are **not required on the target machine** when installing a platform-specific **bundled wheel**.
+
+The converter is adapted from the MIT-licensed [FBklyra/mermaid-to-visio](https://github.com/FBklyra/mermaid-to-visio). Mermaid itself is MIT licensed; Chromium and Playwright have their own third-party notices and licenses. Keep those notices with redistributed binaries.
+
+## Prebuilt offline wheels via GitHub Actions
+
+The workflow [`.github/workflows/bundled-wheels.yml`](.github/workflows/bundled-wheels.yml) builds two distributions using uv:
+
+- **PyPI:** a small universal Python wheel and source archive, without Mermaid.js or browser binaries. The first render automatically installs the pinned runtime support files.
+- **GitHub Releases:** the exact PyPI artifacts plus four bundled wheels for Linux x86-64, Windows x86-64, macOS Apple Silicon, and macOS Intel. Bundled wheels contain Mermaid **12.1.0** and the Chromium Headless Shell matching Playwright **1.63.0**, so rendering needs no runtime downloads.
+
+A matching version tag (for example `v0.7.0`) attaches all six artifacts to a GitHub Release and publishes only the lightweight artifacts to PyPI through Trusted Publishing. Pull requests, pushes to `main`, and manual runs build and test without publishing.
+
+### Runtime support files
+
+Each asset is resolved independently: first from its bundled location inside the installed package (`mermaid_render/runtime` and `mermaid_render/browsers`), then from persistent per-user application data:
+
+| OS | Support directory |
+|---|---|
+| macOS | `~/Library/Application Support/mermaid-render` |
+| Linux | `$XDG_DATA_HOME/mermaid-render`, default `~/.local/share/mermaid-render` |
+| Windows | `%LOCALAPPDATA%\mermaid-render` |
+
+These are support files, not temporary or cache files. Mermaid uses a versioned `mermaid/<version>` subdirectory; Chromium uses `browsers/playwright-<version>-<os>-<architecture>`. Upgrades keep versions separate. Downloads are staged and validated before installation, and concurrent processes share an installation lock. Rendering reuses existing files without downloading them again.
+
+Missing assets install automatically on render. Optionally run `mermaid-render setup` beforehand. Runtime paths are managed internally; the CLI and rendering API have no Mermaid or browser path overrides. If automatic setup fails, the error links directly to the [GitHub Releases](https://github.com/himbeles/mermaid-render/releases) bundled wheels and explains how to install one for offline use.
+
+### Building from GitHub
+
+1. Push this repository to GitHub (including `.github/workflows/bundled-wheels.yml`).
+2. Select **Actions → mermaid-render distributions → Run workflow**.
+3. Download your platform's wheel from the run artifacts, or get all four wheels from the GitHub Release created when you push a `v*` tag.
+
+### Install and use (after downloading your platform wheel)
+
+```bash
+uv tool install ./mermaid_render-*-py3-none-macosx_*_arm64.whl
+mermaid-render diagram.mmd -o diagram.svg
+mermaid-render diagram.mmd -o diagram.png --scale 2
+mermaid-render diagram.mmd -o diagram.pdf
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+The example installs the macOS Apple Silicon wheel. Choose the wheel matching your operating system and architecture.
+
+For the lightweight PyPI installation:
+
+```bash
+uv tool install mermaid-render
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+```python
+from mermaid_render import convert
+
+source = """flowchart LR
+  A[Input] --> B{Valid?}
+  B -->|Yes| C[Process]
+  B -->|No| D[Reject]
+"""
+
+convert(source, "diagram.svg")
+convert(source, "diagram.png", scale=2, background="transparent")
+convert(source, "diagram.pdf")
+convert(source, "diagram.vsdx")
+```
+
+Visio VSDX generation creates editable flowchart shapes and *native connection relationships*, not generic disconnected SVG paths. Only flowcharts currently support connected VSDX export; other Mermaid diagram types can be exported as SVG, PNG or PDF. Connection behavior after editing/moving nodes in desktop Visio is not yet independently verified.
+
+## Output formats
+
+`mermaid-render` infers the format from the output extension; use `-f/--format`
+to choose explicitly (`svg`, `png`, `pdf`, `visio`/`vsdx`). The API returns
+bytes and optionally writes the output file:
+
+```bash
+mermaid-render diagram.mmd -o diagram.svg
+mermaid-render diagram.mmd -o diagram.png --scale 2 --background transparent
+mermaid-render diagram.mmd -o diagram.pdf --background white
+mermaid-render diagram.mmd -o diagram.vsdx
+```
+
+- **SVG:** Original Mermaid-generated SVG markup, without rasterization.
+- **PNG:** Chromium screenshot at the Mermaid SVG viewBox size. `--scale 2`
+  doubles pixel dimensions (96 to 192 pixels per CSS inch). `--background`
+  accepts a CSS color or `transparent`.
+- **PDF:** Chromium print-to-PDF with a tight single diagram-sized page, zero
+  margins, and vector SVG content where supported. The `--scale` option applies
+  only to PNG. PDF transparency is not guaranteed by Chromium; use SVG or PNG
+  when an alpha channel is needed.
+- **VSDX:** Native Visio shapes and connection relationships for Mermaid flowcharts.
+  Other Mermaid types deliberately fail rather than writing disconnected shapes.
+
+All four formats use the *same official Mermaid.js runtime in headless Chromium*.
+No Node.js process or installed system browser is used by the offline wheels.
+
+## Development using uv
+
+```bash
+uv sync
+uv run pytest -q
+uv run mermaid-render examples/example.mmd --format png -o diagram.png
+```
+
+`uv sync` creates a `.venv` from the committed lockfile. Rendering and browser tests automatically prepare missing runtime support files. The project uses Hatchling with a PEP 621 `pyproject.toml` and `src/` layout.
+
+Default builds are always lightweight, even if the checkout contains old bundled files:
+
+```bash
+uv build --out-dir dist/pypi
+uv run python scripts/check_lightweight_dist.py dist/pypi
+```
+
+### Local platform-specific wheel build
+
+On a machine with internet access, with the same OS/architecture as your intended wheel:
+
+```bash
+uv sync
+uv run python scripts/build_platform_wheel.py --outdir dist/bundled
+uv run python scripts/test_wheel_install.py dist/bundled/*.whl
+```
+
+The platform tag is detected automatically. For Linux, install system browser libraries first (`uv run python -m playwright install-deps chromium`). The script downloads the pinned Mermaid distribution, installs the matching headless shell into temporary staging, writes a relative executable manifest, and builds a platform-specific wheel directly with `uv build` and a Hatchling hook. Staging is removed afterward and the source tree is never populated with runtime assets. The wheel retains native executable permissions and includes upstream license assets distributed in the payload.
+
+**Linux compatibility:** Linux wheels are available through GitHub Releases only. They use the `linux_x86_64` tag and bundle Chromium without vendoring its system libraries. Install compatible browser dependencies on the target system (`python -m playwright install-deps chromium`). The wheel is tested on Ubuntu 24.04 and is not audited for manylinux compatibility.
+
+**macOS caveat:** The wheel tag derives its minimum version from the bundled Mach-O binaries using `otool`; there is no project-defined macOS minimum. CI tests on macOS 15, so older versions are not independently tested. If Gatekeeper imposes restrictions on downloaded unsigned binaries, local signing or organizational policy may be needed.
+
+### Configure PyPI publishing
+
+Commit and push the release changes. Set `project.version` to the intended release version, then push the matching tag, for example:
+
+   ```bash
+   git tag v0.7.0
+   git push origin v0.7.0
+   ```
+
+The workflow also runs builds on pull requests and main-branch pushes, but those runs do not publish to PyPI. If a publish run stops after a partial upload, rerun the failed job: uv checks PyPI and skips identical files already uploaded. Published versions cannot be overwritten; use a new version for changed artifacts.
+
+After the first successful publication, on any supported operating system:
+
+```bash
+uv tool install mermaid-render
+mermaid-render examples/example.mmd -o diagram.vsdx
+```
+
+## Development/project structure
+
+- `src/mermaid_render/api.py` — Python API and SVG/PNG/PDF rendering
+- `src/mermaid_render/assets.py` — bundled lookup and persistent runtime support installation
+- `src/mermaid_render/graph_capture.js` — Mermaid graph semantics and SVG geometry extraction
+- `src/mermaid_render/semantic.py` — connected Visio shapes/edges with Glue formula references
+- `src/mermaid_render/vsdx.py` — geometry-only VSDX exporter for arbitrary SVG
+- `scripts/build_platform_wheel.py` — real platform wheel build with bundled Mermaid/Chromium
+- `hatch_build.py` and `scripts/wheel_platform.py` — native wheel metadata and binary-derived platform tags
+- `scripts/test_wheel_install.py` and `scripts/smoke_offline.py` — clean-venv install, offline SVG/Visio smoke test
+- `.github/workflows/bundled-wheels.yml` — four-platform build/test/release workflow
+
+## License
+
+MIT for the Python port and its source adaptation; see `LICENSE`. Mermaid and Chromium remain third-party projects with their own notices and copyright holders.

mermaid_render-0.7.0/examples/connected_graph.py

@@ -0,0 +1,11 @@
+"""Cross-platform experimental native Visio connector example (no COM)."""
+from pathlib import Path
+from mermaid_render import build_connected_vsdx
+
+nodes = [
+    {"id": "A", "text": "Input", "x": 20, "y": 30, "width": 120, "height": 55},
+    {"id": "B", "text": "Processing", "x": 230, "y": 30, "width": 145, "height": 55},
+    {"id": "C", "text": "Output", "x": 470, "y": 30, "width": 120, "height": 55},
+]
+edges = [{"source": "A", "target": "B"}, {"source": "B", "target": "C"}]
+Path("connected_graph.vsdx").write_bytes(build_connected_vsdx(nodes, edges))

mermaid_render-0.7.0/examples/example.mmd

@@ -0,0 +1,7 @@
+flowchart TD
+    A[Christmas] -->|Get money| B(Go shopping)
+    B --> C{Let me think}
+    C -->|One| D[Laptop]
+    C -->|Two| E[iPhone]
+    C -->|Three| F[Car]
+  

mermaid_render-0.7.0/hatch_build.py

@@ -0,0 +1,31 @@
+"""Write platform wheel metadata directly when a browser is bundled."""
+from __future__ import annotations
+
+import sys
+import os
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        # Default builds remain lightweight even in a populated checkout.
+        staging = os.environ.get('MERMAID_RENDER_BUNDLE_DIR')
+        if not staging:
+            return
+        staging = Path(staging).resolve()
+        browsers = staging / 'browsers'
+        runtime = staging / 'runtime'
+        if not (browsers / 'BROWSER_INFO.json').is_file() or not (runtime / 'VERSION.json').is_file():
+            raise RuntimeError('Bundled build requires complete staged browser and Mermaid assets')
+        sys.path.insert(0, str(Path(self.root) / 'scripts'))
+        try:
+            from wheel_platform import platform_tag
+            tag = platform_tag(browsers)
+        finally:
+            sys.path.pop(0)
+        build_data['pure_python'] = False
+        build_data['tag'] = f'py3-none-{tag}'
+        build_data['force_include'][str(browsers)] = 'mermaid_render/browsers'
+        build_data['force_include'][str(runtime)] = 'mermaid_render/runtime'

mermaid_render-0.7.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "mermaid-render"
+version = "0.7.0"
+description = "Render Mermaid diagrams to SVG, PNG, PDF or connected Visio VSDX"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Python port contributors" }]
+keywords = ["mermaid", "visio", "vsdx", "svg", "png", "pdf", "diagram"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Multimedia :: Graphics :: Graphics Conversion",
+]
+dependencies = ["playwright==1.63.0", "platformdirs>=4,<5", "filelock>=3.16,<4"]
+
+[project.scripts]
+mermaid-render = "mermaid_render.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8,<10"]
+
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mermaid_render"]
+exclude = ["**/browsers/**", "**/runtime/**"]
+
+[tool.hatch.build.targets.wheel.hooks.custom]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["/src/mermaid_render/runtime/**", "/src/mermaid_render/browsers/**"]
+include = ["/src", "/tests", "/examples", "/scripts", "/hatch_build.py", "/.python-version", "/.gitignore"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

mermaid_render-0.7.0/scripts/build_platform_wheel.py

@@ -0,0 +1,70 @@
+"""Build a platform wheel with Mermaid.js + Chromium Headless Shell inside.
+
+Run with `uv run python scripts/build_platform_wheel.py` on
+EACH corresponding native platform. No Node.js, npm, or system Visio required.
+"""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import os
+import tempfile
+from pathlib import Path
+from zipfile import ZipFile
+
+PROJECT = Path(__file__).resolve().parents[1]
+from mermaid_render.assets import find_shell, install_browser
+from mermaid_render.vendor import DEFAULT_VERSION
+
+
+def build(version: str, outdir: Path) -> Path:
+    from mermaid_render.vendor import download_mermaid
+    from wheel_platform import platform_tag as detect_platform_tag
+
+    outdir.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="mermaid-bundle-") as temporary:
+        staging = Path(temporary)
+        runtime = staging / "runtime"
+        browsers = staging / "browsers"
+        print(f"Downloading Mermaid {version}...", flush=True)
+        download_mermaid(runtime, version=version)
+        print("Installing Chromium Headless Shell with Playwright...", flush=True)
+        install_browser(browsers)
+        executable = find_shell(browsers)
+        platform_tag = detect_platform_tag(browsers)
+        relative = executable.relative_to(browsers).as_posix()
+        env = os.environ.copy()
+        env["MERMAID_RENDER_BUNDLE_DIR"] = str(staging)
+        subprocess.run(["uv", "build", "--wheel", "--out-dir", str(outdir)],
+                       cwd=PROJECT, env=env, check=True)
+    wheels = list(outdir.glob(f"mermaid_render-*-py3-none-{platform_tag}.whl"))
+    if len(wheels) != 1:
+        raise RuntimeError(f"Expected exactly one newly built wheel, got: {wheels}")
+    result = wheels[0]
+    with ZipFile(result) as z:
+        names = set(z.namelist())
+        required = {
+            "mermaid_render/runtime/mermaid.esm.min.mjs",
+            "mermaid_render/runtime/VERSION.json",
+            "mermaid_render/runtime/MERMAID_LICENSE.txt",
+            "mermaid_render/browsers/BROWSER_INFO.json",
+            "mermaid_render/browsers/" + relative,
+        }
+        missing = required - names
+        if missing:
+            raise RuntimeError(f"Wheel missing required runtime files: {sorted(missing)}")
+        if z.testzip() is not None:
+            raise RuntimeError("Corrupted output wheel")
+    print(f"Built offline wheel: {result} ({result.stat().st_size / 1024**2:.1f} MiB)")
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--outdir", type=Path, default=PROJECT / "dist")
+    opts = parser.parse_args()
+    build(DEFAULT_VERSION, opts.outdir.resolve())
+
+
+if __name__ == "__main__":
+    main()

mermaid_render-0.7.0/scripts/check_lightweight_dist.py

@@ -0,0 +1,28 @@
+"""Reject runtime payloads or platform wheels in distributions destined for PyPI."""
+import sys
+import tarfile
+from pathlib import Path
+from zipfile import ZipFile
+
+
+def check(directory: Path) -> None:
+    wheels = list(directory.glob('*.whl'))
+    sources = list(directory.glob('*.tar.gz'))
+    if len(wheels) != 1 or len(sources) != 1 or not wheels[0].name.endswith('-py3-none-any.whl'):
+        raise SystemExit('Expected one universal wheel and one source archive')
+    for artifact in wheels + sources:
+        if artifact.stat().st_size > 10 * 1024**2:
+            raise SystemExit(f'Unexpectedly large lightweight distribution: {artifact}')
+        if artifact.suffix == '.whl':
+            with ZipFile(artifact) as archive:
+                names = archive.namelist()
+        else:
+            with tarfile.open(artifact) as archive:
+                names = archive.getnames()
+        if any('/mermaid_render/runtime/' in '/' + name or '/mermaid_render/browsers/' in '/' + name for name in names):
+            raise SystemExit(f'Runtime assets leaked into {artifact}')
+        print(f'{artifact.name}: {artifact.stat().st_size / 1024:.1f} KiB, no runtime payload')
+
+
+if __name__ == '__main__':
+    check(Path(sys.argv[1]))

mermaid_render-0.7.0/scripts/smoke_offline.py

@@ -0,0 +1,52 @@
+"""Run in a clean environment after installing the built wheel.
+
+Only local files are allowed: any external HTTP request is rejected by the
+converter's browser request routing when the bundled Mermaid runtime is present.
+"""
+import importlib.metadata
+import tempfile
+from io import BytesIO
+from pathlib import Path
+from zipfile import ZipFile
+
+from mermaid_render import convert
+import sys
+import mermaid_render.assets as assets
+
+root = Path(importlib.metadata.distribution('mermaid-render').locate_file('mermaid_render'))
+lightweight = '--lightweight' in sys.argv
+support = tempfile.TemporaryDirectory()
+assets.data_root = lambda: Path(support.name) / "support"
+if lightweight:
+    assert not (root / 'browsers' / 'BROWSER_INFO.json').exists()
+    assert not (root / 'runtime' / 'mermaid.esm.min.mjs').exists()
+else:
+    assert assets.bundled_browser() is not None
+    assert (root / 'runtime' / 'mermaid.esm.min.mjs').is_file()
+
+
+def no_download(*args, **kwargs):
+    raise AssertionError('Rendering tried to download already available runtime assets')
+
+
+if not lightweight:
+    assets.download_mermaid = assets.install_browser = no_download
+
+src = 'flowchart LR\n A[Alpha] --> B[Beta]\n B --> C[Gamma]'
+svg = convert(src, format='svg')
+assert b'<svg' in svg
+# The first lightweight render installs missing assets. All later renders must
+# work without any setup downloads, just like a bundled installation.
+assets.download_mermaid = assets.install_browser = no_download
+png = convert(src, format='png', scale=2)
+assert png.startswith(b'\x89PNG\r\n\x1a\n')
+pdf = convert(src, format='pdf')
+assert pdf.startswith(b'%PDF-')
+vsdx = convert(src, format='vsdx')
+with ZipFile(BytesIO(vsdx)) as z:
+    assert z.testzip() is None
+    page = z.read('visio/pages/page1.xml')
+    assert b'<Connects>' in page and b'<Connect ' in page
+print('Offline wheel smoke test passed: SVG, PNG, PDF and connected VSDX.')
+
+support.cleanup()