@imontene/mdrender 1.0.0

package/dist/options.js

@@ -0,0 +1,131 @@
+import path from "node:path";
+import { ExitCode } from "./exit-codes.js";
+import { MdRenderError } from "./errors.js";
+import { DEFAULT_LANG } from "./i18n.js";
+export const PAGE_SIZES = ["A3", "A4", "A5", "Letter", "Legal", "Tabloid"];
+export const MERMAID_THEMES = ["default", "neutral", "dark", "forest", "base"];
+export const BUILTIN_THEMES = ["light", "dark"];
+export const DEFAULT_OPTIONS = {
+    pageSize: "A4",
+    margin: "20mm",
+    landscape: false,
+    toc: false,
+    tocDepth: 3,
+    pageNumbers: true,
+    theme: "light",
+    css: [],
+    lang: DEFAULT_LANG,
+};
+export class OptionsError extends MdRenderError {
+    constructor(message) {
+        super(message, ExitCode.Usage);
+    }
+}
+const LENGTH = /^\d+(\.\d+)?(mm|cm|in|px)$/;
+/** Parse a CSS margin shorthand into the four sides, or throw. */
+export function parseMargin(margin) {
+    const parts = margin.trim().split(/\s+/);
+    if (parts.length < 1 || parts.length > 4 || !parts.every((p) => LENGTH.test(p))) {
+        throw new OptionsError(`invalid margin "${margin}": use 1 to 4 lengths in mm, cm, in or px, e.g. "20mm" or "15mm 20mm"`);
+    }
+    const [top, right = top, bottom = top, left = right] = parts;
+    return { top, right, bottom, left };
+}
+const toCamel = (key) => key.replace(/[-_]([a-z])/g, (_m, c) => c.toUpperCase());
+const isString = (v) => typeof v === "string";
+const text = (value, describe) => {
+    if (value instanceof Date)
+        return value.toISOString().slice(0, 10);
+    if (isString(value) || typeof value === "number")
+        return String(value);
+    throw new OptionsError(`${describe} must be text`);
+};
+const bool = (value, describe) => {
+    if (typeof value === "boolean")
+        return value;
+    throw new OptionsError(`${describe} must be true or false`);
+};
+const oneOf = (choices) => (value, describe) => {
+    const match = choices.find((c) => isString(value) && c.toLowerCase() === value.toLowerCase());
+    if (match)
+        return match;
+    throw new OptionsError(`${describe} must be one of: ${choices.join(", ")}`);
+};
+const VALIDATORS = {
+    pageSize: oneOf(PAGE_SIZES),
+    margin: (value, describe) => {
+        const margin = text(value, describe, "");
+        try {
+            parseMargin(margin);
+        }
+        catch (error) {
+            throw new OptionsError(`${describe}: ${error.message}`);
+        }
+        return margin;
+    },
+    landscape: bool,
+    toc: bool,
+    tocDepth: (value, describe) => {
+        const depth = Number(value);
+        if (Number.isInteger(depth) && depth >= 1 && depth <= 6)
+            return depth;
+        throw new OptionsError(`${describe} must be a whole number from 1 to 6`);
+    },
+    pageNumbers: bool,
+    header: text,
+    footer: text,
+    mermaidTheme: oneOf(MERMAID_THEMES),
+    theme: (value, describe, baseDir) => {
+        const theme = text(value, describe, baseDir);
+        const builtin = BUILTIN_THEMES.find((t) => t === theme.toLowerCase());
+        if (builtin)
+            return builtin;
+        if (/\.css$/i.test(theme))
+            return path.resolve(baseDir, theme);
+        throw new OptionsError(`${describe} must be light, dark or a .css file`);
+    },
+    css: (value, describe, baseDir) => {
+        const list = Array.isArray(value) ? value : [value];
+        if (!list.every(isString))
+            throw new OptionsError(`${describe} must be a file path or a list`);
+        return list.map((file) => path.resolve(baseDir, file));
+    },
+    lang: text,
+    title: text,
+    subtitle: text,
+    author: text,
+    date: text,
+};
+/**
+ * Validate options from a config file, front matter or the command line.
+ *
+ * Keys may be camelCase or kebab-case (`page-size`). Unknown keys are ignored so front matter can
+ * hold other metadata. Relative CSS paths resolve against `baseDir`.
+ */
+export function normalizeOptions(raw, source, baseDir, 
+/** How to name a key in error messages (e.g. as a command-line flag). */
+label = (key) => `"${key}"`) {
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value === undefined || value === null)
+            continue;
+        const name = toCamel(key);
+        const validate = VALIDATORS[name];
+        if (!validate)
+            continue;
+        result[name] = validate(value, `${source}: ${label(key)}`, baseDir);
+    }
+    return result;
+}
+/** Merge option layers, later ones winning. CSS lists accumulate instead of replacing. */
+export function mergeOptions(...layers) {
+    const merged = { ...DEFAULT_OPTIONS, css: [] };
+    for (const layer of layers) {
+        const { css, ...rest } = layer;
+        Object.assign(merged, rest);
+        if (css)
+            merged.css.push(...css);
+    }
+    return merged;
+}
+//# sourceMappingURL=options.js.map

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export type OutputFormat = "pdf" | "html";
+export declare function isMarkdownFile(file: string): boolean;

package/dist/paths.js

@@ -0,0 +1,4 @@
+export function isMarkdownFile(file) {
+    return /\.(md|markdown)$/i.test(file);
+}
+//# sourceMappingURL=paths.js.map

package/dist/preview.d.ts

@@ -0,0 +1,22 @@
+import { type RenderSettings } from "./convert.js";
+import { ExitCode } from "./exit-codes.js";
+import { type Io } from "./run.js";
+export interface PreviewOptions {
+    input: string;
+    settings: RenderSettings;
+    io: Io;
+    /** The preview stops when this signal aborts (Ctrl+C in the CLI). */
+    signal: AbortSignal;
+    /** Port to listen on; 0 picks a free one. */
+    port?: number;
+    /** Open the default browser on the preview URL. */
+    open?: boolean;
+    debounceMs?: number;
+}
+/** Open a URL with the system's default browser. */
+export declare function openInBrowser(url: string): void;
+/**
+ * Serve a live HTML preview of a Markdown file on localhost and reload it on every change to
+ * the file, its config file or its stylesheets.
+ */
+export declare function preview(options: PreviewOptions): Promise<ExitCode>;

package/dist/preview.js

@@ -0,0 +1,126 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import path from "node:path";
+import { watch } from "chokidar";
+import { BrowserPool, renderDocument } from "./convert.js";
+import { formatDiagnostic } from "./diagnostics.js";
+import { ExitCode } from "./exit-codes.js";
+import { escapeHtml } from "./html.js";
+import { displayPath, info } from "./run.js";
+/** Reloads the page when the server announces a new render (Server-Sent Events). */
+const LIVE_RELOAD = `<script>
+new EventSource("/events").addEventListener("reload", () => location.reload());
+</script>`;
+function errorPage(message) {
+    return `<!doctype html><html><head><meta charset="utf-8"><title>mdrender</title></head>
+<body style="font-family: system-ui, sans-serif; padding: 2rem; color: #b42318;">
+<h1>mdrender</h1><pre style="white-space: pre-wrap;">${escapeHtml(message)}</pre>
+</body></html>`;
+}
+/** Open a URL with the system's default browser. */
+export function openInBrowser(url) {
+    const [command, args] = process.platform === "win32"
+        ? ["cmd", ["/c", "start", "", url]]
+        : process.platform === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.on("error", () => undefined);
+    child.unref();
+}
+/**
+ * Serve a live HTML preview of a Markdown file on localhost and reload it on every change to
+ * the file, its config file or its stylesheets.
+ */
+export async function preview(options) {
+    const { settings, io, signal } = options;
+    const input = path.resolve(options.input);
+    const browsers = new BrowserPool(settings.browser);
+    const clients = new Set();
+    let page = errorPage("Rendering…");
+    let dependencies = [];
+    const render = async () => {
+        try {
+            const doc = await renderDocument(input, settings, browsers);
+            for (const diagnostic of doc.diagnostics) {
+                io.err(`${formatDiagnostic(diagnostic, displayPath(input))}\n`);
+            }
+            page = doc.html.replace(/<\/body>\s*<\/html>\s*$/, `${LIVE_RELOAD}\n</body>\n</html>\n`);
+            dependencies = doc.dependencies;
+        }
+        catch (error) {
+            // Keep serving: show the problem in the page and retry on the next change.
+            const message = error instanceof Error ? error.message : String(error);
+            io.err(`error: ${message}\n`);
+            page = errorPage(message).replace("</body>", `${LIVE_RELOAD}</body>`);
+        }
+        for (const client of clients)
+            client.write("event: reload\ndata: \n\n");
+    };
+    await render();
+    const server = createServer((request, response) => {
+        if (request.url === "/events") {
+            response.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            response.write(": connected\n\n");
+            clients.add(response);
+            request.on("close", () => clients.delete(response));
+            return;
+        }
+        if (request.url === "/" || request.url?.startsWith("/?")) {
+            response.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-store",
+            });
+            response.end(page);
+            return;
+        }
+        response.writeHead(404).end();
+    });
+    // Only reachable from this machine.
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port ?? 0, "127.0.0.1", () => resolve());
+    });
+    const { port } = server.address();
+    const url = `http://127.0.0.1:${port}/`;
+    io.out(`${url}\n`);
+    info(io, `Preview of ${displayPath(input)} at ${url} (Ctrl+C to stop)\n`);
+    if (options.open)
+        openInBrowser(url);
+    const watcher = watch([input, ...dependencies], {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 },
+    });
+    let timer;
+    let running = Promise.resolve();
+    watcher.on("all", () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            running = running.then(async () => {
+                const before = new Set(dependencies);
+                await render();
+                watcher.add(dependencies.filter((dep) => !before.has(dep)));
+            });
+        }, options.debounceMs ?? 150);
+    });
+    await new Promise((resolve) => {
+        if (signal.aborted)
+            resolve();
+        else
+            signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+    clearTimeout(timer);
+    await running.catch(() => undefined);
+    await watcher.close();
+    for (const client of clients)
+        client.end();
+    server.closeAllConnections();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await browsers.close();
+    return ExitCode.Ok;
+}
+//# sourceMappingURL=preview.js.map

package/dist/render/browser.d.ts

@@ -0,0 +1,48 @@
+import { type Page, type PDFOptions } from "puppeteer-core";
+/**
+ * Whether a failed launch should be retried without Chrome's sandbox. Ubuntu 23.10+ blocks the
+ * sandbox (AppArmor user-namespace restrictions) for browsers not installed from a package,
+ * such as the one `mdrender setup` downloads. The pages mdrender opens run no document
+ * JavaScript and have no network access, so running unsandboxed there is an acceptable
+ * fallback.
+ */
+export declare function shouldRetryWithoutSandbox(error: unknown, args: string[], platform?: NodeJS.Platform): boolean;
+export interface PrintOptions {
+    output: string;
+    format?: PDFOptions["format"];
+    landscape?: boolean;
+    margin?: {
+        top: string;
+        right: string;
+        bottom: string;
+        left: string;
+    };
+    /** Chrome header/footer templates; both omitted means no header or footer. */
+    headerTemplate?: string;
+    footerTemplate?: string;
+    /** Let the page load http(s) resources (remote images, stylesheets). Off by default. */
+    allowRemote?: boolean;
+}
+/** One headless browser shared by every step of a conversion (Mermaid, then PDF). */
+export declare class BrowserSession {
+    private readonly browser;
+    readonly timeout: number;
+    private constructor();
+    static open(executablePath: string, timeout?: number, 
+    /** Told when the browser had to start without its sandbox. */
+    onUnsandboxed?: () => void): Promise<BrowserSession>;
+    /**
+     * A page for trusted code only (our own scripts), with no network access; see `printPdf` for
+     * user content.
+     */
+    newPage(): Promise<Page>;
+    /**
+     * Print a complete HTML document to PDF. Page scripts are disabled: the document is fully
+     * rendered by then (math by KaTeX, diagrams by Mermaid), and any <script> in the Markdown
+     * must not run.
+     */
+    printPdf(html: string, options: PrintOptions): Promise<{
+        blocked: string[];
+    }>;
+    close(): Promise<void>;
+}

package/dist/render/browser.js

@@ -0,0 +1,134 @@
+import { launch } from "puppeteer-core";
+import { RenderError } from "../errors.js";
+const DEFAULT_TIMEOUT = 60_000;
+function launchArgs() {
+    const args = ["--disable-gpu", "--font-render-hinting=none"];
+    // Chromium refuses to start its sandbox as root (common in containers and CI).
+    const isRoot = process.platform !== "win32" && process.getuid?.() === 0;
+    if (isRoot || process.env.MDRENDER_NO_SANDBOX === "1") {
+        args.push("--no-sandbox");
+    }
+    return args;
+}
+/**
+ * Whether a failed launch should be retried without Chrome's sandbox. Ubuntu 23.10+ blocks the
+ * sandbox (AppArmor user-namespace restrictions) for browsers not installed from a package,
+ * such as the one `mdrender setup` downloads. The pages mdrender opens run no document
+ * JavaScript and have no network access, so running unsandboxed there is an acceptable
+ * fallback.
+ */
+export function shouldRetryWithoutSandbox(error, args, platform = process.platform) {
+    return (platform === "linux" &&
+        !args.includes("--no-sandbox") &&
+        /no usable sandbox/i.test(String(error?.message ?? error)));
+}
+/**
+ * Only allow requests the document needs: inline data, plus http(s) when `allowRemote`.
+ * file: URLs are always refused, so HTML in a Markdown file cannot pull local files into
+ * the PDF (local images are embedded beforehand). Returns the URLs that were blocked.
+ */
+async function restrictNetwork(page, allowRemote) {
+    const blocked = [];
+    await page.setRequestInterception(true);
+    page.on("request", (request) => {
+        if (request.isInterceptResolutionHandled())
+            return;
+        const url = request.url();
+        const scheme = url.slice(0, url.indexOf(":")).toLowerCase();
+        if (scheme === "data" || scheme === "about" || scheme === "blob") {
+            void request.continue();
+        }
+        else if (allowRemote && (scheme === "http" || scheme === "https")) {
+            void request.continue();
+        }
+        else {
+            blocked.push(url);
+            void request.abort("blockedbyclient");
+        }
+    });
+    return blocked;
+}
+/** One headless browser shared by every step of a conversion (Mermaid, then PDF). */
+export class BrowserSession {
+    browser;
+    timeout;
+    constructor(browser, timeout) {
+        this.browser = browser;
+        this.timeout = timeout;
+    }
+    static async open(executablePath, timeout = DEFAULT_TIMEOUT, 
+    /** Told when the browser had to start without its sandbox. */
+    onUnsandboxed) {
+        const args = launchArgs();
+        const start = (launchWith) => launch({ executablePath, headless: true, args: launchWith, timeout });
+        try {
+            let browser;
+            try {
+                browser = await start(args);
+            }
+            catch (error) {
+                if (!shouldRetryWithoutSandbox(error, args))
+                    throw error;
+                browser = await start([...args, "--no-sandbox"]);
+                onUnsandboxed?.();
+            }
+            return new BrowserSession(browser, timeout);
+        }
+        catch (error) {
+            throw new RenderError(`could not start the browser at ${executablePath}: ${error.message}`);
+        }
+    }
+    /**
+     * A page for trusted code only (our own scripts), with no network access; see `printPdf` for
+     * user content.
+     */
+    async newPage() {
+        const page = await this.browser.newPage();
+        page.setDefaultTimeout(this.timeout);
+        await restrictNetwork(page, false);
+        return page;
+    }
+    /**
+     * Print a complete HTML document to PDF. Page scripts are disabled: the document is fully
+     * rendered by then (math by KaTeX, diagrams by Mermaid), and any <script> in the Markdown
+     * must not run.
+     */
+    async printPdf(html, options) {
+        const margin = options.margin ?? { top: "20mm", right: "20mm", bottom: "20mm", left: "20mm" };
+        const headerFooter = options.headerTemplate !== undefined || options.footerTemplate !== undefined;
+        const page = await this.browser.newPage();
+        page.setDefaultTimeout(this.timeout);
+        const blocked = await restrictNetwork(page, options.allowRemote ?? false);
+        try {
+            await page.setJavaScriptEnabled(false);
+            await page.setContent(html, { waitUntil: "load" });
+            // Make sure every embedded font has loaded before printing.
+            await page.evaluate("document.fonts.ready.then(() => undefined)");
+            await page.pdf({
+                path: options.output,
+                format: options.format ?? "A4",
+                landscape: options.landscape ?? false,
+                margin,
+                printBackground: true,
+                displayHeaderFooter: headerFooter,
+                headerTemplate: options.headerTemplate ?? "<span></span>",
+                footerTemplate: options.footerTemplate ?? "<span></span>",
+                // PDF bookmarks from the headings, and a tagged (accessible) PDF.
+                outline: true,
+                tagged: true,
+                timeout: this.timeout,
+            });
+            return { blocked: [...new Set(blocked)] };
+        }
+        catch (error) {
+            throw new RenderError(`failed to render PDF: ${error.message}`);
+        }
+        finally {
+            await page.close();
+        }
+    }
+    async close() {
+        await this.browser.close();
+    }
+}
+//# sourceMappingURL=browser.js.map

package/dist/render/fonts.d.ts

@@ -0,0 +1,10 @@
+/** Inter Regular alone, for page headers/footers (Chrome renders them apart from the page). */
+export declare function interRegularFontFace(): string;
+/**
+ * Inline a Fontsource stylesheet: the woff2 source becomes a data URI (the legacy woff fallback is
+ * dropped) so the document needs no network or file access. `font-display: block` makes the
+ * browser wait for the real font instead of printing with a fallback.
+ */
+export declare function inlineFontStylesheet(cssKey: string): string;
+/** @font-face rules for every bundled font, with the font files embedded. */
+export declare function fontFaceCss(): string;

package/dist/render/fonts.js

@@ -0,0 +1,47 @@
+import { INTER_DIR, INTER_FACES, MONO_STYLESHEETS, readAsset, readTextAsset, woff2References, } from "../assets.js";
+/**
+ * Static (non-variable) font files are used on purpose: Chromium embeds variable fonts in PDFs
+ * as Type 3 fonts, while static fonts are embedded as proper TrueType fonts.
+ *
+ * Text: Inter 4 (the typeface served by Google Fonts) from the upstream release, full glyph set.
+ * Code: JetBrains Mono from Fontsource (split into unicode-range subsets).
+ */
+function woff2DataUri(key) {
+    return `data:font/woff2;base64,${readAsset(key).toString("base64")}`;
+}
+function interFace({ weight, style, file }) {
+    return `@font-face {
+  font-family: "Inter";
+  font-style: ${style};
+  font-weight: ${weight};
+  font-display: block;
+  src: url(${woff2DataUri(`${INTER_DIR}/${file}`)}) format("woff2");
+}`;
+}
+let regularFace;
+/** Inter Regular alone, for page headers/footers (Chrome renders them apart from the page). */
+export function interRegularFontFace() {
+    regularFace ??= interFace(INTER_FACES[0]);
+    return regularFace;
+}
+/**
+ * Inline a Fontsource stylesheet: the woff2 source becomes a data URI (the legacy woff fallback is
+ * dropped) so the document needs no network or file access. `font-display: block` makes the
+ * browser wait for the real font instead of printing with a fallback.
+ */
+export function inlineFontStylesheet(cssKey) {
+    const css = readTextAsset(cssKey);
+    const fonts = woff2References(cssKey, css);
+    let index = 0;
+    return css
+        .replace(/font-display:\s*swap/g, "font-display: block")
+        .replace(/,\s*url\([^)]+\.woff\)\s*format\(['"]woff['"]\)/g, "")
+        .replace(/url\((['"]?)([^)'"]+\.woff2)\1\)/g, () => `url(${woff2DataUri(fonts[index++])})`);
+}
+let cached;
+/** @font-face rules for every bundled font, with the font files embedded. */
+export function fontFaceCss() {
+    cached ??= [...INTER_FACES.map(interFace), ...MONO_STYLESHEETS.map(inlineFontStylesheet)].join("\n");
+    return cached;
+}
+//# sourceMappingURL=fonts.js.map

package/dist/render/header-footer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Header/footer text with placeholders, in up to three columns separated by `|`:
+ *
+ *   "{title} | | {page} / {pages}"   → title on the left, page numbers on the right
+ *   "Confidencial"                    → centered
+ *
+ * Placeholders: {page}, {pages}, {title}, {author}, {date}. Use `\|` for a literal bar.
+ */
+export interface HeaderFooterValues {
+    title: string;
+    author?: string;
+    date?: string;
+}
+/**
+ * Chrome header/footer template. Chrome renders it apart from the page, so it carries its own
+ * styles and its own copy of Inter.
+ */
+export declare function headerFooterTemplate(spec: string | undefined, values: HeaderFooterValues, horizontalMargin: {
+    left: string;
+    right: string;
+}): string;
+export declare const DEFAULT_FOOTER = "{page} / {pages}";

package/dist/render/header-footer.js

@@ -0,0 +1,39 @@
+import { escapeHtml } from "../html.js";
+import { interRegularFontFace } from "./fonts.js";
+const CHROME_CLASSES = { page: "pageNumber", pages: "totalPages" };
+function renderText(text, values) {
+    return escapeHtml(text.trim()).replace(/\{(\w+)\}/g, (match, name) => {
+        const chromeClass = CHROME_CLASSES[name];
+        if (chromeClass)
+            return `<span class="${chromeClass}"></span>`;
+        const value = values[name];
+        return value !== undefined ? escapeHtml(value) : match;
+    });
+}
+/** Split on `|` (but not `\|`) into left, center and right columns. */
+function columns(spec) {
+    const parts = spec.split(/(?<!\\)\|/).map((p) => p.replace(/\\\|/g, "|"));
+    if (parts.length === 1)
+        return ["", parts[0], ""];
+    if (parts.length === 2)
+        return [parts[0], "", parts[1]];
+    return [parts[0], parts[1], parts.slice(2).join("|")];
+}
+/**
+ * Chrome header/footer template. Chrome renders it apart from the page, so it carries its own
+ * styles and its own copy of Inter.
+ */
+export function headerFooterTemplate(spec, values, horizontalMargin) {
+    if (!spec)
+        return "<span></span>";
+    const [left, center, right] = columns(spec).map((c) => renderText(c, values));
+    return `<style>${interRegularFontFace()}</style>
+<div style="box-sizing: border-box; width: 100%; display: flex; padding: 0 ${horizontalMargin.right} 0 ${horizontalMargin.left};
+  font-family: Inter, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; font-size: 8pt; color: #59636e;">
+  <span style="flex: 1; text-align: left;">${left}</span>
+  <span style="flex: 1; text-align: center;">${center}</span>
+  <span style="flex: 1; text-align: right;">${right}</span>
+</div>`;
+}
+export const DEFAULT_FOOTER = "{page} / {pages}";
+//# sourceMappingURL=header-footer.js.map

package/dist/render/katex.d.ts

@@ -0,0 +1,2 @@
+/** KaTeX's stylesheet with its woff2 fonts embedded (woff/ttf fallbacks dropped). */
+export declare function katexCss(): string;

package/dist/render/katex.js

@@ -0,0 +1,19 @@
+import { KATEX_CSS, readAsset, readTextAsset, woff2References } from "../assets.js";
+let cached;
+/** KaTeX's stylesheet with its woff2 fonts embedded (woff/ttf fallbacks dropped). */
+export function katexCss() {
+    if (cached)
+        return cached;
+    const css = readTextAsset(KATEX_CSS);
+    const fonts = woff2References(KATEX_CSS, css);
+    let index = 0;
+    cached = css
+        .replace(/,url\([^)]+\.woff\) format\("woff"\)/g, "")
+        .replace(/,url\([^)]+\.ttf\) format\("truetype"\)/g, "")
+        .replace(/url\(([^)]+\.woff2)\)/g, () => {
+        const data = readAsset(fonts[index++]).toString("base64");
+        return `url(data:font/woff2;base64,${data})`;
+    });
+    return cached;
+}
+//# sourceMappingURL=katex.js.map

package/dist/render/mermaid.d.ts

@@ -0,0 +1,25 @@
+import type { Diagnostic } from "../diagnostics.js";
+import type { MermaidBlock } from "../markdown/env.js";
+import type { MermaidTheme } from "../options.js";
+import type { BrowserSession } from "./browser.js";
+export { MERMAID_THEMES, type MermaidTheme } from "../options.js";
+type DiagramResult = {
+    svg: string;
+} | {
+    error: string;
+};
+/**
+ * Render Mermaid diagrams to SVG in a blank page that holds no user content: only the diagram
+ * sources are passed in, as data. Mermaid runs with `securityLevel: "strict"`.
+ */
+export declare function renderMermaid(session: BrowserSession, blocks: MermaidBlock[], theme?: MermaidTheme, 
+/** Width of the text column, so diagrams are laid out at their printed size. */
+widthPx?: number): Promise<DiagramResult[]>;
+/**
+ * Replace the Mermaid placeholders in `html` with rendered SVGs, or with a visible error box.
+ * Returns the new HTML and one error diagnostic per failed diagram.
+ */
+export declare function fillMermaid(html: string, nonce: string, blocks: MermaidBlock[], results: DiagramResult[]): {
+    html: string;
+    diagnostics: Diagnostic[];
+};