deckrun 1.4.0 → 1.6.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { readFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { createServer } from "http";
 import { createRequire } from "module";
-import { resolve, dirname, basename, extname } from "path";
+import { resolve, dirname, basename, extname, join, isAbsolute, relative } from "path";
 import { Command } from "commander";
 import open from "open";
 import { parseSlides } from "./parser.js";
@@ -12,6 +12,9 @@ import { DEFAULT_SIZE, DEFAULT_THEME, findFont, findSize, findTheme, fontListing
 import { generateEditorHtml } from "./editor.js";
 import { generatePreviewHtml } from "./preview.js";
 import { findBrowser, renderPdfSerial, PdfError } from "./pdf.js";
+import { DEFAULT_TEMPLATE, DEFAULT_TRANSITION, findTemplate, findTransition, resolveTemplateName, resolveTransitionName, templateListing, transitionListing, } from "./presentation-options.js";
+import { lintMarkdown } from "./lint.js";
+const moduleRequire = createRequire(import.meta.url);
 const c = {
     reset: "\x1b[0m",
     bold: "\x1b[1m",
@@ -23,8 +26,7 @@ const c = {
 };
 function packageVersion() {
     try {
-        const require = createRequire(import.meta.url);
-        return require("../package.json").version;
+        return moduleRequire("../package.json").version;
     }
     catch {
         return "0.0.0";
@@ -135,6 +137,21 @@ function sendJson(res, payload) {
     });
     res.end(JSON.stringify(payload));
 }
+/** Resolve bundled math/diagram assets installed with the npm package. */
+function vendorAsset(pathname) {
+    const name = pathname.replace(/^\/__vendor\/?/, "");
+    if (name === "katex.min.css" || name === "katex.min.js" || name.startsWith("fonts/")) {
+        const katexDist = dirname(moduleRequire.resolve("katex"));
+        const target = resolve(katexDist, name);
+        const fromRoot = relative(katexDist, target);
+        return !isAbsolute(fromRoot) && !fromRoot.startsWith("..") ? target : null;
+    }
+    if (name === "mermaid.min.js") {
+        const mermaidDist = dirname(moduleRequire.resolve("mermaid"));
+        return join(mermaidDist, "mermaid.min.js");
+    }
+    return null;
+}
 /** Decks built from editor content, addressable so a new tab can load them. */
 const decks = new Map();
 let deckSeq = 0;
@@ -168,7 +185,7 @@ function serveStashedDeck(id, res) {
 }
 async function handleEditorRoute(mode, pathname, req, res) {
     if (pathname === "/__preview" && req.method === "GET") {
-        sendHtml(res, generatePreviewHtml(mode.theme, mode.size, mode.fonts));
+        sendHtml(res, generatePreviewHtml(mode.theme, mode.size, mode.fonts, mode.template, mode.transition));
         return true;
     }
     if (pathname === "/__parse" && req.method === "POST") {
@@ -191,13 +208,15 @@ async function handleEditorRoute(mode, pathname, req, res) {
         }
         const theme = resolveThemeName(body.theme);
         const size = resolveSizeName(body.size);
+        const template = resolveTemplateName(body.template);
+        const transition = resolveTransitionName(body.transition);
         const title = deckTitle(slides, body.title?.trim() || "deckrun");
         // A deck built for printing must not open behind a fullscreen prompt.
         const forPrint = body.print === true;
         const path = stashDeck(generateHtml(slides, title, forPrint ? false : mode.fullscreen, theme, size, {
             head: body.head,
             body: body.body,
-        }));
+        }, { template, transition, standalone: body.standalone === true }));
         sendJson(res, { path: forPrint ? `${path}&print=1` : path });
         return true;
     }
@@ -221,8 +240,10 @@ async function handleEditorRoute(mode, pathname, req, res) {
         }
         const theme = resolveThemeName(body.theme);
         const size = resolveSizeName(body.size);
+        const template = resolveTemplateName(body.template);
+        const transition = resolveTransitionName(body.transition);
         const title = deckTitle(slides, body.title?.trim() || "deckrun");
-        const path = stashDeck(generateHtml(slides, title, false, theme, size, { head: body.head, body: body.body }));
+        const path = stashDeck(generateHtml(slides, title, false, theme, size, { head: body.head, body: body.body }, { template, transition }));
         try {
             const pdf = await renderPdfSerial(`${mode.origin}${path}`, browser);
             const filename = safeFilename(body.title?.trim() || title) + ".pdf";
@@ -406,19 +427,63 @@ async function serve(mode, baseDir, port) {
                 else
                     sendHtml(res, mode.kind === "deck"
                         ? mode.html
-                        : generateEditorHtml(mode.theme, mode.size, mode.fonts));
+                        : generateEditorHtml(mode.theme, mode.size, mode.fonts, mode.template, mode.transition));
                 return;
             }
             if (mode.kind === "deck" && mode.remoteDoc && pathname === "/__remote-doc") {
                 sendHtml(res, mode.remoteDoc);
                 return;
             }
+            if (pathname.startsWith("/__vendor/")) {
+                const asset = vendorAsset(pathname);
+                if (!asset) {
+                    res.writeHead(404, { "Content-Type": "text/plain" });
+                    res.end("Not found");
+                    return;
+                }
+                const data = await readFile(asset);
+                res.writeHead(200, {
+                    "Content-Type": getMime(asset),
+                    "Cache-Control": "public, max-age=31536000, immutable",
+                });
+                res.end(data);
+                return;
+            }
+            if (mode.kind === "deck" && pathname === "/__pdf") {
+                const browser = await findBrowser();
+                if (!browser) {
+                    res.writeHead(501, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        error: "no browser",
+                        detail: "No Chrome, Chromium, Edge, or Brave found. Set DECKRUN_BROWSER to one to export PDFs directly.",
+                    }));
+                    return;
+                }
+                try {
+                    const pdf = await renderPdfSerial(`${mode.origin}/`, browser);
+                    const filename = safeFilename(mode.title || "deck") + ".pdf";
+                    res.writeHead(200, {
+                        "Content-Type": "application/pdf",
+                        "Content-Length": pdf.length,
+                        "Content-Disposition": `attachment; filename="${filename}"`,
+                        "Cache-Control": "no-store",
+                    });
+                    res.end(pdf);
+                }
+                catch (err) {
+                    const detail = err instanceof PdfError ? err.message : "rendering failed";
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "render failed", detail }));
+                }
+                return;
+            }
             if (mode.kind === "editor" && (await handleEditorRoute(mode, pathname, req, res))) {
                 return;
             }
             // Everything else comes off disk, relative to the working directory.
             const filePath = resolve(baseDir, pathname.replace(/^\/+/, ""));
-            if (filePath !== baseDir && !filePath.startsWith(baseDir + "/")) {
+            const fromBase = relative(baseDir, filePath);
+            if (isAbsolute(fromBase) || fromBase.startsWith("..")) {
                 res.writeHead(403);
                 res.end("Forbidden");
                 return;
@@ -457,9 +522,13 @@ program
     .option("--size <name>", "Type size: s, m, l, or xl", DEFAULT_SIZE)
     .option("--head-font <name>", "Override the theme's heading face (see --list-fonts)")
     .option("--body-font <name>", "Override the theme's body face (see --list-fonts)")
+    .option("--template <name>", "Composition template (see --list-templates)", DEFAULT_TEMPLATE)
+    .option("--transition <name>", "Slide transition (see --list-transitions)", DEFAULT_TRANSITION)
     .option("--list-themes", "Print every theme and exit")
     .option("--list-sizes", "Print every type size and exit")
     .option("--list-fonts", "Print every font face and exit")
+    .option("--list-templates", "Print every composition template and exit")
+    .option("--list-transitions", "Print every slide transition and exit")
     .action(async (file, opts) => {
     if (opts.listThemes) {
         for (const line of themeListing())
@@ -476,6 +545,16 @@ program
             console.log(line);
         process.exit(0);
     }
+    if (opts.listTemplates) {
+        for (const line of templateListing())
+            console.log(line);
+        process.exit(0);
+    }
+    if (opts.listTransitions) {
+        for (const line of transitionListing())
+            console.log(line);
+        process.exit(0);
+    }
     const named = findTheme(opts.theme);
     if (!named) {
         console.error(`deckrun: unknown theme '${opts.theme}'. Run --list-themes to see them all.`);
@@ -486,6 +565,16 @@ program
         console.error(`deckrun: unknown size '${opts.size}'. Run --list-sizes to see them all.`);
         process.exit(1);
     }
+    const templated = findTemplate(opts.template);
+    if (!templated) {
+        console.error(`deckrun: unknown template '${opts.template}'. Run --list-templates to see them all.`);
+        process.exit(1);
+    }
+    const transitioned = findTransition(opts.transition);
+    if (!transitioned) {
+        console.error(`deckrun: unknown transition '${opts.transition}'. Run --list-transitions to see them all.`);
+        process.exit(1);
+    }
     // Both face flags are optional; unset means the theme keeps its own.
     const fonts = { head: null, body: null };
     for (const [flag, slot] of [
@@ -504,6 +593,8 @@ program
     }
     const theme = named;
     const size = sized;
+    const template = templated;
+    const transition = transitioned;
     const fullscreen = !!opts.fullscreen;
     let mode;
     let baseDir;
@@ -562,8 +653,9 @@ program
             baseDir = process.cwd();
             const defaultName = target.pathname.split("/").filter(Boolean).pop() || target.hostname;
             if (isHtml) {
-                if (opts.size !== DEFAULT_SIZE || opts.headFont || opts.bodyFont) {
-                    console.error(`${c.dim}deckrun: --size, --head-font, and --body-font only apply to Markdown decks; ignored for an HTML doc.${c.reset}`);
+                if (opts.size !== DEFAULT_SIZE || opts.headFont || opts.bodyFont ||
+                    opts.template !== DEFAULT_TEMPLATE || opts.transition !== DEFAULT_TRANSITION) {
+                    console.error(`${c.dim}deckrun: --size, font, template, and transition options only apply to Markdown decks; ignored for an HTML doc.${c.reset}`);
                 }
                 const title = docTitle(rawContent, defaultName);
                 let docHtml = rawContent;
@@ -591,13 +683,13 @@ program
                 const title = deckTitle(slides, defaultName);
                 mode = {
                     kind: "deck",
-                    html: generateHtml(slides, title, fullscreen, theme, size, fonts),
+                    html: generateHtml(slides, title, fullscreen, theme, size, fonts, { template, transition }),
                 };
                 const faces = [
                     fonts.head ? `head ${fontName(fonts.head)}` : "",
                     fonts.body ? `body ${fontName(fonts.body)}` : "",
                 ].filter(Boolean).join(" · ");
-                console.log(`${c.dim}${slides.length} slide${slides.length !== 1 ? "s" : ""} from ${file} · ${THEMES[theme].label} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
+                console.log(`${c.dim}${slides.length} slide${slides.length !== 1 ? "s" : ""} from ${file} · ${THEMES[theme].label} · ${template} · ${transition} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
             }
         }
         else {
@@ -613,8 +705,9 @@ program
                     console.error(`deckrun: cannot read file '${file}'`);
                     process.exit(1);
                 }
-                if (opts.size !== DEFAULT_SIZE || opts.headFont || opts.bodyFont) {
-                    console.error(`${c.dim}deckrun: --size, --head-font, and --body-font only apply to Markdown decks; ignored for an HTML doc.${c.reset}`);
+                if (opts.size !== DEFAULT_SIZE || opts.headFont || opts.bodyFont ||
+                    opts.template !== DEFAULT_TEMPLATE || opts.transition !== DEFAULT_TRANSITION) {
+                    console.error(`${c.dim}deckrun: --size, font, template, and transition options only apply to Markdown decks; ignored for an HTML doc.${c.reset}`);
                 }
                 const title = docTitle(rawHtml, basename(absPath, extname(absPath)));
                 mode = {
@@ -640,33 +733,106 @@ program
                 const title = deckTitle(slides, basename(absPath, extname(absPath)));
                 mode = {
                     kind: "deck",
-                    html: generateHtml(slides, title, fullscreen, theme, size, fonts),
+                    title,
+                    html: generateHtml(slides, title, fullscreen, theme, size, fonts, { template, transition }),
                 };
                 const faces = [
                     fonts.head ? `head ${fontName(fonts.head)}` : "",
                     fonts.body ? `body ${fontName(fonts.body)}` : "",
                 ].filter(Boolean).join(" · ");
-                console.log(`${c.dim}${slides.length} slide${slides.length !== 1 ? "s" : ""} from ${basename(absPath)} · ${THEMES[theme].label} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
+                console.log(`${c.dim}${slides.length} slide${slides.length !== 1 ? "s" : ""} from ${basename(absPath)} · ${THEMES[theme].label} · ${template} · ${transition} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
             }
         }
     }
     else {
         baseDir = process.cwd();
-        mode = { kind: "editor", theme, size, fonts, fullscreen };
+        mode = { kind: "editor", theme, size, fonts, template, transition, fullscreen };
     }
     const port = await findFreePort(parseInt(opts.port, 10));
-    if (mode.kind === "editor")
-        mode.origin = `http://127.0.0.1:${port}`;
+    mode.origin = `http://127.0.0.1:${port}`;
     const url = await serve(mode, baseDir, port);
     const label = mode.kind === "editor" ? "editor" : "present";
     console.log(`${c.bold}${c.magenta}${label}${c.reset} ${c.dim}→${c.reset} ${c.cyan}${c.bold}${url}${c.reset}  ${c.dim}(Ctrl+C to stop)${c.reset}`);
     if (mode.kind === "editor") {
         console.log(`${c.dim}write on the left, live deck on the right. autosaves to your browser.${c.reset}`);
-        console.log(`${c.dim}Cmd/Ctrl+K inserts anything · Cmd/Ctrl+Shift+L switches theme · Cmd/Ctrl+Enter presents${c.reset}`);
+        console.log(`${c.dim}Cmd/Ctrl+K inserts anything · template/theme controls recompose live · Cmd/Ctrl+Enter presents${c.reset}`);
     }
     if (opts.open !== false)
         await open(url);
     // Keep the process alive until interrupted.
     await new Promise(() => { });
 });
+program
+    .command("lint")
+    .description("Check Markdown decks for common authoring and rendering problems")
+    .argument("<files...>", "Markdown files to check; use - to read standard input")
+    .option("--format <format>", "Output format: stylish or json", "stylish")
+    .option("--max-warnings <number>", "Warnings allowed before the command fails", "0")
+    .action((files, opts) => {
+    if (opts.format !== "stylish" && opts.format !== "json") {
+        console.error("deckrun lint: --format must be 'stylish' or 'json'.");
+        process.exitCode = 2;
+        return;
+    }
+    const maxWarnings = Number.parseInt(opts.maxWarnings, 10);
+    if (!Number.isInteger(maxWarnings) || maxWarnings < -1) {
+        console.error("deckrun lint: --max-warnings must be -1 or a non-negative integer.");
+        process.exitCode = 2;
+        return;
+    }
+    const reports = [];
+    for (const file of files) {
+        let markdown;
+        try {
+            markdown = file === "-" ? readFileSync(0, "utf-8") : readFileSync(resolve(process.cwd(), file), "utf-8");
+        }
+        catch {
+            reports.push({
+                file,
+                slides: 0,
+                errors: 1,
+                warnings: 0,
+                issues: [{
+                        rule: "file-read",
+                        severity: "error",
+                        message: "The file could not be read.",
+                        line: 1,
+                        column: 1,
+                    }],
+            });
+            continue;
+        }
+        const result = lintMarkdown(markdown);
+        reports.push({ file, ...result });
+    }
+    const errors = reports.reduce((sum, report) => sum + report.errors, 0);
+    const warnings = reports.reduce((sum, report) => sum + report.warnings, 0);
+    const issueCount = errors + warnings;
+    if (opts.format === "json") {
+        console.log(JSON.stringify({ files: reports, errors, warnings }, null, 2));
+    }
+    else {
+        for (const report of reports) {
+            if (!report.issues.length)
+                continue;
+            console.log(`\n${report.file}`);
+            for (const item of report.issues) {
+                const position = `${item.line}:${item.column}`.padEnd(9);
+                const severity = item.severity.padEnd(7);
+                const slide = item.slide ? `slide ${item.slide} · ` : "";
+                console.log(`  ${position} ${severity} ${slide}${item.message}  ${item.rule}`);
+            }
+        }
+        if (issueCount === 0) {
+            const slides = reports.reduce((sum, report) => sum + report.slides, 0);
+            console.log(`✓ ${files.length} file${files.length === 1 ? "" : "s"}, ${slides} slide${slides === 1 ? "" : "s"}, no problems`);
+        }
+        else {
+            console.log(`\n✖ ${issueCount} problem${issueCount === 1 ? "" : "s"} (${errors} error${errors === 1 ? "" : "s"}, ${warnings} warning${warnings === 1 ? "" : "s"})`);
+        }
+    }
+    if (errors > 0 || (maxWarnings !== -1 && warnings > maxWarnings)) {
+        process.exitCode = 1;
+    }
+});
 program.parse(process.argv);

package/dist/lint.js

@@ -0,0 +1,218 @@
+export function lintMarkdown(markdown) {
+    const issues = [];
+    const trimmed = markdown.trim();
+    if (!trimmed) {
+        issues.push({
+            rule: "empty-deck",
+            severity: "error",
+            message: "The deck is empty.",
+            line: 1,
+            column: 1,
+        });
+        return {
+            slides: 0,
+            errors: 1,
+            warnings: 0,
+            issues,
+        };
+    }
+    const lines = markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    const slides = [];
+    let curSlideLines = [];
+    let curStartLine = 1;
+    let slideIndex = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^[ \t]*---[ \t]*$/.test(line)) {
+            slides.push({
+                slideIndex,
+                startLine: curStartLine,
+                endLine: i,
+                lines: curSlideLines,
+            });
+            slideIndex++;
+            curStartLine = i + 2;
+            curSlideLines = [];
+        }
+        else {
+            curSlideLines.push(line);
+        }
+    }
+    slides.push({
+        slideIndex,
+        startLine: curStartLine,
+        endLine: lines.length,
+        lines: curSlideLines,
+    });
+    // Global & Slide checks
+    let inCodeFence = false;
+    let fenceStartLine = 1;
+    let fenceStartCol = 1;
+    let inDisplayMath = false;
+    let mathStartLine = 1;
+    let mathStartCol = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const lineNum = i + 1;
+        const line = lines[i];
+        // Determine current slide number
+        const currentSlide = slides.find((s) => lineNum >= s.startLine && lineNum <= s.endLine)?.slideIndex ??
+            1;
+        // Check code fences
+        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
+        if (fenceMatch) {
+            if (!inCodeFence) {
+                inCodeFence = true;
+                fenceStartLine = lineNum;
+                fenceStartCol = fenceMatch[1].length + 1;
+                const tag = fenceMatch[3].trim();
+                if (!tag) {
+                    issues.push({
+                        rule: "untagged-code-fence",
+                        severity: "warning",
+                        message: "Code fence has no language tag for syntax highlighting.",
+                        line: lineNum,
+                        column: fenceStartCol,
+                        slide: currentSlide,
+                    });
+                }
+            }
+            else {
+                inCodeFence = false;
+            }
+        }
+        // Check display math
+        if (!inCodeFence) {
+            if (/^\s*\$\$\s*$/.test(line) || /^\s*\\\[\s*$/.test(line)) {
+                if (!inDisplayMath) {
+                    inDisplayMath = true;
+                    mathStartLine = lineNum;
+                    mathStartCol = 1;
+                }
+                else {
+                    inDisplayMath = false;
+                }
+            }
+            else if (line.includes("$$")) {
+                const occurrences = (line.match(/\$\$/g) || []).length;
+                if (occurrences % 2 !== 0) {
+                    inDisplayMath = !inDisplayMath;
+                    if (inDisplayMath) {
+                        mathStartLine = lineNum;
+                        mathStartCol = line.indexOf("$$") + 1;
+                    }
+                }
+            }
+            // Check headings
+            const headingMatch = line.match(/^(\s*#{1,6}\s+)(.*)$/);
+            if (headingMatch && headingMatch[2].length > 80) {
+                issues.push({
+                    rule: "long-heading",
+                    severity: "warning",
+                    message: `Heading is ${headingMatch[2].length} characters long; consider shortening for presentation readability.`,
+                    line: lineNum,
+                    column: headingMatch[1].length + 1,
+                    slide: currentSlide,
+                });
+            }
+            // Check image directives
+            const imgRegex = /!\[([^\]]*)\]\(([^\s)]+)(?:\s+"([^"]*)")?\)/g;
+            let imgMatch;
+            while ((imgMatch = imgRegex.exec(line)) !== null) {
+                const alt = imgMatch[1].trim();
+                const title = imgMatch[3] ?? "";
+                const col = imgMatch.index + 1;
+                if (!alt) {
+                    issues.push({
+                        rule: "missing-image-alt",
+                        severity: "warning",
+                        message: "Image is missing alt text.",
+                        line: lineNum,
+                        column: col,
+                        slide: currentSlide,
+                    });
+                }
+                if (title) {
+                    const opMatch = title.toLowerCase().match(/opacity[=:]?\s*([^\s"]+)/);
+                    if (opMatch) {
+                        const val = parseFloat(opMatch[1]);
+                        if (isNaN(val) || val < 0 || val > 1) {
+                            issues.push({
+                                rule: "invalid-image-opacity",
+                                severity: "warning",
+                                message: `Invalid image opacity '${opMatch[1]}'; expected a number between 0 and 1.`,
+                                line: lineNum,
+                                column: col,
+                                slide: currentSlide,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (inCodeFence) {
+        issues.push({
+            rule: "unclosed-code-fence",
+            severity: "error",
+            message: "Code fence was opened but never closed.",
+            line: fenceStartLine,
+            column: fenceStartCol,
+        });
+    }
+    if (inDisplayMath) {
+        issues.push({
+            rule: "unclosed-math",
+            severity: "error",
+            message: "Display math block was opened but never closed.",
+            line: mathStartLine,
+            column: mathStartCol,
+        });
+    }
+    // Per-slide checks
+    for (const s of slides) {
+        const slideContent = s.lines.join("\n").trim();
+        if (!slideContent) {
+            issues.push({
+                rule: "empty-slide",
+                severity: "warning",
+                message: `Slide ${s.slideIndex} is empty.`,
+                line: s.startLine,
+                column: 1,
+                slide: s.slideIndex,
+            });
+            continue;
+        }
+        // Check bullet density
+        const bullets = s.lines.filter((l) => /^\s*([-*+]|\d+[.)])\s+/.test(l));
+        if (bullets.length > 8) {
+            issues.push({
+                rule: "dense-slide",
+                severity: "warning",
+                message: `Slide ${s.slideIndex} has ${bullets.length} bullets (recommended maximum is 8).`,
+                line: s.startLine,
+                column: 1,
+                slide: s.slideIndex,
+            });
+        }
+        // Check reveal markers
+        const revealCount = (slideContent.match(/\{reveal\}/g) || []).length;
+        if (revealCount > 10) {
+            issues.push({
+                rule: "reveal-excessive",
+                severity: "warning",
+                message: `Slide ${s.slideIndex} has ${revealCount} reveal markers (recommended maximum is 10).`,
+                line: s.startLine,
+                column: 1,
+                slide: s.slideIndex,
+            });
+        }
+    }
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    return {
+        slides: slides.length,
+        errors,
+        warnings,
+        issues,
+    };
+}

package/dist/parser.js

@@ -1,4 +1,89 @@
 import { marked } from "marked";
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/**
+ * Capture TeX before the regular Markdown tokenizer sees it. This keeps
+ * operators such as `*` and `_` inside a formula instead of turning them into
+ * emphasis. The browser can then render these deliberately marked nodes with
+ * KaTeX after fonts and layout styles are available.
+ */
+marked.use({
+    extensions: [
+        {
+            name: "deckrunBlockMath",
+            level: "block",
+            tokenizer(src) {
+                const dollars = /^\$\$[ \t]*\n?([\s\S]+?)\n?[ \t]*\$\$(?:[ \t]*(?:\n|$))/.exec(src);
+                const brackets = /^\\\[[ \t]*\n?([\s\S]+?)\n?[ \t]*\\\](?:[ \t]*(?:\n|$))/.exec(src);
+                const match = dollars ?? brackets;
+                if (!match)
+                    return;
+                return {
+                    type: "deckrunBlockMath",
+                    raw: match[0],
+                    text: match[1].trim(),
+                    display: true,
+                };
+            },
+            renderer(token) {
+                return `<div class="math-source" data-display="true">${escapeHtml(String(token.text))}</div>\n`;
+            },
+        },
+        {
+            name: "deckrunInlineMath",
+            level: "inline",
+            start(src) {
+                const dollar = src.indexOf("$");
+                const paren = src.indexOf("\\(");
+                if (dollar < 0)
+                    return paren < 0 ? undefined : paren;
+                if (paren < 0)
+                    return dollar;
+                return Math.min(dollar, paren);
+            },
+            tokenizer(src) {
+                // A closing dollar followed by a digit is treated as currency rather
+                // than math, so ordinary prose like "$5 and $10" stays untouched.
+                const dollars = /^\$(?!\s|\$)((?:\\.|[^\\$\n])*?[^\\$\s])\$(?!\$|\d)/.exec(src);
+                const parens = /^\\\(((?:\\.|[^\\\n])*?)\\\)/.exec(src);
+                const match = dollars ?? parens;
+                if (!match)
+                    return;
+                return {
+                    type: "deckrunInlineMath",
+                    raw: match[0],
+                    text: match[1],
+                    display: false,
+                };
+            },
+            renderer(token) {
+                return `<span class="math-source" data-display="false">${escapeHtml(String(token.text))}</span>`;
+            },
+        },
+        {
+            name: "deckrunRevealMarker",
+            level: "inline",
+            start(src) {
+                const at = src.indexOf("{reveal}");
+                return at < 0 ? undefined : at;
+            },
+            tokenizer(src) {
+                const match = /^\{reveal\}/.exec(src);
+                if (!match)
+                    return;
+                return { type: "deckrunRevealMarker", raw: match[0] };
+            },
+            renderer() {
+                return '<span class="deckrun-fragment-marker" aria-hidden="true"></span>';
+            },
+        },
+    ],
+});
 function parseImageDirective(title) {
     if (!title)
         return { position: "inline", opacity: 1 };

package/dist/pdf.js

@@ -161,7 +161,11 @@ export async function renderPdf(url, browser) {
         "--mute-audio",
         // Never touch the browser profile the person is actually using.
         `--user-data-dir=${join(dir, "profile")}`,
-        "--virtual-time-budget=5000",
+        // Mermaid performs an asynchronous layout pass after its local script has
+        // loaded. Give that pass room to settle and flush every compositor stage
+        // before Chrome snapshots the pages.
+        "--virtual-time-budget=10000",
+        "--run-all-compositor-stages-before-draw",
         // Header/footer flag names differ across versions; unknown switches are ignored.
         "--no-pdf-header-footer",
         "--print-to-pdf-no-header",