deckrun 1.3.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";
@@ -281,8 +302,8 @@ async function handleEditorRoute(mode, pathname, req, res) {
             res.end(JSON.stringify({ error: "fetch failed", detail: `upstream responded ${upstream.status}` }));
             return true;
         }
-        const html = await upstream.text();
-        if (html.length > MAX_BODY) {
+        const rawContent = await upstream.text();
+        if (rawContent.length > MAX_BODY) {
             res.writeHead(413, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
                 error: "too large",
@@ -290,12 +311,48 @@ async function handleEditorRoute(mode, pathname, req, res) {
             }));
             return true;
         }
-        if (!html.trim()) {
+        if (!rawContent.trim()) {
             res.writeHead(422, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ error: "empty document" }));
             return true;
         }
-        sendJson(res, { html, title: docTitle(html, target.hostname) });
+        const contentType = (upstream.headers.get("content-type") ?? "").toLowerCase();
+        const pathname = target.pathname.toLowerCase();
+        let isHtml = false;
+        if (pathname.endsWith(".html") || pathname.endsWith(".htm")) {
+            isHtml = true;
+        }
+        else if (pathname.endsWith(".md") || pathname.endsWith(".markdown")) {
+            isHtml = false;
+        }
+        else if (contentType.includes("text/html") ||
+            contentType.includes("application/xhtml+xml")) {
+            isHtml = true;
+        }
+        else if (contentType.includes("text/markdown") ||
+            contentType.includes("text/x-markdown") ||
+            contentType.includes("text/plain")) {
+            isHtml = false;
+        }
+        else if (/<!doctype\s+html/i.test(rawContent) || /<html[\s>]/i.test(rawContent)) {
+            isHtml = true;
+        }
+        const defaultName = target.pathname.split("/").filter(Boolean).pop() || target.hostname;
+        let title;
+        if (isHtml) {
+            title = docTitle(rawContent, defaultName);
+        }
+        else {
+            const slides = parseSlides(rawContent);
+            title = deckTitle(slides, defaultName);
+        }
+        sendJson(res, {
+            kind: isHtml ? "html" : "markdown",
+            content: rawContent,
+            html: isHtml ? rawContent : undefined,
+            markdown: !isHtml ? rawContent : undefined,
+            title,
+        });
         return true;
     }
     if (pathname === "/__present-doc" && req.method === "POST") {
@@ -370,7 +427,54 @@ 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))) {
@@ -378,7 +482,8 @@ async function serve(mode, baseDir, port) {
             }
             // 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;
@@ -407,9 +512,9 @@ async function serve(mode, baseDir, port) {
 const program = new Command();
 program
     .name("deckrun")
-    .description("Present a Markdown file in the browser. Run without a file to write one in the built-in editor.")
+    .description("Present a Markdown file, HTML file, or public URL in the browser. Run without a file or URL to write in the built-in editor.")
     .version(packageVersion(), "-v, --version", "Print the version number")
-    .argument("[file]", "Markdown file to present. Omit it to open the editor.")
+    .argument("[file]", "Markdown file, HTML file, or public URL to present. Omit it to open the editor.")
     .option("-p, --port <number>", "Port to serve on", "7890")
     .option("--no-open", "Do not automatically open the browser")
     .option("--fullscreen", "Auto-enter fullscreen on first interaction")
@@ -417,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())
@@ -436,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.`);
@@ -446,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 [
@@ -464,75 +593,246 @@ program
     }
     const theme = named;
     const size = sized;
+    const template = templated;
+    const transition = transitioned;
     const fullscreen = !!opts.fullscreen;
     let mode;
     let baseDir;
     if (file) {
-        const absPath = resolve(process.cwd(), file);
-        baseDir = dirname(absPath);
-        const ext = extname(absPath).toLowerCase();
-        if (ext === ".html" || ext === ".htm") {
-            let rawHtml;
+        if (/^https?:\/\//i.test(file)) {
+            let target;
             try {
-                rawHtml = readFileSync(absPath, "utf-8");
+                target = new URL(file);
             }
             catch {
-                console.error(`deckrun: cannot read file '${file}'`);
+                console.error(`deckrun: invalid URL '${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}`);
-            }
-            const title = docTitle(rawHtml, basename(absPath, extname(absPath)));
-            mode = {
-                kind: "deck",
-                html: generateDocHtml(`/${basename(absPath)}`, title, fullscreen, theme),
-            };
-            console.log(`${c.dim}presenting ${basename(absPath)} · ${THEMES[theme].label}${c.reset}`);
-        }
-        else {
-            let markdown;
+            let upstream;
             try {
-                markdown = readFileSync(absPath, "utf-8");
+                upstream = await fetch(target, {
+                    redirect: "follow",
+                    signal: AbortSignal.timeout(15_000),
+                    headers: { "User-Agent": "deckrun" },
+                });
             }
-            catch {
-                console.error(`deckrun: cannot read file '${file}'`);
+            catch (err) {
+                console.error(`deckrun: cannot fetch '${file}': ${err instanceof Error ? err.message : "network error"}`);
+                process.exit(1);
+            }
+            if (!upstream.ok) {
+                console.error(`deckrun: fetch failed for '${file}' (HTTP ${upstream.status})`);
                 process.exit(1);
             }
-            const slides = parseSlides(markdown);
-            if (slides.length === 0) {
-                console.error("deckrun: no slides found in the file.");
+            const rawContent = await upstream.text();
+            if (!rawContent.trim()) {
+                console.error(`deckrun: empty document fetched from '${file}'`);
                 process.exit(1);
             }
-            const title = deckTitle(slides, basename(absPath, extname(absPath)));
-            mode = {
-                kind: "deck",
-                html: generateHtml(slides, title, fullscreen, theme, size, fonts),
-            };
-            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}`);
+            const contentType = (upstream.headers.get("content-type") ?? "").toLowerCase();
+            const pathname = target.pathname.toLowerCase();
+            let isHtml = false;
+            if (pathname.endsWith(".html") || pathname.endsWith(".htm")) {
+                isHtml = true;
+            }
+            else if (pathname.endsWith(".md") || pathname.endsWith(".markdown")) {
+                isHtml = false;
+            }
+            else if (contentType.includes("text/html") ||
+                contentType.includes("application/xhtml+xml")) {
+                isHtml = true;
+            }
+            else if (contentType.includes("text/markdown") ||
+                contentType.includes("text/x-markdown") ||
+                contentType.includes("text/plain")) {
+                isHtml = false;
+            }
+            else if (/<!doctype\s+html/i.test(rawContent) || /<html[\s>]/i.test(rawContent)) {
+                isHtml = true;
+            }
+            baseDir = process.cwd();
+            const defaultName = target.pathname.split("/").filter(Boolean).pop() || target.hostname;
+            if (isHtml) {
+                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;
+                if (!/<base\s/i.test(docHtml)) {
+                    if (/<head[^>]*>/i.test(docHtml)) {
+                        docHtml = docHtml.replace(/<head[^>]*>/i, (m) => `${m}\n  <base href="${target.href}">`);
+                    }
+                    else {
+                        docHtml = `<base href="${target.href}">\n` + docHtml;
+                    }
+                }
+                mode = {
+                    kind: "deck",
+                    html: generateDocHtml("/__remote-doc", title, fullscreen, theme),
+                    remoteDoc: docHtml,
+                };
+                console.log(`${c.dim}presenting ${file} · ${THEMES[theme].label}${c.reset}`);
+            }
+            else {
+                const slides = parseSlides(rawContent);
+                if (slides.length === 0) {
+                    console.error("deckrun: no slides found in the fetched content.");
+                    process.exit(1);
+                }
+                const title = deckTitle(slides, defaultName);
+                mode = {
+                    kind: "deck",
+                    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} · ${template} · ${transition} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
+            }
+        }
+        else {
+            const absPath = resolve(process.cwd(), file);
+            baseDir = dirname(absPath);
+            const ext = extname(absPath).toLowerCase();
+            if (ext === ".html" || ext === ".htm") {
+                let rawHtml;
+                try {
+                    rawHtml = readFileSync(absPath, "utf-8");
+                }
+                catch {
+                    console.error(`deckrun: cannot read file '${file}'`);
+                    process.exit(1);
+                }
+                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 = {
+                    kind: "deck",
+                    html: generateDocHtml(`/${basename(absPath)}`, title, fullscreen, theme),
+                };
+                console.log(`${c.dim}presenting ${basename(absPath)} · ${THEMES[theme].label}${c.reset}`);
+            }
+            else {
+                let markdown;
+                try {
+                    markdown = readFileSync(absPath, "utf-8");
+                }
+                catch {
+                    console.error(`deckrun: cannot read file '${file}'`);
+                    process.exit(1);
+                }
+                const slides = parseSlides(markdown);
+                if (slides.length === 0) {
+                    console.error("deckrun: no slides found in the file.");
+                    process.exit(1);
+                }
+                const title = deckTitle(slides, basename(absPath, extname(absPath)));
+                mode = {
+                    kind: "deck",
+                    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} · ${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);