@imontene/mdrender 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Cambios
 
+## 2.3.0 — 2026-10-16
+
+- **Manrope es la nueva tipografía por defecto** del texto, el encabezado, el pie y los
+  diagramas Mermaid. `--font inter` (o `font: inter`) conserva Inter, la de versiones
+  anteriores. Manrope no tiene cursivas (el navegador inclina la normal) y toma de Inter los
+  símbolos que le faltan (`→`, `✓`, `≤`…).
+
 ## 2.2.0 — 2026-10-15
 
 - **Autoajuste de diagramas de flujo Mermaid** (`flowchart`/`graph`): cada diagrama se dibuja

package/README.md

@@ -2,7 +2,7 @@
 
 **Convierte archivos Markdown (`.md`) en PDF y HTML desde la línea de comandos, en Windows y
 Linux**, con ecuaciones LaTeX, diagramas Mermaid y la tipografía
-[Inter](https://fonts.google.com/specimen/Inter).
+[Manrope](https://fonts.google.com/specimen/Manrope) (o [Inter](https://fonts.google.com/specimen/Inter)).
 
 ```bash
 mdrender informe.md            # → informe.pdf
@@ -15,7 +15,8 @@ Ejemplo: [`examples/ejemplo.md`](examples/ejemplo.md) → [`examples/ejemplo.pdf
 - 📄 **Markdown → PDF o HTML autocontenido** (fuentes, imágenes y diagramas incluidos).
 - ➗ **Ecuaciones** `$…$` y `$$…$$` con KaTeX, dibujadas al convertir (sin JavaScript en la salida).
 - 📊 **Diagramas Mermaid**: flujo, secuencia, clases, estados, ER, Gantt, torta, mapa mental…
-- 🔤 **Inter** para el texto y **JetBrains Mono** para el código, incrustadas en el PDF.
+- 🔤 **Manrope** para el texto (o **Inter** con `--font inter`) y **JetBrains Mono** para el
+  código, incrustadas en el PDF.
 - 🧩 **GFM**: tablas, listas de tareas, tachado, notas al pie, alertas `> [!NOTE]`,
   resaltado de código para ~35 lenguajes.
 - 🖨️ Tamaño de página, márgenes, orientación, encabezado/pie con números de página,
@@ -151,6 +152,7 @@ equipo); `--port` fija el puerto y `--no-open` no abre el navegador.
 | `--header <texto>`             | Encabezado de página (ver abajo)                                     | —                  |
 | `--footer <texto>`             | Pie de página (ver abajo)                                            | `{page} / {pages}` |
 | `--no-page-numbers`            | Sin el pie con números de página                                     | —                  |
+| `--font <manrope\|inter>`      | Tipografía del texto (ver abajo)                                     | `manrope`          |
 | `--density <densidad>`         | `normal` o `compact` (menos espacio entre líneas y bloques)          | `normal`           |
 | `--font-size <tamaño>`         | Tamaño del texto en `pt` o `px`, de 6 a 24 pt; p. ej. `10pt`         | `10.5pt`           |
 | `--theme <light\|dark\|css>`   | `light`, `dark` o un `.css` que reemplaza el tema                    | `light`            |
@@ -175,6 +177,13 @@ equipo); `--port` fija el puerto y `--no-open` no abre el navegador.
 El encabezado y el pie se dibujan dentro de las márgenes superior e inferior: con menos de
 10 mm pueden tocar el texto y mdrender lo advierte.
 
+**Tipografía**: el texto usa [Manrope](https://fonts.google.com/specimen/Manrope);
+`--font inter` (o `font: inter` en el front matter o en `mdrender.config.json`) vuelve a
+[Inter](https://fonts.google.com/specimen/Inter), la tipografía de las versiones anteriores.
+Ambas van incrustadas en el PDF, también en el encabezado, el pie y los diagramas. Manrope no
+tiene cursivas (el navegador inclina la normal) ni algunos símbolos como `→`, `✓` o `≤`, que
+se toman de Inter.
+
 **Aprovechar la página**: `--density compact` reduce interlineado, espacios entre párrafos y
 títulos, y `--font-size 10pt` achica el texto (los diagramas Mermaid siguen el mismo tamaño).
 Juntos ahorran entre un 15 y un 25 % de páginas. Además, siempre:
@@ -318,6 +327,6 @@ cambios: [CHANGELOG.md](CHANGELOG.md).
 
 ## Licencia
 
-[MIT](LICENSE). Inter y JetBrains Mono se distribuyen bajo la
+[MIT](LICENSE). Manrope, Inter y JetBrains Mono se distribuyen bajo la
 [SIL Open Font License 1.1](https://openfontlicense.org); los ejecutables incluyen
 `THIRD-PARTY-NOTICES.txt` con las licencias de todos los componentes.

package/dist/assets/theme.css

@@ -1,7 +1,8 @@
-/* mdrender light theme — Inter for text, JetBrains Mono for code. */
+/* mdrender light theme — Manrope (or Inter) for text, JetBrains Mono for code. */
 
 :root {
-  --font-text: "Inter", system-ui, sans-serif;
+  /* mdrender sets both after the theme for the chosen --font (render/fonts.ts). */
+  --font-text: "Manrope", "Inter", system-ui, sans-serif;
   /* Inter after the mono font covers symbols (arrows, math) missing from the code font. */
   --font-code: "JetBrains Mono", "Inter", ui-monospace, monospace;
   --color-text: #1f2328;

package/dist/assets.d.ts

@@ -31,6 +31,8 @@ export declare const INTER_FACES: readonly [{
     readonly style: "italic";
     readonly file: "Inter-BoldItalic.woff2";
 }];
+/** Manrope faces in use (Fontsource, split into unicode-range subsets); it has no italics. */
+export declare const MANROPE_STYLESHEETS: string[];
 export declare const MONO_STYLESHEETS: string[];
 export declare const KATEX_CSS = "katex/dist/katex.min.css";
 export declare const MERMAID_JS = "mermaid/dist/mermaid.min.js";

package/dist/assets.js

@@ -78,6 +78,12 @@ export const INTER_FACES = [
     { weight: 700, style: "normal", file: "Inter-Bold.woff2" },
     { weight: 700, style: "italic", file: "Inter-BoldItalic.woff2" },
 ];
+/** Manrope faces in use (Fontsource, split into unicode-range subsets); it has no italics. */
+export const MANROPE_STYLESHEETS = [
+    "@fontsource/manrope/400.css",
+    "@fontsource/manrope/600.css",
+    "@fontsource/manrope/700.css",
+];
 export const MONO_STYLESHEETS = [
     "@fontsource/jetbrains-mono/400.css",
     "@fontsource/jetbrains-mono/400-italic.css",
@@ -103,7 +109,7 @@ export function assetManifest() {
     const keys = new Set([PACKAGE_JSON, ...THEMES, MERMAID_JS]);
     for (const { file } of INTER_FACES)
         keys.add(`${INTER_DIR}/${file}`);
-    for (const cssKey of [...MONO_STYLESHEETS, KATEX_CSS]) {
+    for (const cssKey of [...MANROPE_STYLESHEETS, ...MONO_STYLESHEETS, KATEX_CSS]) {
         keys.add(cssKey);
         for (const font of woff2References(cssKey, readTextAsset(cssKey)))
             keys.add(font);

package/dist/cli.js

@@ -25,6 +25,7 @@ const DOCUMENT_FLAGS = [
     "header",
     "footer",
     "pageNumbers",
+    "font",
     "density",
     "fontSize",
     "css",
@@ -57,6 +58,7 @@ function addDocumentOptions(command) {
         .option("--header <text>", 'page header, e.g. "{title} | | {date}"')
         .option("--footer <text>", 'page footer (default: "{page} / {pages}")')
         .option("--no-page-numbers", "no default page-number footer")
+        .option("--font <font>", "text typeface: manrope or inter (default: manrope)")
         .option("--density <density>", "normal or compact (tighter spacing) (default: normal)")
         .option("--font-size <size>", "text size, e.g. 10pt or 11pt (default: 10.5pt)")
         .option("--theme <theme>", "light, dark, or a .css file replacing the theme (default: light)")
@@ -77,7 +79,7 @@ function configure(command, io) {
 function buildRenderProgram(io) {
     const program = new Command()
         .name("mdrender")
-        .description("Render Markdown files to PDF (or self-contained HTML) using the Inter typeface.")
+        .description("Render Markdown files to PDF (or self-contained HTML) set in Manrope (or Inter).")
         .version(version, "-V, --version")
         .argument("<inputs...>", "Markdown files, folders or glob patterns (e.g. docs/**/*.md)")
         .option("-o, --output <path>", "output file, or folder for several inputs")

package/dist/convert.js

@@ -12,6 +12,7 @@ import { BrowserSession } from "./render/browser.js";
 import { DEFAULT_FOOTER, headerFooterTemplate } from "./render/header-footer.js";
 import { fillMermaid, renderMermaid } from "./render/mermaid.js";
 import { SMALL_SCALE } from "./render/mermaid-fit.js";
+import { FONT_FAMILIES, fontStack } from "./render/fonts.js";
 import { contentHeightPx, contentWidthPx, lengthToPx } from "./render/page.js";
 import { buildHtmlDocument, builtinThemeCss, densityCss } from "./render/template.js";
 import { writeFileAtomic } from "./write.js";
@@ -82,7 +83,16 @@ export function headerFooterSpaceWarnings(margin, hasHeader, hasFooter) {
 /** Font size, if set, and the page's text height (used to fit images and diagrams). */
 function layoutCss(options, margin) {
     const height = contentHeightPx(options.pageSize, options.orientation === "landscape", margin);
-    const rules = [`:root { --page-content-height: ${height}px; }`];
+    const family = FONT_FAMILIES[options.font];
+    const rules = [
+        `:root { --page-content-height: ${height}px; }`,
+        `:root { --font-text: ${fontStack(options.font)}; ` +
+            `--font-code: "JetBrains Mono", "${family}", "Inter", ui-monospace, monospace; }`,
+    ];
+    // Manrope's glyphs are taller than the headings' 1.25 line height (about 1.37 em). When a
+    // heading is pushed to the next page, Chrome then repeats its text in the PDF bookmark.
+    if (options.font === "manrope")
+        rules.push("h1, h2, h3, h4, h5, h6 { line-height: 1.4; }");
     if (options.fontSize)
         rules.push(`html { font-size: ${options.fontSize}; }`);
     return rules.join("\n");
@@ -158,6 +168,7 @@ paged = false) {
                 : Infinity,
             autofit: options.mermaidAutofit,
             flip: options.mermaidFlip,
+            font: options.font,
         });
         const filled = fillMermaid(body, md.nonce, md.mermaid, results);
         body = filled.html;
@@ -188,6 +199,7 @@ paged = false) {
         date: options.date,
         showTitle: options.title !== undefined,
         themeCss,
+        font: options.font,
         layoutCss: [...densityCss(options.density), layoutCss(options, margin)],
         extraCss,
     });
@@ -218,9 +230,11 @@ export async function convertFile(convert) {
                 landscape: options.orientation === "landscape",
                 margin,
                 headerTemplate: hasHeaderFooter
-                    ? headerFooterTemplate(options.header, values, margin)
+                    ? headerFooterTemplate(options.header, values, margin, options.font)
+                    : undefined,
+                footerTemplate: hasHeaderFooter
+                    ? headerFooterTemplate(footer, values, margin, options.font)
                     : undefined,
-                footerTemplate: hasHeaderFooter ? headerFooterTemplate(footer, values, margin) : undefined,
                 allowRemote: convert.allowRemote,
             });
             for (const url of blocked) {

package/dist/doctor.js

@@ -135,8 +135,9 @@ function settingsCheck(options) {
         name: "Settings",
         status: "info",
         detail: `${options.pageSize} ${options.orientation}, margins ${m.top} ${m.right} ${m.bottom} ` +
-            `${m.left} (top right bottom left), ${options.density} density, ` +
-            `${options.fontSize ?? DEFAULT_FONT_SIZE} text, language ${options.lang}, theme ` +
+            `${m.left} (top right bottom left), ${options.font} ` +
+            `${options.fontSize ?? DEFAULT_FONT_SIZE}, ${options.density} density, ` +
+            `language ${options.lang}, theme ` +
             path.basename(options.theme),
     };
 }

package/dist/options.d.ts

@@ -14,6 +14,8 @@ export type MermaidTheme = (typeof MERMAID_THEMES)[number];
 export declare const MERMAID_FLIPS: readonly ["auto", "never"];
 export type MermaidFlip = (typeof MERMAID_FLIPS)[number];
 export declare const BUILTIN_THEMES: readonly ["light", "dark"];
+export declare const TEXT_FONTS: readonly ["manrope", "inter"];
+export type TextFont = (typeof TEXT_FONTS)[number];
 export declare const DENSITIES: readonly ["normal", "compact"];
 export type Density = (typeof DENSITIES)[number];
 /** Rendering options, merged from defaults < config file < front matter < command line. */
@@ -41,6 +43,8 @@ export interface DocumentOptions {
     mermaidAutofit: boolean;
     /** Whether autofit may turn a flowchart to the other axis (LR ↔ TB) when it reads far better. */
     mermaidFlip: MermaidFlip;
+    /** Typeface of the text: Manrope or Inter (code is always JetBrains Mono). */
+    font: TextFont;
     /** Vertical spacing: "compact" tightens line height, paragraph and heading spacing. */
     density: Density;
     /** Base font size of the text, e.g. "10pt"; when unset, the theme's (10.5pt). */

package/dist/options.js

@@ -7,6 +7,7 @@ export const ORIENTATIONS = ["portrait", "landscape"];
 export const MERMAID_THEMES = ["default", "neutral", "dark", "forest", "base"];
 export const MERMAID_FLIPS = ["auto", "never"];
 export const BUILTIN_THEMES = ["light", "dark"];
+export const TEXT_FONTS = ["manrope", "inter"];
 export const DENSITIES = ["normal", "compact"];
 export const DEFAULT_OPTIONS = {
     pageSize: "Letter",
@@ -17,6 +18,7 @@ export const DEFAULT_OPTIONS = {
     pageNumbers: true,
     mermaidAutofit: true,
     mermaidFlip: "auto",
+    font: "manrope",
     density: "normal",
     theme: "light",
     css: [],
@@ -115,6 +117,7 @@ const VALIDATORS = {
     mermaidTheme: oneOf(MERMAID_THEMES),
     mermaidAutofit: bool,
     mermaidFlip: oneOf(MERMAID_FLIPS),
+    font: oneOf(TEXT_FONTS),
     density: oneOf(DENSITIES),
     fontSize,
     theme: (value, describe, baseDir) => {

package/dist/render/fonts.d.ts

@@ -1,10 +1,24 @@
-/** Inter Regular alone, for page headers/footers (Chrome renders them apart from the page). */
-export declare function interRegularFontFace(): string;
+import type { TextFont } from "../options.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: Manrope (default) from Fontsource, or Inter 4 from the upstream release (full glyph
+ * set). Manrope covers Latin, Greek, Cyrillic and Vietnamese but has no italics (the browser
+ * slants it) nor arrows and math symbols such as → ✓ ≤: those fall back to Inter, which is
+ * embedded too in its regular and bold weights.
+ * Code: JetBrains Mono from Fontsource (split into unicode-range subsets).
+ */
+export declare const FONT_FAMILIES: Record<TextFont, string>;
+/** CSS font-family list for the text: the chosen font, Inter for missing glyphs, the system's. */
+export declare function fontStack(font: TextFont): 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;
+/** @font-face rules for every font a document uses, with the font files embedded. */
+export declare function fontFaceCss(font?: TextFont): string;
+/** The text font's regular weight alone, for page headers/footers (rendered apart from the page). */
+export declare function regularFontFace(font?: TextFont): string;

package/dist/render/fonts.js

@@ -1,11 +1,21 @@
-import { INTER_DIR, INTER_FACES, MONO_STYLESHEETS, readAsset, readTextAsset, woff2References, } from "../assets.js";
+import { INTER_DIR, INTER_FACES, MANROPE_STYLESHEETS, 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.
+ * Text: Manrope (default) from Fontsource, or Inter 4 from the upstream release (full glyph
+ * set). Manrope covers Latin, Greek, Cyrillic and Vietnamese but has no italics (the browser
+ * slants it) nor arrows and math symbols such as → ✓ ≤: those fall back to Inter, which is
+ * embedded too in its regular and bold weights.
  * Code: JetBrains Mono from Fontsource (split into unicode-range subsets).
  */
+export const FONT_FAMILIES = { manrope: "Manrope", inter: "Inter" };
+/** CSS font-family list for the text: the chosen font, Inter for missing glyphs, the system's. */
+export function fontStack(font) {
+    return font === "inter"
+        ? `"Inter", system-ui, sans-serif`
+        : `"Manrope", "Inter", system-ui, sans-serif`;
+}
 function woff2DataUri(key) {
     return `data:font/woff2;base64,${readAsset(key).toString("base64")}`;
 }
@@ -18,12 +28,6 @@ function interFace({ weight, style, file }) {
   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
@@ -38,10 +42,39 @@ export function inlineFontStylesheet(cssKey) {
         .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;
+const interUpright = (weight) => INTER_FACES.find((face) => face.weight === weight && face.style === "normal");
+/** @font-face rules for the text font and its fallback, with the font files embedded. */
+function textFaces(font) {
+    if (font === "inter")
+        return INTER_FACES.map(interFace);
+    return [
+        ...MANROPE_STYLESHEETS.map(inlineFontStylesheet),
+        // Fallback for glyphs Manrope lacks; 600 text takes the nearest heavier face, 700.
+        interFace(interUpright(400)),
+        interFace(interUpright(700)),
+    ];
+}
+const cached = new Map();
+/** @font-face rules for every font a document uses, with the font files embedded. */
+export function fontFaceCss(font = "manrope") {
+    let css = cached.get(font);
+    if (css === undefined) {
+        css = [...textFaces(font), ...MONO_STYLESHEETS.map(inlineFontStylesheet)].join("\n");
+        cached.set(font, css);
+    }
+    return css;
+}
+const regularFaces = new Map();
+/** The text font's regular weight alone, for page headers/footers (rendered apart from the page). */
+export function regularFontFace(font = "manrope") {
+    let css = regularFaces.get(font);
+    if (css === undefined) {
+        css =
+            font === "inter"
+                ? interFace(interUpright(400))
+                : [inlineFontStylesheet(MANROPE_STYLESHEETS[0]), interFace(interUpright(400))].join("\n");
+        regularFaces.set(font, css);
+    }
+    return css;
 }
 //# sourceMappingURL=fonts.js.map

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

@@ -1,3 +1,4 @@
+import type { TextFont } from "../options.js";
 /**
  * Header/footer text with placeholders, in up to three columns separated by `|`:
  *
@@ -13,10 +14,10 @@ export interface HeaderFooterValues {
 }
 /**
  * Chrome header/footer template. Chrome renders it apart from the page, so it carries its own
- * styles and its own copy of Inter.
+ * styles and its own copy of the text font.
  */
 export declare function headerFooterTemplate(spec: string | undefined, values: HeaderFooterValues, horizontalMargin: {
     left: string;
     right: string;
-}): string;
+}, font?: TextFont): string;
 export declare const DEFAULT_FOOTER = "{page} / {pages}";

package/dist/render/header-footer.js

@@ -1,5 +1,5 @@
 import { escapeHtml } from "../html.js";
-import { interRegularFontFace } from "./fonts.js";
+import { fontStack, regularFontFace } from "./fonts.js";
 const CHROME_CLASSES = { page: "pageNumber", pages: "totalPages" };
 function renderText(text, values) {
     return escapeHtml(text.trim()).replace(/\{(\w+)\}/g, (match, name) => {
@@ -21,15 +21,15 @@ function columns(spec) {
 }
 /**
  * Chrome header/footer template. Chrome renders it apart from the page, so it carries its own
- * styles and its own copy of Inter.
+ * styles and its own copy of the text font.
  */
-export function headerFooterTemplate(spec, values, horizontalMargin) {
+export function headerFooterTemplate(spec, values, horizontalMargin, font = "manrope") {
     if (!spec)
         return "<span></span>";
     const [left, center, right] = columns(spec).map((c) => renderText(c, values));
-    return `<style>${interRegularFontFace()}</style>
+    return `<style>${regularFontFace(font)}</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;">
+  font-family: ${fontStack(font).replaceAll('"', "'")}; 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>

package/dist/render/mermaid.d.ts

@@ -1,6 +1,6 @@
 import type { Diagnostic } from "../diagnostics.js";
 import type { MermaidBlock } from "../markdown/env.js";
-import type { MermaidFlip, MermaidTheme } from "../options.js";
+import type { MermaidFlip, MermaidTheme, TextFont } from "../options.js";
 import type { BrowserSession } from "./browser.js";
 export { MERMAID_THEMES, type MermaidTheme } from "../options.js";
 /** How autofit laid out a flowchart (see render/mermaid-fit.ts). */
@@ -37,6 +37,8 @@ export interface MermaidRenderOptions {
     /** Search label wrapping widths (and, with `flip`, the other axis) for each flowchart. */
     autofit?: boolean;
     flip?: MermaidFlip;
+    /** Text font of the document, used for diagram labels too. */
+    font?: TextFont;
 }
 /**
  * Room kept for a heading printed together with the diagram below it (see keep-with-heading in

package/dist/render/mermaid.js

@@ -1,6 +1,6 @@
 import { MERMAID_JS, readTextAsset } from "../assets.js";
 import { mermaidPlaceholder } from "../markdown/mermaid.js";
-import { fontFaceCss } from "./fonts.js";
+import { FONT_FAMILIES, fontFaceCss, fontStack } from "./fonts.js";
 import { escapeHtml } from "../html.js";
 import { authorConfigured, candidate, chooseCandidate, flipWorthTrying, flippedDirection, flowchartHeader, withDirection, WRAPPING_WIDTHS, wrapsExhausted, } from "./mermaid-fit.js";
 export { MERMAID_THEMES } from "../options.js";
@@ -14,15 +14,16 @@ const DEFAULT_FONT_PX = 14;
  */
 export const HEADING_ALLOWANCE_EM = 5;
 let mermaidJs;
-function mermaidConfig(theme, fontPx, wrap) {
+function mermaidConfig(theme, font, fontPx, wrap) {
+    const fontFamily = fontStack(font);
     return {
         startOnLoad: false,
         securityLevel: "strict",
         theme,
-        fontFamily: "Inter, sans-serif",
+        fontFamily,
         // Sequence diagrams take their text sizes from here, the others from themeVariables.
         fontSize: fontPx,
-        themeVariables: { fontFamily: "Inter, sans-serif", fontSize: `${fontPx}px` },
+        themeVariables: { fontFamily, fontSize: `${fontPx}px` },
         htmlLabels: true,
         // Actors only at the top of sequence diagrams: repeating them below costs height.
         sequence: { mirrorActors: false },
@@ -35,20 +36,21 @@ function mermaidConfig(theme, fontPx, wrap) {
  * flowcharts are rendered in several layouts and the one whose text prints largest is kept.
  */
 export async function renderMermaid(session, blocks, options = {}) {
-    const { theme = "neutral", widthPx = DEFAULT_WIDTH_PX, fontPx = DEFAULT_FONT_PX, pageHeightPx = Infinity, autofit = true, flip = "auto", } = options;
+    const { theme = "neutral", widthPx = DEFAULT_WIDTH_PX, fontPx = DEFAULT_FONT_PX, pageHeightPx = Infinity, autofit = true, flip = "auto", font = "manrope", } = options;
+    const family = FONT_FAMILIES[font];
     mermaidJs ??= readTextAsset(MERMAID_JS);
     const page = await session.newPage();
     try {
-        await page.setContent(`<!doctype html><html><head><meta charset="utf-8"><style>${fontFaceCss()}
-body { margin: 0; width: ${widthPx}px; font-family: "Inter", sans-serif; }</style>
+        await page.setContent(`<!doctype html><html><head><meta charset="utf-8"><style>${fontFaceCss(font)}
+body { margin: 0; width: ${widthPx}px; font-family: ${fontStack(font)}; }</style>
 </head><body></body></html>`);
         await page.evaluate(mermaidJs);
-        await page.evaluate(async () => {
+        await page.evaluate(async (family) => {
             // Runs in the browser. The project is compiled without DOM types, hence PageGlobals.
             const { document } = globalThis;
             // Load the font weights Mermaid uses before it measures any text.
-            await Promise.all(["400", "600", "700"].map((w) => document.fonts.load(`${w} 16px Inter`)));
-        });
+            await Promise.all(["400", "600", "700"].map((w) => document.fonts.load(`${w} 16px "${family}"`)));
+        }, family);
         const render = (source, id, wrap) => page.evaluate(async (source, id, config) => {
             const { mermaid } = globalThis;
             // Each render sets the whole configuration, so one layout never leaks into the next.
@@ -59,7 +61,7 @@ body { margin: 0; width: ${widthPx}px; font-family: "Inter", sans-serif; }</styl
             catch (error) {
                 return { error: String(error?.message ?? error) };
             }
-        }, source, id, mermaidConfig(theme, fontPx, wrap));
+        }, source, id, mermaidConfig(theme, font, fontPx, wrap));
         const results = [];
         for (const [i, block] of blocks.entries()) {
             const id = `mermaid-${i + 1}`;

package/dist/render/template.d.ts

@@ -1,4 +1,5 @@
 import { escapeHtml } from "../html.js";
+import type { TextFont } from "../options.js";
 export { escapeHtml };
 /** Stylesheets of a built-in theme ("light" or "dark"). */
 export declare function builtinThemeCss(theme: "light" | "dark"): string[];
@@ -17,6 +18,8 @@ export interface DocumentParts {
     showTitle?: boolean;
     /** Theme stylesheet contents. Defaults to the built-in light theme. */
     themeCss?: string[];
+    /** Text font to embed. Defaults to Manrope. */
+    font?: TextFont;
     /** Layout stylesheets (density, font size, page height), applied after the theme. */
     layoutCss?: string[];
     /** Extra stylesheet contents, applied after the theme and layout. */

package/dist/render/template.js

@@ -38,7 +38,7 @@ export function buildHtmlDocument(parts) {
     const { title, body, math = false, lang, author, layoutCss = [], extraCss = [] } = parts;
     const themeCss = parts.themeCss ?? builtinThemeCss("light");
     const styles = [
-        fontFaceCss(),
+        fontFaceCss(parts.font),
         ...(math ? [katexCss()] : []),
         ...themeCss,
         ...layoutCss,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imontene/mdrender",
-  "version": "2.2.0",
-  "description": "Command-line app for Windows and Linux that renders Markdown — with LaTeX equations and Mermaid diagrams — to PDF and HTML using the Inter typeface",
+  "version": "2.3.0",
+  "description": "Command-line app for Windows and Linux that renders Markdown — with LaTeX equations and Mermaid diagrams — to PDF and HTML set in Manrope or Inter",
   "keywords": [
     "markdown",
     "pdf",
@@ -11,6 +11,7 @@
     "latex",
     "cli",
     "inter",
+    "manrope",
     "converter"
   ],
   "homepage": "https://github.com/imontene/MD_reder#readme",
@@ -65,6 +66,7 @@
   },
   "dependencies": {
     "@fontsource/jetbrains-mono": "^5.3.0",
+    "@fontsource/manrope": "^5.3.0",
     "@puppeteer/browsers": "^3.2.3",
     "chokidar": "^5.0.0",
     "commander": "^15.0.0",