@liustack/pagepress 1.0.0 → 3.0.0

package/README.md

@@ -1,19 +1,30 @@
 # PagePress
 
-A CLI toolkit for AI agents to render local HTML files into high-quality PDF documents.
+A CLI toolkit for AI agents to render local Markdown files into high-quality PDF documents.
 
 中文说明请见：[README.zh-CN.md](README.zh-CN.md)
 
 ## Features
 
 - PDF-only command surface (`pagepress`)
-- Local HTML file input only (`.html`)
+- Local Markdown file input only (`.md`)
+- Built-in Markdown templates: `default`, `github`, `magazine`
+- Built-in Mermaid rendering for Markdown code blocks
 - Deterministic output via Playwright + Chromium print engine
 
 ## Installation
 
+Requires Node.js 18+.
+
+Install the CLI globally:
+
 ```bash
 npm install -g @liustack/pagepress
+```
+
+Then install the Chromium browser used for PDF rendering:
+
+```bash
 npx playwright install chromium
 ```
 
@@ -23,17 +34,47 @@ Or run with `npx`:
 npx @liustack/pagepress [options]
 ```
 
+`pagepress` renders PDFs through Playwright + Chromium, so the browser install step is required even if you use `npx`.
+
+Or install as an **Agent Skill** — tell any AI coding tool that supports agent skills (Claude Code, Codex, OpenCode, Cursor, Antigravity, etc.):
+
+```text
+Install the skill from liustack/pagepress
+```
+
+Or use the `skills` CLI directly:
+
+```bash
+npx skills add liustack/pagepress --skill pagepress
+```
+
+To check for updates later:
+
+```bash
+pagepress check-update
+pagepress self-update
+```
+
+If `check-update` cannot reach the registry, it returns `checked: false` and you can continue using the local CLI.
+
 ## Usage
 
 ```bash
-# Local HTML to PDF
-pagepress -i page.html -o output.pdf
+# Markdown to PDF
+pagepress -i document.md -o output.pdf --template default
 ```
 
+## Templates
+
+- `default` - Clean minimalist style
+- `github` - GitHub style
+- `magazine` - magazine layout
+
 ## Options
 
-- `-i, --input <path>` input HTML file path
+- `-i, --input <path>` input Markdown file path
 - `-o, --output <path>` output PDF file path
+- `-t, --template <name>` template for Markdown input (default: `default`)
 - `--wait-until <state>` `load | domcontentloaded | networkidle`
 - `--timeout <ms>` timeout in milliseconds
 - `--safe` disable external network requests and JavaScript execution

package/README.zh-CN.md

@@ -1,17 +1,28 @@
 # PagePress
 
-面向 AI Agent 的 PDF 渲染 CLI，可将本地 HTML 文件输出为高质量 PDF。
+面向 AI Agent 的 PDF 渲染 CLI，可将本地 Markdown 文件输出为高质量 PDF。
 
 ## 特性
 
 - 专注 PDF 输出（仅 `pagepress`）
-- 仅支持本地 HTML 文件输入（`.html`）
+- 仅支持本地 Markdown 文件输入（`.md`）
+- 内置 Markdown 模板：`default`、`github`、`magazine`
+- 支持 Mermaid 代码块渲染
 - 基于 Playwright + Chromium 的稳定打印引擎
 
 ## 安装
 
+需要 Node.js 18+。
+
+全局安装 CLI：
+
 ```bash
 npm install -g @liustack/pagepress
+```
+
+然后安装 PDF 渲染所需的 Chromium 浏览器：
+
+```bash
 npx playwright install chromium
 ```
 
@@ -21,17 +32,47 @@ npx playwright install chromium
 npx @liustack/pagepress [options]
 ```
 
+`pagepress` 基于 Playwright + Chromium 导出 PDF，所以即使使用 `npx`，浏览器安装这一步也仍然需要。
+
+也可以作为 **Agent Skill** 安装，在任何支持 Agent Skill 的 AI 编程工具（Claude Code、Codex、OpenCode、Cursor、Antigravity 等）中输入：
+
+```text
+帮我安装这个 skill：liustack/pagepress
+```
+
+或使用 `skills` CLI 直接安装：
+
+```bash
+npx skills add liustack/pagepress --skill pagepress
+```
+
+后续如需检查或升级版本：
+
+```bash
+pagepress check-update
+pagepress self-update
+```
+
+如果 `check-update` 无法连接 registry，会返回 `checked: false`，此时可继续使用本地 CLI。
+
 ## 用法
 
 ```bash
-# 本地 HTML 转 PDF
-pagepress -i page.html -o output.pdf
+# Markdown 转 PDF
+pagepress -i document.md -o output.pdf --template default
 ```
 
+## 模板
+
+- `default` - 简洁风格
+- `github` - GitHub 风格
+- `magazine` - 杂志排版
+
 ## 参数
 
-- `-i, --input <path>` 输入 HTML 路径
+- `-i, --input <path>` 输入 Markdown 路径
 - `-o, --output <path>` 输出 PDF 路径
+- `-t, --template <name>` Markdown 模板（默认 `default`）
 - `--wait-until <state>` `load | domcontentloaded | networkidle`
 - `--timeout <ms>` 超时时间（毫秒）
 - `--safe` 禁用外部网络请求和 JavaScript 执行

package/dist/main.js

@@ -4,8 +4,76 @@ import { chromium } from "playwright";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
+import { createRequire } from "module";
+import { Renderer, marked } from "marked";
+import matter from "gray-matter";
+import hljs from "highlight.js";
+import { execFile } from "child_process";
+const pdfTemplates = {
+  default: {
+    name: "default",
+    description: "Clean minimalist design",
+    file: "default.html"
+  },
+  github: {
+    name: "github",
+    description: "GitHub-flavored markdown style",
+    file: "github.html"
+  },
+  magazine: {
+    name: "magazine",
+    description: "VOGUE/WIRED premium magazine style",
+    file: "magazine.html"
+  }
+};
+function getTemplate(name) {
+  const template = pdfTemplates[name];
+  if (!template) {
+    throw new Error(`Unknown PDF template: ${name}. Available: ${Object.keys(pdfTemplates).join(", ")}`);
+  }
+  return template;
+}
+const require$2 = createRequire(import.meta.url);
+const MAGAZINE_FONTS = [
+  "@fontsource/bebas-neue/400.css",
+  "@fontsource/cormorant-garamond/400.css",
+  "@fontsource/cormorant-garamond/400-italic.css",
+  "@fontsource/cormorant-garamond/600.css",
+  "@fontsource/inter/300.css",
+  "@fontsource/inter/400.css",
+  "@fontsource/inter/500.css"
+];
+function getFontCSS(template) {
+  if (template !== "magazine") {
+    return "";
+  }
+  const cssChunks = [];
+  for (const fontPath of MAGAZINE_FONTS) {
+    try {
+      const cssFilePath = require$2.resolve(fontPath);
+      let css = fs.readFileSync(cssFilePath, "utf-8");
+      const cssDir = path.dirname(cssFilePath);
+      css = css.replace(/url\(\.\/files\/([^)]+)\)/g, (match, filename) => {
+        const fontFilePath = path.join(cssDir, "files", filename);
+        if (fs.existsSync(fontFilePath)) {
+          const fontData = fs.readFileSync(fontFilePath);
+          const base64 = fontData.toString("base64");
+          const ext = path.extname(filename).slice(1);
+          const mimeType = ext === "woff2" ? "font/woff2" : `font/${ext}`;
+          return `url(data:${mimeType};base64,${base64})`;
+        }
+        return match;
+      });
+      cssChunks.push(css);
+    } catch (e) {
+      console.warn(`Warning: Could not load font ${fontPath}:`, e);
+    }
+  }
+  return cssChunks.join("\n");
+}
 const __filename$1 = fileURLToPath(import.meta.url);
-path.dirname(__filename$1);
+const __dirname$1 = path.dirname(__filename$1);
+const require$1 = createRequire(import.meta.url);
 const WAIT_UNTIL_STATES = /* @__PURE__ */ new Set(["load", "domcontentloaded", "networkidle"]);
 function normalizeWaitUntil(value) {
   if (!value) return "networkidle";
@@ -21,18 +89,88 @@ function normalizeTimeout(value) {
   }
   return value;
 }
+function findTemplatesDir() {
+  const candidates = [
+    // When running from project root (dev/installed)
+    path.resolve(process.cwd(), "src/templates"),
+    // Relative to dist/main.js
+    path.resolve(__dirname$1, "..", "src", "templates"),
+    // Relative to source file location
+    path.resolve(__dirname$1, "templates")
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) return dir;
+  }
+  throw new Error(`Templates directory not found. Searched: ${candidates.join(", ")}`);
+}
 async function render(options) {
+  const template = getTemplate(options.template ?? "default");
   const safeMode = options.safe ?? false;
   const waitUntil = normalizeWaitUntil(options.waitUntil);
   const timeout = normalizeTimeout(options.timeout);
+  const templatesDir = findTemplatesDir();
+  const templatePath = path.join(templatesDir, template.file);
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+  const inputPath = path.resolve(options.input);
   if (options.input.startsWith("http://") || options.input.startsWith("https://")) {
-    throw new Error("Remote URL inputs are not supported. Please provide a local HTML file path.");
+    throw new Error("Remote URL inputs are not supported. Please provide a local Markdown file path.");
   }
-  if (!options.input.endsWith(".html")) {
-    throw new Error(`Unsupported input format: ${options.input}. Only HTML (.html) files are supported.`);
+  if (!options.input.endsWith(".md")) {
+    throw new Error(`Unsupported input format: ${options.input}. Only Markdown (.md) files are supported.`);
   }
-  const inputPath = path.resolve(options.input);
-  const htmlContent = fs.readFileSync(inputPath, "utf-8");
+  const raw = fs.readFileSync(inputPath, "utf-8");
+  const { data: frontmatter, content } = matter(raw);
+  const hasMermaid = /```mermaid/i.test(content);
+  const renderer = new Renderer();
+  renderer.code = function({ text, lang }) {
+    if (lang === "mermaid") {
+      return `<pre class="mermaid">${text}</pre>`;
+    }
+    const highlighted = lang && hljs.getLanguage(lang) ? hljs.highlight(text, { language: lang }).value : hljs.highlightAuto(text).value;
+    const langClass = lang ? `hljs language-${lang}` : "hljs";
+    return `<pre><code class="${langClass}">${highlighted}</code></pre>`;
+  };
+  marked.use({ renderer });
+  const bodyHtml = await marked.parse(content);
+  const title = frontmatter.title || "Document";
+  const isDarkTheme = template.name === "magazine";
+  const hljsLightStyles = `
+<style>
+/* highlight.js GitHub Light Theme */
+.hljs { color: #24292e; }
+.hljs-comment, .hljs-quote { color: #6a737d; font-style: italic; }
+.hljs-keyword, .hljs-selector-tag, .hljs-literal, .hljs-type { color: #d73a49; font-weight: 600; }
+.hljs-string, .hljs-attr, .hljs-symbol, .hljs-bullet, .hljs-addition { color: #032f62; }
+.hljs-number { color: #005cc5; }
+.hljs-title, .hljs-section, .hljs-function .hljs-title { color: #6f42c1; }
+.hljs-built_in, .hljs-name { color: #005cc5; }
+.hljs-class .hljs-title { color: #e36209; }
+.hljs-meta { color: #6f42c1; }
+.hljs-variable, .hljs-template-variable { color: #e36209; }
+.hljs-params { color: #24292e; }
+</style>
+`;
+  const hljsDarkStyles = `
+<style>
+/* highlight.js Dark Theme for Magazine */
+.hljs { color: #e8e8e8; }
+.hljs-comment, .hljs-quote { color: #6b7280; font-style: italic; }
+.hljs-keyword, .hljs-selector-tag, .hljs-literal, .hljs-type { color: #f0abfc; }
+.hljs-string, .hljs-attr, .hljs-symbol, .hljs-bullet, .hljs-addition { color: #86efac; }
+.hljs-number { color: #fcd34d; }
+.hljs-title, .hljs-section, .hljs-function .hljs-title { color: #93c5fd; }
+.hljs-built_in, .hljs-name { color: #93c5fd; }
+.hljs-class .hljs-title { color: #67e8f9; }
+.hljs-meta { color: #f0abfc; }
+.hljs-variable, .hljs-template-variable { color: #fcd34d; }
+.hljs-params { color: #e8e8e8; }
+</style>
+`;
+  const hljsStyles = isDarkTheme ? hljsDarkStyles : hljsLightStyles;
+  let templateHtml = fs.readFileSync(templatePath, "utf-8");
+  const htmlContent = templateHtml.replace(/\{\{title\}\}/g, title).replace(/\{\{body\}\}/g, bodyHtml).replace(/\{\{styles\}\}/g, hljsStyles);
   let browser = null;
   try {
     browser = await chromium.launch({ headless: true });
@@ -49,6 +187,112 @@ async function render(options) {
     const page = await context.newPage();
     await page.goto(pathToFileURL(inputPath).href, { waitUntil: "domcontentloaded", timeout });
     await page.setContent(htmlContent, { waitUntil, timeout });
+    const fontCSS = getFontCSS(template.name);
+    if (fontCSS) {
+      await page.addStyleTag({ content: fontCSS });
+    }
+    if (hasMermaid && !safeMode) {
+      const mermaidPath = require$1.resolve("mermaid/dist/mermaid.min.js");
+      await page.addScriptTag({ path: mermaidPath });
+      const templateName = template.name;
+      await page.evaluate((tpl) => {
+        const defaultTheme = {
+          primaryColor: "#f5f5f7",
+          primaryTextColor: "#1d1d1f",
+          primaryBorderColor: "#d2d2d7",
+          lineColor: "#86868b",
+          secondaryColor: "#f5f5f7",
+          tertiaryColor: "#ffffff",
+          background: "#ffffff",
+          mainBkg: "#f5f5f7",
+          nodeBorder: "#d2d2d7",
+          nodeTextColor: "#1d1d1f",
+          clusterBkg: "rgba(0, 0, 0, 0.02)",
+          clusterBorder: "rgba(0, 0, 0, 0.1)",
+          titleColor: "#1d1d1f"
+        };
+        const githubTheme = {
+          primaryColor: "#f6f8fa",
+          primaryTextColor: "#1f2328",
+          primaryBorderColor: "#d0d7de",
+          lineColor: "#656d76",
+          secondaryColor: "#f6f8fa",
+          tertiaryColor: "#ffffff",
+          background: "#ffffff",
+          mainBkg: "#f6f8fa",
+          nodeBorder: "#d0d7de",
+          nodeTextColor: "#1f2328",
+          clusterBkg: "rgba(208, 215, 222, 0.2)",
+          clusterBorder: "#d0d7de",
+          titleColor: "#1f2328"
+        };
+        const magazineTheme = {
+          primaryColor: "#2a2a2a",
+          primaryTextColor: "#ffffff",
+          primaryBorderColor: "#c41e3a",
+          lineColor: "#666666",
+          secondaryColor: "#1a1a1a",
+          tertiaryColor: "#0f0f0f",
+          background: "#0f0f0f",
+          mainBkg: "#2a2a2a",
+          nodeBorder: "#c41e3a",
+          nodeTextColor: "#ffffff",
+          clusterBkg: "rgba(196, 30, 58, 0.1)",
+          clusterBorder: "rgba(196, 30, 58, 0.4)",
+          titleColor: "#ffffff"
+        };
+        const themes = {
+          default: defaultTheme,
+          github: githubTheme,
+          magazine: magazineTheme
+        };
+        const activeTheme = themes[tpl] || defaultTheme;
+        window.mermaid.initialize({
+          startOnLoad: false,
+          theme: "base",
+          themeVariables: {
+            ...activeTheme,
+            fontFamily: '"SF Mono", "Fira Code", Menlo, monospace',
+            fontSize: "13px"
+          },
+          flowchart: {
+            curve: "basis",
+            nodeSpacing: 40,
+            rankSpacing: 50,
+            htmlLabels: true,
+            useMaxWidth: true,
+            subGraphTitleMargin: { top: 15, bottom: 15 },
+            padding: 20
+          }
+        });
+      }, templateName);
+      await page.evaluate(() => {
+        return window.mermaid.run();
+      });
+      await page.waitForSelector(".mermaid svg", { timeout: 5e3 });
+      await page.waitForTimeout(300);
+      await page.evaluate(() => {
+        document.querySelectorAll(".node rect").forEach((rect) => {
+          rect.setAttribute("rx", "12");
+          rect.setAttribute("ry", "12");
+        });
+        document.querySelectorAll(".cluster rect").forEach((rect) => {
+          rect.setAttribute("rx", "16");
+          rect.setAttribute("ry", "16");
+        });
+        document.querySelectorAll(".cluster-label").forEach((label) => {
+          const transform = label.getAttribute("transform");
+          if (transform) {
+            const match = transform.match(/translate\(([\d.]+),\s*([\d.]+)\)/);
+            if (match) {
+              const x = parseFloat(match[1]);
+              const y = parseFloat(match[2]) + 8;
+              label.setAttribute("transform", `translate(${x}, ${y})`);
+            }
+          }
+        });
+      });
+    }
     await page.waitForTimeout(200);
     const outputPath = path.resolve(options.output);
     await page.pdf({
@@ -60,6 +304,7 @@ async function render(options) {
     return {
       pdfPath: outputPath,
       meta: {
+        template: template.name,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
@@ -69,9 +314,107 @@ async function render(options) {
     }
   }
 }
-const program = new Command();
-program.name("pagepress").description("Render local HTML files to PDF").version("1.0.0").requiredOption("-i, --input <path>", "Input HTML file path").requiredOption("-o, --output <path>", "Output PDF file path").option("--wait-until <state>", "Navigation waitUntil (load, domcontentloaded, networkidle)", "networkidle").option("--timeout <ms>", "Navigation timeout in milliseconds", "30000").option("--safe", "Disable external network requests and JavaScript execution").action(async (options) => {
+const PACKAGE_NAME = "@liustack/pagepress";
+function normalizeVersion(version) {
+  const normalized = version.trim().replace(/^v/i, "").split("-")[0];
+  if (!normalized) {
+    throw new Error(`Invalid version: ${version}`);
+  }
+  return normalized;
+}
+function parseVersion(version) {
+  return normalizeVersion(version).split(".").map((segment) => {
+    const value = Number.parseInt(segment, 10);
+    if (!Number.isFinite(value)) {
+      throw new Error(`Invalid version segment: ${segment}`);
+    }
+    return value;
+  });
+}
+function compareVersions(left, right) {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftValue = leftParts[index] ?? 0;
+    const rightValue = rightParts[index] ?? 0;
+    if (leftValue < rightValue) return -1;
+    if (leftValue > rightValue) return 1;
+  }
+  return 0;
+}
+const runCommand = (command, args) => new Promise((resolve, reject) => {
+  execFile(command, args, { encoding: "utf-8" }, (error, stdout, stderr) => {
+    if (error) {
+      const message = stderr.trim() || error.message;
+      reject(new Error(message));
+      return;
+    }
+    resolve(stdout.trim());
+  });
+});
+const resolvePlaywrightCliPath = () => {
+  const require2 = createRequire(import.meta.url);
+  const playwrightPackagePath = require2.resolve("playwright/package.json");
+  const playwrightPackage = JSON.parse(fs.readFileSync(playwrightPackagePath, "utf-8"));
+  const cliRelativePath = playwrightPackage.bin?.playwright;
+  if (!cliRelativePath) {
+    throw new Error("Unable to resolve Playwright CLI.");
+  }
+  return path.resolve(path.dirname(playwrightPackagePath), cliRelativePath);
+};
+async function checkForUpdate({
+  currentVersion,
+  packageName = PACKAGE_NAME,
+  run = runCommand
+}) {
+  const normalizedCurrentVersion = normalizeVersion(currentVersion);
   try {
+    const latestVersion = normalizeVersion(await run("npm", ["view", packageName, "version"]));
+    return {
+      packageName,
+      currentVersion: normalizedCurrentVersion,
+      latestVersion,
+      updateAvailable: compareVersions(normalizedCurrentVersion, latestVersion) < 0,
+      checked: true
+    };
+  } catch (error) {
+    return {
+      packageName,
+      currentVersion: normalizedCurrentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      checked: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createSelfUpdater(run = runCommand, resolvePlaywrightCli = resolvePlaywrightCliPath) {
+  return async ({
+    currentVersion,
+    packageName = PACKAGE_NAME
+  }) => {
+    const updateInfo = await checkForUpdate({ currentVersion, packageName, run });
+    if (!updateInfo.checked) {
+      throw new Error(`Unable to check for updates: ${updateInfo.error ?? "unknown error"}`);
+    }
+    if (!updateInfo.updateAvailable) {
+      return {
+        ...updateInfo,
+        updated: false
+      };
+    }
+    await run("npm", ["install", "-g", `${packageName}@latest`]);
+    await run(process.execPath, [resolvePlaywrightCli(), "install", "chromium"]);
+    return {
+      ...updateInfo,
+      updated: true
+    };
+  };
+}
+async function runRenderCommand() {
+  const program = new Command();
+  program.name("pagepress").description("Render local Markdown files to PDF").version("3.0.0").requiredOption("-i, --input <path>", "Input Markdown file path").requiredOption("-o, --output <path>", "Output PDF file path").option("-t, --template <name>", "PDF template (default, github, magazine)", "default").option("--wait-until <state>", "Navigation waitUntil (load, domcontentloaded, networkidle)", "networkidle").option("--timeout <ms>", "Navigation timeout in milliseconds", "30000").option("--safe", "Disable external network requests and JavaScript execution").action(async (options) => {
     const timeout = Number.parseInt(options.timeout, 10);
     if (!Number.isFinite(timeout) || timeout < 0) {
       throw new Error("Invalid --timeout value. Use a non-negative integer in milliseconds.");
@@ -79,14 +422,37 @@ program.name("pagepress").description("Render local HTML files to PDF").version(
     const result = await render({
       input: options.input,
       output: options.output,
+      template: options.template,
       waitUntil: options.waitUntil,
       timeout,
       safe: options.safe
     });
     console.log(JSON.stringify(result, null, 2));
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
+  });
+  await program.parseAsync(process.argv);
+}
+async function runCheckUpdateCommand() {
+  const result = await checkForUpdate({ currentVersion: "3.0.0" });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function runSelfUpdateCommand() {
+  const selfUpdate = createSelfUpdater();
+  const result = await selfUpdate({ currentVersion: "3.0.0" });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function main() {
+  const command = process.argv[2];
+  if (command === "check-update") {
+    await runCheckUpdateCommand();
+    return;
   }
+  if (command === "self-update") {
+    await runSelfUpdateCommand();
+    return;
+  }
+  await runRenderCommand();
+}
+main().catch((error) => {
+  console.error("Error:", error instanceof Error ? error.message : error);
+  process.exit(1);
 });
-program.parse();

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@liustack/pagepress",
-  "version": "1.0.0",
-  "description": "CLI tool to render local HTML files into PDF",
+  "version": "3.0.0",
+  "description": "CLI tool to render local Markdown files into polished PDF documents",
   "type": "module",
   "bin": {
     "pagepress": "./dist/main.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "src/templates"
   ],
   "keywords": [
     "pdf",
-    "html-to-pdf",
+    "markdown-to-pdf",
     "pdf-report",
     "cli",
-    "playwright"
+    "playwright",
+    "mermaid"
   ],
   "author": "Leon Liu",
   "license": "MIT",
@@ -30,7 +32,15 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@fontsource/bebas-neue": "^5.2.7",
+    "@fontsource/cormorant-garamond": "^5.2.11",
+    "@fontsource/inter": "^5.2.8",
     "commander": "^13.1.0",
+    "gray-matter": "^4.0.3",
+    "highlight.js": "^11.11.1",
+    "marked": "^15.0.12",
+    "marked-highlight": "^2.2.3",
+    "mermaid": "^11.12.2",
     "playwright": "^1.58.1"
   },
   "devDependencies": {