deckrun 1.3.0 → 1.6.0

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",

package/dist/presentation-options.js

@@ -0,0 +1,287 @@
+export const DEFAULT_TEMPLATE = "classic";
+export const DEFAULT_TRANSITION = "slide";
+export const TEMPLATE_IDS = [
+    "classic",
+    "minimal",
+    "editorial",
+    "spotlight",
+];
+export const TRANSITION_IDS = [
+    "slide",
+    "fade",
+    "zoom",
+    "lift",
+    "none",
+];
+export const TEMPLATE_SPECS = {
+    classic: {
+        label: "Classic",
+        blurb: "The original balanced deckrun layout",
+    },
+    minimal: {
+        label: "Minimal",
+        blurb: "Quiet surfaces, wider margins, fewer decorative treatments",
+    },
+    editorial: {
+        label: "Editorial",
+        blurb: "Strong rules and magazine-like reading rhythm",
+    },
+    spotlight: {
+        label: "Spotlight",
+        blurb: "Centered, high-impact composition for concise keynote slides",
+    },
+};
+export const TRANSITION_SPECS = {
+    slide: {
+        label: "Slide",
+        blurb: "Horizontal sliding transition between slides",
+    },
+    fade: {
+        label: "Fade",
+        blurb: "Cross-fade between slides",
+    },
+    zoom: {
+        label: "Zoom",
+        blurb: "Scale up and down between slides",
+    },
+    lift: {
+        label: "Lift",
+        blurb: "Vertical rising transition between slides",
+    },
+    none: {
+        label: "None",
+        blurb: "Instant cut between slides",
+    },
+};
+export function findTemplate(input) {
+    if (!input)
+        return null;
+    const key = String(input).trim().toLowerCase();
+    for (const id of TEMPLATE_IDS) {
+        if (id === key)
+            return id;
+        if (TEMPLATE_SPECS[id].label.toLowerCase() === key)
+            return id;
+    }
+    return null;
+}
+export function resolveTemplateName(input) {
+    return findTemplate(input) ?? DEFAULT_TEMPLATE;
+}
+export function templateSummaries() {
+    return TEMPLATE_IDS.map((id) => ({
+        id,
+        label: TEMPLATE_SPECS[id].label,
+        blurb: TEMPLATE_SPECS[id].blurb,
+    }));
+}
+export function templateListing() {
+    const pad = Math.max(...TEMPLATE_IDS.map((id) => id.length));
+    return TEMPLATE_IDS.map((id) => {
+        const s = TEMPLATE_SPECS[id];
+        return `${id.padEnd(pad)}  ${s.label.padEnd(10)}  ${s.blurb}`;
+    });
+}
+export function findTransition(input) {
+    if (!input)
+        return null;
+    const key = String(input).trim().toLowerCase();
+    for (const id of TRANSITION_IDS) {
+        if (id === key)
+            return id;
+        if (TRANSITION_SPECS[id].label.toLowerCase() === key)
+            return id;
+    }
+    return null;
+}
+export function resolveTransitionName(input) {
+    return findTransition(input) ?? DEFAULT_TRANSITION;
+}
+export function transitionSummaries() {
+    return TRANSITION_IDS.map((id) => ({
+        id,
+        label: TRANSITION_SPECS[id].label,
+        blurb: TRANSITION_SPECS[id].blurb,
+    }));
+}
+export function transitionListing() {
+    const pad = Math.max(...TRANSITION_IDS.map((id) => id.length));
+    return TRANSITION_IDS.map((id) => {
+        const s = TRANSITION_SPECS[id];
+        return `${id.padEnd(pad)}  ${s.label.padEnd(8)}  ${s.blurb}`;
+    });
+}
+export const TEMPLATE_CSS = `/* ── Templates ──────────────────────────────────────────────────────────── */
+
+/* Minimal */
+:root[data-template="minimal"] {
+  --slide-pad-x: 10vw;
+  --slide-pad-y: 8vh;
+}
+:root[data-template="minimal"] #backdrop {
+  opacity: 0.15;
+}
+:root[data-template="minimal"] .slide__content h1 {
+  letter-spacing: -0.02em;
+}
+:root[data-template="minimal"] blockquote {
+  border-left-width: 2px;
+  background: transparent;
+}
+:root[data-template="minimal"] pre {
+  border: 1px solid var(--surface0);
+}
+
+/* Editorial */
+:root[data-template="editorial"] {
+  --slide-pad-x: 7vw;
+}
+:root[data-template="editorial"] .slide__content h1 {
+  border-bottom: 3px solid var(--accent);
+  padding-bottom: 0.3em;
+  margin-bottom: 0.6em;
+}
+:root[data-template="editorial"] .slide__content h2 {
+  border-bottom: 1px solid var(--surface1);
+  padding-bottom: 0.2em;
+}
+:root[data-template="editorial"] blockquote {
+  border-left: 4px solid var(--accent);
+  font-style: italic;
+  background: var(--surface0);
+}
+:root[data-template="editorial"] table th {
+  border-bottom: 2px solid var(--accent);
+}
+:root[data-template="editorial"] hr {
+  border: none;
+  border-top: 2px solid var(--surface2);
+  margin: 2em 0;
+}
+
+/* Spotlight */
+:root[data-template="spotlight"] .slide {
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content h1 {
+  font-size: calc(var(--type-display) * 1.15);
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content p {
+  max-width: 80%;
+  margin-left: auto;
+  margin-right: auto;
+}
+:root[data-template="spotlight"] .slide__content ul,
+:root[data-template="spotlight"] .slide__content ol {
+  text-align: left;
+  display: inline-block;
+  margin-left: auto;
+  margin-right: auto;
+}
+:root[data-template="spotlight"] .slide__content blockquote {
+  text-align: center;
+  border-left: none;
+  border-top: 2px solid var(--accent);
+  border-bottom: 2px solid var(--accent);
+  padding: 1em 2em;
+  background: transparent;
+}
+:root[data-template="spotlight"] .slide__content pre {
+  text-align: left;
+}
+`;
+export const TRANSITION_CSS = `/* ── Transitions ────────────────────────────────────────────────────────── */
+
+/* Fade */
+:root[data-transition="fade"] .slide {
+  transition: opacity 0.3s ease;
+  transform: none !important;
+}
+:root[data-transition="fade"] .slide.exit-left,
+:root[data-transition="fade"] .slide.exit-right,
+:root[data-transition="fade"] .slide.enter-from-left,
+:root[data-transition="fade"] .slide.enter-from-right {
+  transform: none !important;
+  opacity: 0;
+}
+:root[data-transition="fade"] .slide.is-active {
+  opacity: 1;
+  transform: none !important;
+}
+
+/* Zoom */
+:root[data-transition="zoom"] .slide {
+  transform: scale(0.92);
+  transition: opacity 0.35s ease, transform 0.35s cubic-bezier(0.4, 0, 0.2, 1);
+}
+:root[data-transition="zoom"] .slide.is-active {
+  transform: scale(1);
+  opacity: 1;
+}
+:root[data-transition="zoom"] .slide.exit-left,
+:root[data-transition="zoom"] .slide.exit-right {
+  transform: scale(1.08);
+  opacity: 0;
+}
+:root[data-transition="zoom"] .slide.enter-from-left,
+:root[data-transition="zoom"] .slide.enter-from-right {
+  transform: scale(0.92);
+  opacity: 0;
+}
+
+/* Lift */
+:root[data-transition="lift"] .slide {
+  transform: translateY(48px);
+  transition: opacity 0.35s ease, transform 0.35s cubic-bezier(0.4, 0, 0.2, 1);
+}
+:root[data-transition="lift"] .slide.is-active {
+  transform: translateY(0);
+  opacity: 1;
+}
+:root[data-transition="lift"] .slide.exit-left,
+:root[data-transition="lift"] .slide.exit-right {
+  transform: translateY(-48px);
+  opacity: 0;
+}
+:root[data-transition="lift"] .slide.enter-from-left,
+:root[data-transition="lift"] .slide.enter-from-right {
+  transform: translateY(48px);
+  opacity: 0;
+}
+
+/* None */
+:root[data-transition="none"] .slide,
+:root[data-transition="none"] .slide.is-active,
+:root[data-transition="none"] .slide.exit-left,
+:root[data-transition="none"] .slide.exit-right,
+:root[data-transition="none"] .slide.enter-from-left,
+:root[data-transition="none"] .slide.enter-from-right {
+  transition: none !important;
+  transform: none !important;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  :root[data-transition] .slide {
+    transition: opacity 0.2s linear !important;
+    transform: none !important;
+  }
+}
+
+@media print {
+  :root[data-transition] .slide {
+    transition: none !important;
+    transform: none !important;
+    opacity: 1 !important;
+  }
+}
+`;