@open-nav/invoicing 0.1.0

package/src/pdf.ts

@@ -0,0 +1,302 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { InvoiceData } from '@open-nav/core';
+import { renderInvoiceHtml } from './html.js';
+import { renderInvoicePdfNative, type NativePdfOptions } from './pdf-native.js';
+
+/**
+ * PDF output, by either of two engines.
+ *
+ * `native` is the default and needs nothing installed: pdfmake lays the
+ * document out and pdfkit writes the PDF, using the Roboto files pdfmake
+ * bundles. Roboto covers Latin Extended-A, so `ő` and `ű` embed correctly —
+ * which was the whole difficulty, since the PDF core fonts cannot represent
+ * them and a font therefore has to be embedded.
+ *
+ * `browser` renders the HTML document and converts it with Chrome, Chromium
+ * or Edge. It follows the HTML exactly, at the cost of needing a browser.
+ *
+ * They are two layouts, not one: the native engine follows the same theme but
+ * builds the page from pdfmake's document model rather than CSS, so the two
+ * will not match pixel for pixel.
+ */
+
+export class PdfConversionError extends Error {}
+
+export interface PdfOptions extends NativePdfOptions {
+  /**
+   * Which engine to use.
+   *
+   * `native` (the default) needs nothing installed. `browser` follows the
+   * HTML document exactly but requires Chrome, Chromium or Edge.
+   */
+  engine?: 'native' | 'browser';
+  /** Browser executable. Auto-detected when omitted. `browser` engine only. */
+  browserPath?: string;
+  /** Extra arguments passed to the browser. */
+  browserArgs?: string[];
+  /**
+   * Run the browser with its sandbox. On by default.
+   *
+   * The sandbox is what contains a malicious document, and invoice data is
+   * input. It is left on even though that means conversion fails when running
+   * as root — in a container or CI, pass `sandbox: false` deliberately. The
+   * error message says so, rather than quietly weakening the default for
+   * everybody.
+   */
+  sandbox?: boolean;
+  /** Give up after this long. Defaults to 30 000 ms. */
+  timeoutMs?: number;
+  /** Environment consulted when detecting a browser. Injectable for tests. */
+  env?: Record<string, string | undefined>;
+  /**
+   * Absolute locations probed when detecting a browser, in place of the usual
+   * install paths. Injectable for tests: those paths are the host's, so
+   * without this a test cannot describe a machine that has no browser.
+   */
+  searchPaths?: readonly string[];
+  /**
+   * Convert HTML to PDF yourself, instead of spawning a browser.
+   *
+   * ```ts
+   * import { chromium } from 'playwright';
+   * const convert = async (html: string) => {
+   *   const browser = await chromium.launch();
+   *   const page = await browser.newPage();
+   *   await page.setContent(html, { waitUntil: 'load' });
+   *   const pdf = await page.pdf({ printBackground: true });
+   *   await browser.close();
+   *   return pdf;
+   * };
+   * ```
+   */
+  convert?: (html: string) => Promise<Buffer>;
+}
+
+/**
+ * Render an invoice straight to PDF bytes.
+ *
+ * Uses the native engine unless `engine: 'browser'` is asked for, or a
+ * `convert` function is supplied — passing a converter is itself a request to
+ * go through HTML.
+ */
+export async function renderInvoicePdf(
+  document: InvoiceData,
+  options: PdfOptions = {},
+): Promise<Buffer> {
+  const engine = options.engine ?? (options.convert || options.browserPath ? 'browser' : 'native');
+  if (engine === 'native') return renderInvoicePdfNative(document, options);
+  return htmlToPdf(renderInvoiceHtml(document, options), options);
+}
+
+/** Convert a rendered document to PDF bytes. */
+export async function htmlToPdf(html: string, options: PdfOptions = {}): Promise<Buffer> {
+  if (options.convert) return options.convert(html);
+
+  const browser = options.browserPath ?? findBrowser(options.env, options.searchPaths);
+  if (!browser) {
+    throw new PdfConversionError(
+      'No browser found to convert the document to PDF.\n' +
+        'Install Chrome, Chromium or Edge, or set one of OPEN_NAV_BROWSER, ' +
+        'CHROME_PATH or PUPPETEER_EXECUTABLE_PATH, or pass browserPath, ' +
+        'or supply your own convert() — see PdfOptions.',
+    );
+  }
+  return spawnConversion(html, browser, options);
+}
+
+async function spawnConversion(
+  html: string,
+  browser: string,
+  options: PdfOptions,
+): Promise<Buffer> {
+  const workDir = mkdtempSync(join(tmpdir(), 'open-nav-pdf-'));
+  const inputPath = join(workDir, 'invoice.html');
+  const outputPath = join(workDir, 'invoice.pdf');
+
+  try {
+    writeFileSync(inputPath, html, 'utf8');
+
+    const args = [
+      '--headless',
+      '--disable-gpu',
+      '--no-pdf-header-footer',
+      // Its own profile, so concurrent conversions do not fight over one.
+      `--user-data-dir=${join(workDir, 'profile')}`,
+      ...(options.sandbox === false ? ['--no-sandbox'] : []),
+      ...(options.browserArgs ?? []),
+      `--print-to-pdf=${outputPath}`,
+      `file://${inputPath}`,
+    ];
+
+    const { code, stderr } = await run(browser, args, options.timeoutMs ?? 30_000);
+
+    if (!existsSync(outputPath)) {
+      throw new PdfConversionError(explainFailure(browser, code, stderr, options));
+    }
+    const pdf = readFileSync(outputPath);
+    if (!pdf.subarray(0, 5).equals(Buffer.from('%PDF-'))) {
+      throw new PdfConversionError(
+        `${browser} produced ${pdf.length} bytes that are not a PDF.\n${stderr.trim()}`,
+      );
+    }
+    return pdf;
+  } finally {
+    rmSync(workDir, { recursive: true, force: true });
+  }
+}
+
+/** Turn a browser failure into something the caller can act on. */
+function explainFailure(
+  browser: string,
+  code: number | null,
+  stderr: string,
+  options: PdfOptions,
+): string {
+  if (/without --no-sandbox is not supported/i.test(stderr)) {
+    return (
+      `${browser} refuses to run as root with its sandbox enabled.\n` +
+      'Pass sandbox: false (or --no-sandbox on the CLI) if you accept that, ' +
+      'which is usual in a container, or run as a non-root user.'
+    );
+  }
+  if (options.sandbox === false && /sandbox/i.test(stderr)) {
+    return `${browser} could not start even with the sandbox disabled.\n${stderr.trim()}`;
+  }
+  return `${browser} exited with code ${code ?? 'unknown'} and produced no PDF.\n${stderr.trim()}`;
+}
+
+function run(
+  command: string,
+  args: string[],
+  timeoutMs: number,
+): Promise<{ code: number | null; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+    let stderr = '';
+    child.stderr?.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(
+        new PdfConversionError(
+          `${command} did not finish within ${timeoutMs}ms. ` +
+            'A logo fetched over the network is the usual cause; inline it instead.',
+        ),
+      );
+    }, timeoutMs);
+
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      reject(new PdfConversionError(`Could not run ${command}: ${error.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ code, stderr });
+    });
+  });
+}
+
+/** Environment variables that name a browser, in the order they are honoured. */
+const BROWSER_ENV_VARS = ['OPEN_NAV_BROWSER', 'CHROME_PATH', 'PUPPETEER_EXECUTABLE_PATH'] as const;
+
+const EXECUTABLE_NAMES = [
+  'google-chrome-stable',
+  'google-chrome',
+  'chromium-browser',
+  'chromium',
+  'microsoft-edge',
+  'chrome',
+];
+
+const WELL_KNOWN_PATHS = [
+  // macOS
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  // Linux
+  '/usr/bin/google-chrome-stable',
+  '/usr/bin/google-chrome',
+  '/usr/bin/chromium-browser',
+  '/usr/bin/chromium',
+  '/usr/bin/microsoft-edge',
+  '/snap/bin/chromium',
+  // Windows
+  'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+  'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+  'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+];
+
+/**
+ * Locate a browser able to print to PDF.
+ *
+ * Order: an explicit environment variable, a Playwright install, the usual
+ * install locations, then `PATH`.
+ *
+ * `searchPaths` replaces that third step. It exists because the usual
+ * locations are absolute paths on the host, so no value of `env` can describe
+ * a machine without a browser — which is exactly what the failure path has to
+ * be tested against.
+ */
+export function findBrowser(
+  env: Record<string, string | undefined> = process.env,
+  searchPaths: readonly string[] = WELL_KNOWN_PATHS,
+): string | undefined {
+  for (const name of BROWSER_ENV_VARS) {
+    const candidate = env[name];
+    if (candidate && existsSync(candidate)) return candidate;
+  }
+
+  const fromPlaywright = findPlaywrightChromium(env['PLAYWRIGHT_BROWSERS_PATH']);
+  if (fromPlaywright) return fromPlaywright;
+
+  for (const candidate of searchPaths) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  const pathEntries = (env['PATH'] ?? '').split(process.platform === 'win32' ? ';' : ':');
+  for (const directory of pathEntries) {
+    if (!directory) continue;
+    for (const name of EXECUTABLE_NAMES) {
+      const candidate = join(directory, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Playwright keeps its browsers in a versioned directory, so the exact path
+ * is not predictable and has to be discovered.
+ */
+function findPlaywrightChromium(browsersPath: string | undefined): string | undefined {
+  if (!browsersPath || !existsSync(browsersPath)) return undefined;
+
+  const candidates: string[] = [];
+  let entries: string[];
+  try {
+    entries = readdirSync(browsersPath);
+  } catch {
+    return undefined;
+  }
+
+  for (const entry of entries) {
+    if (!entry.startsWith('chromium')) continue;
+    candidates.push(
+      join(browsersPath, entry, 'chrome-linux', 'chrome'),
+      join(browsersPath, entry, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium'),
+      join(browsersPath, entry, 'chrome-win', 'chrome.exe'),
+    );
+  }
+
+  // Prefer a full build over the headless shell: the shell cannot print.
+  candidates.sort(
+    (left, right) => Number(left.includes('headless')) - Number(right.includes('headless')),
+  );
+  return candidates.find((candidate) => existsSync(candidate));
+}

package/src/theme.ts

@@ -0,0 +1,305 @@
+import { readFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+
+/**
+ * Visual configuration for the invoice document.
+ *
+ * Every field is optional; what is left out falls back to a restrained
+ * default that prints well in black and white. Values that end up inside the
+ * stylesheet are validated rather than interpolated blindly — a theme is
+ * configuration, but configuration is still input.
+ */
+export interface InvoiceTheme {
+  /** Accent for headings, rules and the total. */
+  accentColor?: string;
+  /** Body text colour. */
+  inkColor?: string;
+  /** Secondary text: labels, references, the footer. */
+  mutedColor?: string;
+  /** Background of the markings panel. */
+  panelColor?: string;
+  /** Rules and borders. */
+  borderColor?: string;
+
+  /** CSS font stack. Give a real fallback chain; a PDF converter needs it. */
+  fontFamily?: string;
+  /** Base size, as a CSS length. Everything else scales from it. */
+  baseFontSize?: string;
+
+  /** Page size for `@page`, e.g. `A4` or `Letter`. */
+  pageSize?: string;
+  /** Page margin for `@page`, e.g. `16mm 14mm`. */
+  pageMargin?: string;
+
+  /** Logo shown in the header. Use `embedImage` to inline a local file. */
+  logo?: InvoiceLogo;
+
+  /** Extra lines in the supplier block: phone, email, web, registration. */
+  issuerContact?: string[];
+  /** Lines printed in the footer, e.g. payment terms or company details. */
+  footerLines?: string[];
+
+  /** Tint alternate table rows. Off by default; it prints heavier. */
+  zebraRows?: boolean;
+  /** Show the "rendered from reported data" note. Defaults to true. */
+  provenanceNote?: boolean;
+
+  /** Appended verbatim after the generated stylesheet. The escape hatch. */
+  customCss?: string;
+}
+
+export interface InvoiceLogo {
+  /**
+   * Image source: a `data:` URI, or an absolute URL.
+   *
+   * Prefer a data URI. An external URL leaves the document dependent on the
+   * network, which defeats archiving it as a single file and can quietly
+   * produce a logo-less PDF.
+   */
+  src: string;
+  /** Rendered width as a CSS length. Height follows the aspect ratio. */
+  width?: string;
+  /** Alternative text, for accessibility and for a failed image. */
+  alt?: string;
+}
+
+export interface ResolvedTheme extends Required<Omit<InvoiceTheme, 'logo' | 'customCss'>> {
+  logo?: InvoiceLogo;
+  customCss?: string;
+}
+
+export const DEFAULT_THEME: ResolvedTheme = {
+  accentColor: '#16181d',
+  inkColor: '#16181d',
+  mutedColor: '#5b6270',
+  panelColor: '#f4f5f8',
+  borderColor: '#c9cdd6',
+  fontFamily: '"Helvetica Neue", Arial, "Liberation Sans", sans-serif',
+  baseFontSize: '10pt',
+  pageSize: 'A4',
+  pageMargin: '16mm 14mm',
+  issuerContact: [],
+  footerLines: [],
+  zebraRows: false,
+  provenanceNote: true,
+};
+
+export class ThemeError extends Error {}
+
+/** Colours we accept: hex, rgb(), rgba(), hsl(), hsla(), or a CSS keyword. */
+const COLOR = /^(#[0-9a-fA-F]{3,8}|(rgb|hsl)a?\([0-9.,%\s/deg]+\)|[a-zA-Z]{3,20})$/;
+/** Lengths and simple length lists, e.g. `10pt` or `16mm 14mm`. */
+const LENGTH_LIST =
+  /^[0-9.]+(px|pt|pc|mm|cm|in|em|rem|%)?( +[0-9.]+(px|pt|pc|mm|cm|in|em|rem|%)?){0,3}$/;
+/** Page sizes: a keyword, optionally with an orientation, or two lengths. */
+const PAGE_SIZE =
+  /^([A-Za-z][A-Za-z0-9]{0,10}( +(portrait|landscape))?|[0-9.]+[a-z]{2} +[0-9.]+[a-z]{2})$/;
+/**
+ * A font stack: names, quotes, commas, spaces, hyphens.
+ *
+ * Parentheses are excluded deliberately. No font name contains one, and
+ * allowing them would admit `url(...)`, which is how a stylesheet is made to
+ * fetch something.
+ */
+const FONT_STACK = /^[-A-Za-z0-9 ,."']+$/;
+
+function check(value: string, pattern: RegExp, field: string, expected: string): string {
+  const trimmed = value.trim();
+  if (!pattern.test(trimmed)) {
+    throw new ThemeError(
+      `theme.${field}: ${JSON.stringify(value)} is not ${expected}. ` +
+        `Values reach the stylesheet, so they are checked rather than trusted.`,
+    );
+  }
+  return trimmed;
+}
+
+/** Fill in the defaults, validating everything that lands in the CSS. */
+export function resolveTheme(theme: InvoiceTheme = {}): ResolvedTheme {
+  const merged: ResolvedTheme = { ...DEFAULT_THEME, ...stripUndefined(theme) };
+
+  for (const field of [
+    'accentColor',
+    'inkColor',
+    'mutedColor',
+    'panelColor',
+    'borderColor',
+  ] as const) {
+    merged[field] = check(merged[field], COLOR, field, 'a CSS colour');
+  }
+  merged.baseFontSize = check(merged.baseFontSize, LENGTH_LIST, 'baseFontSize', 'a CSS length');
+  merged.pageMargin = check(merged.pageMargin, LENGTH_LIST, 'pageMargin', 'a CSS length');
+  merged.pageSize = check(merged.pageSize, PAGE_SIZE, 'pageSize', 'a CSS page size');
+  merged.fontFamily = check(merged.fontFamily, FONT_STACK, 'fontFamily', 'a CSS font stack');
+
+  if (merged.logo) {
+    const src = merged.logo.src.trim();
+    if (!/^(data:image\/[a-z+.-]+;base64,[A-Za-z0-9+/=]+|https?:\/\/\S+)$/.test(src)) {
+      throw new ThemeError(
+        'theme.logo.src must be a data: image URI or an http(s) URL. ' +
+          'Use embedImage() to inline a local file.',
+      );
+    }
+    merged.logo = {
+      src,
+      ...(merged.logo.width
+        ? { width: check(merged.logo.width, LENGTH_LIST, 'logo.width', 'a CSS length') }
+        : {}),
+      ...(merged.logo.alt ? { alt: merged.logo.alt } : {}),
+    };
+  }
+
+  return merged;
+}
+
+function stripUndefined<T extends object>(value: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== undefined),
+  ) as Partial<T>;
+}
+
+const MIME_TYPES: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+};
+
+/** Largest logo we inline, before base64 expansion. */
+export const MAX_LOGO_BYTES = 2 * 1024 * 1024;
+
+/**
+ * Read an image and return it as a `data:` URI.
+ *
+ * Inlining keeps the document self-contained, which is what makes it archive
+ * as one file and print the same offline.
+ */
+export function embedImage(filePath: string, contents?: Buffer): string {
+  const extension = extname(filePath).toLowerCase();
+  const mime = MIME_TYPES[extension];
+  if (!mime) {
+    throw new ThemeError(
+      `Unsupported image type ${extension || filePath}. Supported: ${Object.keys(MIME_TYPES).join(', ')}`,
+    );
+  }
+  const bytes = contents ?? readFileSync(filePath);
+  if (bytes.length > MAX_LOGO_BYTES) {
+    throw new ThemeError(
+      `${filePath} is ${Math.round(bytes.length / 1024)} kB; the limit is ${MAX_LOGO_BYTES / 1024} kB. ` +
+        `A logo this large bloats every document it appears in.`,
+    );
+  }
+  return `data:${mime};base64,${bytes.toString('base64')}`;
+}
+
+/**
+ * Load a theme from a JSON file.
+ *
+ * A `logoFile` field is read relative to the theme file and inlined, so a
+ * theme can be checked in next to its logo and stay portable.
+ */
+export function loadTheme(
+  filePath: string,
+  io: { readFile?: (path: string) => string; readBinary?: (path: string) => Buffer } = {},
+): InvoiceTheme {
+  const readFile = io.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+
+  let parsed: InvoiceTheme & { logoFile?: string };
+  try {
+    parsed = JSON.parse(readFile(filePath)) as InvoiceTheme & { logoFile?: string };
+  } catch (cause) {
+    throw new ThemeError(`${filePath} is not valid JSON: ${(cause as Error).message}`);
+  }
+
+  const { logoFile, ...theme } = parsed;
+  if (logoFile) {
+    const imagePath = resolve(dirname(filePath), logoFile);
+    const readBinary = io.readBinary ?? ((path: string) => readFileSync(path));
+    theme.logo = {
+      ...theme.logo,
+      src: embedImage(imagePath, readBinary(imagePath)),
+    };
+  }
+  return theme;
+}
+
+/** Build the document stylesheet from a resolved theme. */
+export function buildStyles(theme: ResolvedTheme): string {
+  return `<style>
+  @page { size: ${theme.pageSize}; margin: ${theme.pageMargin}; }
+  :root {
+    --accent: ${theme.accentColor};
+    --ink: ${theme.inkColor};
+    --muted: ${theme.mutedColor};
+    --rule: ${theme.borderColor};
+    --panel: ${theme.panelColor};
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    color: var(--ink);
+    font: ${theme.baseFontSize}/1.45 ${theme.fontFamily};
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+  }
+  .invoice { max-width: 190mm; margin: 0 auto; padding: 8mm 0; }
+  .page-break { page-break-after: always; }
+
+  header { display: flex; justify-content: space-between; align-items: flex-start; gap: 12mm; }
+  .brand { display: flex; flex-direction: column; gap: 3mm; }
+  .logo { display: block; max-width: 70mm; max-height: 26mm; }
+  h1 { margin: 0; font-size: 2em; letter-spacing: 0.08em; font-weight: 700; color: var(--accent); }
+  .subtitle { color: var(--muted); font-size: 0.9em; margin-top: 2mm; }
+  .meta { text-align: right; font-size: 0.95em; min-width: 64mm; }
+  .meta div { margin-bottom: 1mm; }
+  .meta .value { font-weight: 700; white-space: nowrap; }
+
+  .parties { display: flex; gap: 6mm; margin: 7mm 0; }
+  .party { flex: 1; border: 1px solid var(--rule); border-radius: 2mm; padding: 4mm; }
+  .party h2 {
+    margin: 0 0 2mm; font-size: 0.8em; text-transform: uppercase;
+    letter-spacing: 0.1em; color: var(--muted); font-weight: 700;
+  }
+  .party .name { font-weight: 700; font-size: 1.1em; margin-bottom: 1mm; }
+  .party .address { font-size: 0.9em; margin-bottom: 1.5mm; }
+  .party dl { margin: 2mm 0 0; display: grid; grid-template-columns: auto 1fr; gap: 0.6mm 3mm; font-size: 0.9em; }
+  .party dt { color: var(--muted); }
+  .party dd { margin: 0; }
+  .party .contact { margin-top: 2mm; font-size: 0.9em; color: var(--muted); }
+
+  table { width: 100%; border-collapse: collapse; font-size: 0.9em; }
+  thead th {
+    text-align: left; font-size: 0.8em; text-transform: uppercase; letter-spacing: 0.06em;
+    color: var(--muted); border-bottom: 1px solid var(--rule); padding: 2mm 1.5mm;
+  }
+  tbody td { padding: 2mm 1.5mm; border-bottom: 1px solid var(--rule); vertical-align: top; }
+  ${theme.zebraRows ? 'tbody tr:nth-child(even) td { background: var(--panel); }' : ''}
+  .num { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
+
+  .totals { display: flex; justify-content: flex-end; margin-top: 5mm; }
+  .totals table { width: auto; min-width: 80mm; }
+  .totals td { padding: 1.5mm 2mm; border: none; background: none; }
+  .totals .grand td {
+    border-top: 1.5px solid var(--accent); color: var(--accent);
+    font-weight: 700; font-size: 1.15em; padding-top: 2.5mm;
+  }
+
+  .vat-summary { margin-top: 6mm; }
+  .vat-summary h2, .markings h2 {
+    font-size: 0.8em; text-transform: uppercase; letter-spacing: 0.1em;
+    color: var(--muted); margin: 0 0 2mm; font-weight: 700;
+  }
+  .markings { margin-top: 6mm; background: var(--panel); border-radius: 2mm; padding: 4mm; }
+  .markings ul { margin: 0; padding-left: 4mm; }
+  .markings li { margin-bottom: 1mm; }
+  .markings .reference { color: var(--muted); font-size: 0.85em; }
+  .note { margin-top: 5mm; font-size: 0.9em; }
+  footer {
+    margin-top: 8mm; color: var(--muted); font-size: 0.8em;
+    border-top: 1px solid var(--rule); padding-top: 2mm;
+  }
+  footer div { margin-bottom: 0.8mm; }
+${theme.customCss ? `\n  /* customCss */\n${theme.customCss}\n` : ''}</style>`;
+}