Pular para o conteúdo principal
Receita número 26

Receitas · Capítulo 10 · Saída e integração

Espécime com todas as fontes carregadas antes de compor

Um espécime tipográfico de quatro páginas composto uma vez cedo demais, como prova, e depois com as fontes que a configuração e o texto pedem já carregadas.

Nesta página
Gênero
Catálogos
Saída
Canvas
Postext
Testada com o Postext 1.65.0
Requer ≥ 1.25.0
Licença
Atualizada em 10 de out. de 2026
Código MIT · Texto CC BY 4.0
  • Amostra em inglês: ainda sem edição em português
  • Refile 180 × 240 mm
  • 1 coluna
  • Ysabeau Office 11/15,5
  • IBM Plex Mono
  • Noto Serif Display
  • 4 páginas
  • Nível
  • Postext 1.57.1
  • Diagramado em 4 ms
  • 188 linhas de código

Em poucas palavras

Um livreto de quatro páginas que exibe três famílias tipográficas. Mostra por que todas as fontes precisam terminar de carregar antes de diagramar as páginas, senão as linhas quebram no lugar errado.

O que você vai compor

House Specimen Nº 3, da imaginária Pellow Lane Press, é um espécime tipográfico de quatro páginas para três fontes. Na capa, um campo azul-ultramar traz um Ag branco em Noto Serif Display itálico de 240 pt e duas linhas em monoespaçada com o nome das três fontes; o título fica abaixo do campo. A página 2 desce a Ysabeau Office numa cascata de 7 a 14 pt e depois compõe pangramas em espanhol, polonês e tcheco cujos ż, ř e ů precisam de um segundo arquivo de fonte. A página 3 é a auditoria: uma tabela em IBM Plex Mono, preenchida pelo pen, com as dez fontes que o livreto declara, as seis em que suas páginas são compostas e os arquivos que o navegador baixou para cada uma. A página 4 compõe duas vezes o primeiro parágrafo da página 1, conforme uma composição antecipada e conforme a última. A antecipada rodou antes de o navegador ter um único arquivo de fonte, por isso suas linhas terminam em outros pontos e algumas passam da medida.

Esta receita responde a

  • Por que as minhas quebras de linha mudam ou as palavras se sobrepõem no PDF, e como carrego as fontes corretamente?
  • Como uso as fontes da minha marca ou fontes licenciadas na composição e as incorporo ao PDF?
  • Como descubro o que está errado no meu documento (avisos, transbordamento, layout que não converge)?

A resposta curta

script.js · linhas 314–331no código completo
// buildDocumentWithFonts starts with prepareFonts: it reads the config and the text for every
// face they ask for (text, headings, chips, table, captions, opener, running heads), in each
// weight and slant, and loads them for the characters the document sets. The page declares its
// files (declareFaces), so they load through document.fonts; a face nothing declares would be
// asked of a resolve(family, weight, style) option. Then it builds, reads the faces the pages
// are set in, loads any that the config did not name and builds again.
let report; // { loaded, missing, synthesized }: lists of { family, weight, style }
const build = () => buildDocumentWithFonts(content(), config(),
  { onFonts: (found) => { report = found; } }); // what the last look at the pages found

kitStatus('Loading fonts…'); // the kit's bar: it also reports any error thrown below
const early = buildDocument(content(), config()); // on purpose: the page has no font yet (page 4)
declareFaces(FONTS);
const fitted = await build(); // every face loaded before a line is measured
audit = auditOf(fitted, report); // page 3's table
drawProof(early, fitted); // page 4's picture
const doc = await build(); // nothing left to load: the same pages, table and picture filled in
showPages(doc, { title: 'Load every font before layout' });

Ingredientes

Tipografia
Ysabeau Office, Noto Serif Display, IBM Plex Mono (SIL OFL 1.1)
Materiais
Nenhum: todas as imagens são desenhadas em código

Preparo

#1 · Declare cada arquivo sem baixá-lo

script.js · linhas 268–287no código completo
const SUBSETS = { // the characters each file covers, copied from the family's @font-face CSS
  latin: 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,'
    + 'U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD',
  'latin-ext': 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,'
    + 'U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,'
    + 'U+A720-A7FF' };
const FILES = new Map(); // FontFace → the subset its file covers, for the audit
function declareFaces(fonts) { // Fontsource's static files stand in for your own /fonts/ folder
  for (const { family, weight, style } of facesOf(fonts)) {
    const id = family.toLowerCase().replaceAll(' ', '-');
    for (const [subset, unicodeRange] of Object.entries(SUBSETS)) {
      const file = `${id}@5/files/${id}-${subset}-${weight}-${style}.woff2`;
      // Adding a face fetches nothing: the file downloads when a load or a line needs it.
      const face = new FontFace(family, `url(https://cdn.jsdelivr.net/npm/@fontsource/${file})`,
        { weight: `${weight}`, style, unicodeRange });
      FILES.set(face, subset);
      document.fonts.add(face);
    }
  }
}

Um FontFace é um arquivo, como uma regra @font-face, por isso uma fonte com um arquivo latin e outro latin-ext é declarada com dois objetos FontFace que compartilham família, peso e estilo e diferem no unicodeRange, copiado do CSS da família. Adicioná-los a document.fonts não baixa nada: o navegador busca um arquivo quando uma chamada a load() ou uma linha de texto precisa dos caracteres dele. O Postext carrega por document.fonts as fontes que a página declara; as que ninguém declara ele pede à opção resolve, que é como as outras receitas recebem do kit os arquivos do Fontsource. customFonts numa configuração apenas descreve os arquivos de um pacote .postext, por isso uma página composta a partir de Markdown declara os seus ou entrega um resolve.

#2 · Carregue as fontes, depois componha

O código é a resposta curta lá em cima. buildDocumentWithFonts começa por prepareFonts, que lê na configuração e no texto todas as fontes que eles pedem, em cada peso e estilo, e as carrega usando os caracteres do próprio documento como amostra, de modo que os arquivos latin-ext chegam com os pangramas em polonês e tcheco (Carregar as fontes antes da diagramação). Depois compõe, lê em que fontes as páginas ficaram compostas, carrega as que a configuração não nomeava e compõe de novo. onFonts recebe o relatório dessa última conferência: as fontes carregadas (loaded), as que faltam (missing) e as que o navegador teria simulado a partir de outro peso ou estilo (synthesized). O pen compõe três vezes porque o livreto imprime a própria prova: uma vez cedo demais, outra com as fontes e uma última com a tabela e a imagem preenchidas.

#3 · Monte a auditoria a partir do relatório

script.js · linhas 291–309no código completo
const SET = { loaded: 'yes', synthesized: 'faked', missing: 'in a fallback' }; // the report
const nameOf = (f) => `${f.family.replaceAll('"', '')} ${f.weight} ${f.style}`; // or a FontFace
function auditOf(doc, report) {
  const found = Object.keys(SET).flatMap((kind) => report[kind].map((f) => [nameOf(f), kind]));
  const inPages = new Map(found);
  const loaded = [...FILES].filter(([face]) => face.status === 'loaded');
  const faces = new Map([...facesOf(FONTS), ...Object.keys(SET).flatMap((kind) => report[kind])]
    .map((f) => [nameOf(f), f])); // the declared faces, then any the pages set without a file
  const rows = [...faces].map(([name, f], i, all) => [
    i && all[i - 1][1].family === f.family ? '' : f.family, // each family named once
    `${f.weight}${f.style === 'italic' ? ' italic' : ''}`, SET[inPages.get(name)] ?? 'no',
    loaded.filter(([face]) => nameOf(face) === name).map(([, subset]) => subset).join(' · ')
      || 'none'].map((cell) => ({ content: cell })));
  // What else to read in a finished layout: its content warnings, its passes, its warnings.
  return { rows, note: `${report.loaded.length} of ${rows.length} faces set in the pages · `
    + `${loaded.length} of ${FILES.size} files fetched · fontFallback warnings: `
    + `${fallbacksIn(doc) || 'none'} · ${doc.converged ? '' : 'not '}converged · layout warnings: `
    + `${doc.warnings?.length || 'none'}` };
}

A tabela parte das fontes que FONTS declara e acrescenta o que o relatório diz de cada uma: se as páginas compõem algo nela, se o navegador a simulou ou se saiu numa fonte substituta. A última coluna lista os arquivos cujo FontFace chegou a loaded. Dezesseis dos vinte foram baixados: o Postext carrega as quatro variantes da família do texto, porque ** e * podem pedi-las em qualquer parágrafo, e os dois itálicos da monoespaçada, que nenhum ajuste cita, nunca foram baixados. A nota lê mais três coisas do documento pronto: contentWarnings, em que uma fonte medida com uma substituta aparece como fontFallback; converged, verdadeiro quando as passadas da diagramação se estabilizaram; e warnings. Confira as três antes de mostrar ou exportar uma página.

#4 · Guarde uma composição antecipada como prova

script.js · linhas 126–174no código completo
const STRIP = { lines: 8, overrun: 10 }; // page 1's first paragraph; mm shown past the measure
const PROOF = { // px: two strips a lead apart, cut at 300 dpi
  width: Math.round(((MEASURE + STRIP.overrun) / 25.4) * 2 * DPI),
  height: Math.round((((2 * STRIP.lines + 1) * LEAD) / 72) * 2 * DPI) };
const proof = { moved: 0, total: 0, faces: 0 }; // lines the early build broke elsewhere, of all
const fallbacksIn = (doc) => // a build lists each face its font set could not give
  (doc.contentWarnings ?? []).filter((w) => w.kind === 'fontFallback').length;
const proofFigure = () => ({ id: 'proof', typeId: 'figure', kind: 'bitmap', createdAt: 0,
  updatedAt: 0, placement: here,
  bitmap: { fileId: 'proof.png', format: 'png', width: PROOF.width, height: PROOF.height },
  caption: 'The first paragraph of page 1 as the early build set it, measured before the fonts '
    + 'had arrived (above), and as the last build set it (below). The early build broke '
    + `${proof.moved} of its ${proof.total} lines of text elsewhere, and its own warnings name `
    + `${proof.faces} faces set in a fallback. The rule marks the measure.`,
  altText: `Two strips of the same ${STRIP.lines} lines of text. In the upper strip the lines `
    + 'break in other places and some run past a vertical rule; in the lower one every line '
    + 'stops short of it.' });
function drawProof(first, last) {
  const linesOf = (doc) => doc.blocks.filter((b) => b.type === 'paragraph')
    .map((b) => b.lines.map((l) => l.text));
  const [before, after] = [first, last].map(linesOf);
  proof.total = before.flat().length;
  proof.faces = fallbacksIn(first);
  proof.moved = before.flatMap((lines, i) => lines.filter((t, j) => t !== after[i]?.[j])).length;
  const canvas = Object.assign(document.createElement('canvas'), PROOF);
  const ctx = canvas.getContext('2d');
  const strip = (PROOF.height * STRIP.lines) / (2 * STRIP.lines + 1);
  const edge = Math.round((PROOF.width * MEASURE) / (MEASURE + STRIP.overrun));
  // The renderer clips each column 2 pt past its edge, which would cut the early build's lines
  // at the measure: paint a copy of page 1 whose column reaches across the whole strip.
  const wide = (column) => ({ ...column,
    bbox: { ...column.bbox, width: column.bbox.width + (STRIP.overrun / 25.4) * DPI } });
  [first, last].forEach((doc, i) => {
    const page = document.createElement('canvas');
    renderPageToCanvas({ ...doc.pages[0], columns: doc.pages[0].columns.map(wide) }, doc, page,
      { scale: 2 }); // 300 dpi
    const { x, y } = doc.pages[0].columns[0].blocks.find((b) => b.type === 'paragraph').bbox;
    ctx.drawImage(page, 2 * x, 2 * y, PROOF.width, strip,
      0, i * (PROOF.height - strip), PROOF.width, strip);
  });
  ctx.fillStyle = `${palette.ultramarine}1f`; // a pale wash over the margin past the measure
  ctx.fillRect(edge, 0, PROOF.width - edge, PROOF.height);
  ctx.fillStyle = palette.ultramarine; // a hairline at the measure, and each strip's name
  ctx.fillRect(edge, 0, 2, PROOF.height);
  ctx.font = `700 ${(7 / 72) * 2 * DPI}px "IBM Plex Mono"`; // 7 pt, loaded by now
  ['early', 'last'].forEach((name, i) => // on the last line of each strip
    ctx.fillText(name, edge + 12, (i ? PROOF.height : strip) - 16));
  registerResourceImage('proof.png', canvas);
}

O pen chama buildDocument uma vez antes de declarar qualquer fonte, de modo que essa composição mede todas as palavras na fonte substituta do navegador. Quando as fontes reais já chegaram, o pen a pinta de novo e a compara linha a linha com a última; a contagem de linhas da legenda sai dessa comparação, e a de fontes, dos avisos fontFallback da própria composição antecipada. Uma linha simples medida numa fonte substituta mais estreita passa da medida até que o recorte da coluna, 2 pt além da borda, corta as últimas letras, por isso o pen pinta a página 1 com a coluna alargada para mostrar todo o excesso. O canvas e o postext-pdf desenham cada trecho de uma linha justificada ou com estilos misturados onde a diagramação o mediu, por isso uma fonte real mais larga que a substituta sai impressa por cima da palavra seguinte, e as palavras de um PDF composto antes de as fontes chegarem se sobrepõem. Nada da composição antecipada passa para a seguinte: prepareFonts encontra as fontes novas em document.fonts e descarta as larguras medidas nas famílias delas, por isso não é preciso chamar clearMeasurementCache().

#5 · Uma cascata no ritmo do texto

script.js · linhas 30–44no código completo
const bodyText = () => ({
  fontFamily: TEXT, fontSize: pt(11), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: true }); // ragged and spaced
// Every waterfall size and pangram is two leads (31 pt) deep, on the text's 15.5 pt rhythm.
const line = (size) => ({ fontSize: pt(size), lineHeight: pt(2 * LEAD) });
const paragraphStyles = () => [
  ...[7, 8, 9, 10, 11, 12, 14].map((size) => ({ id: `s${size}`, ...line(size) })),
  { id: 'pangram', ...line(13) },
  { id: 'colophon', fontSize: pt(7), lineHeight: pt(10), fontFamily: MONO, color: col('muted') }];
// Size labels: boxless mono chips. A Plex Mono letter is 0.6 em wide, so a one-digit label gets
// half a letter each side and the samples start on one edge.
const tag = { fontFamily: MONO, fontSize: pt(7), color: col('ultramarine'),
  backgroundEnabled: false, borderWidth: pt(0), paddingX: pt(0), gap: mm(2.5) };
const chipStyles = () => [{ id: 'size', ...tag }, { id: 'size-1', ...tag, paddingX: em(0.3) }];

A Ysabeau Office compõe o texto em 11 sobre 15,5 pt, com uma linha em branco entre parágrafos em vez de recuo. O texto é alinhado à esquerda, de modo que cada espaço entre palavras mantém a largura natural. Negrito, itálico e referências saem na cor da tinta; sem ajuste, tomariam a cor principal. Cada tamanho da cascata e cada pangrama é um estilo de parágrafo com duas entrelinhas (31 pt) de altura, de modo que a página mantém o ritmo de 15,5 pt do texto. Os rótulos de tamanho são chips em monoespaçada, e os tamanhos de um algarismo ganham meia letra de espaçamento interno de cada lado, para que todas as amostras comecem na mesma borda.

#6 · Três fontes numa capa

script.js · linhas 48–74no código completo
const Y = { kicker: 14, glyphs: 17, label: FIELD - 12, title: FIELD + 10, // mm from the top edge
  end: FIELD + 42 }; // where the opener ends: under the title, the lead and a line of air
const ITALIC_FOOT = 5; // mm: the italic A's foot reaches this far left of the glyphs' origin
const at = (x, y, width) => ({ anchor: { to: 'page', edge: 'top-left' },
  offset: { x: mm(x), y: mm(y) }, ...(width && { size: { width: mm(width) } }) });
const text = (id, content, style, placement) => ({ kind: 'text', id, content, align: 'left',
  overflow: 'wrap', ...style, placement }); // a running head wraps too, never '…'
const cover = () => ({ level: 1, fontSize: pt(30), italic: true, // headings.levels[0]
  breakBefore: { enabled: true, parity: 'odd' }, // the cover is a recto
  span: 'page', // the heading is set across the page; its field hangs from the bleed
  advancedDesign: { enabled: true, minHeight: mm(Y.end - MARGIN.top), // from the top margin
    slot: { elements: [
      { kind: 'box', id: 'field', style: { backgroundColor: col('ultramarine') }, placement: {
        anchor: { to: 'bleed', edge: 'top-left' }, size: { width: 'fill', height: mm(FIELD) } } },
      text('kicker', '{attr.kicker}', { ...label, fontWeight: 700, color: col('paper') },
        at(MARGIN.inner, Y.kicker)),
      text('glyphs', '{attr.glyphs}', { ...display, fontSize: pt(240), lineHeight: 1,
        color: col('paper') }, at(MARGIN.inner + ITALIC_FOOT, Y.glyphs)),
      text('label', '{attr.label}', { ...label, color: col('mist') }, at(MARGIN.inner, Y.label)),
      text('faces', '{attr.faces}', { ...label, color: col('mist') },
        { anchor: { to: '#label', edge: 'below' }, offset: { y: mm(1.2) } }),
      text('title', '{titleText}', { ...display, fontSize: pt(30), lineHeight: 1.05,
        color: col('ink') }, at(MARGIN.inner, Y.title, PAGE.width - 2 * MARGIN.inner)),
      text('lead', '{attr.lead}', { fontFamily: TEXT, italic: true, fontSize: pt(12),
        lineHeight: 1.35, color: col('ink') }, { anchor: { to: '#title', edge: 'below' },
        offset: { y: mm(3) }, size: { width: mm(MEASURE) } }),
    ] } } });

A capa é o design do nível H1: as letras do atributo glyphs do título na fonte de títulos a 240 pt e, embaixo, duas linhas em monoespaçada que nomeiam essa fonte e as de texto e de rótulos, como na folha de espécime de uma fundição de tipos. span: 'page' estende o título à página inteira, e o campo pende do canto superior esquerdo da sangria, por isso sai pela borda de cima. minHeight conta a partir da margem superior e reserva o espaço até Y.end, 42 mm abaixo do campo; sem ele, o texto começa uma linha acima, colado na linha fina.

A receita completa

Sandbox
// ═══ Postext Cookbook · Nº 026 · Type specimen with every font loaded before layout ═════════
// https://postext.dev/en/cookbook/fonts-before-layout
// Code: MIT · Text: original (CC BY 4.0) · Picture: cut from the pen's own early and last builds
// Fonts: Ysabeau Office, Noto Serif Display, IBM Plex Mono (SIL OFL 1.1) · Needs postext ≥ 1.25.0
import { buildDocument, buildDocumentWithFonts, renderPageToCanvas, defaultResourceTypes,
  registerResourceImage } from 'https://esm.sh/postext';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'fonts-before-layout';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const PAGE = { width: 180, height: 240 }; // mm
const MARGIN = { top: 22, bottom: 24, inner: 20, outer: 48 }; // mm: inner is the spine side
const MEASURE = PAGE.width - MARGIN.inner - MARGIN.outer; // 112 mm: about 70 letters at 11 pt
const FIELD = 122; // mm from the top edge: the ultramarine field of the opener
const LEAD = 15.5; // pt: the body leading and the step of every vertical space
const DPI = 150; // the page's resolution: the proof on page 4 is cut at twice this
const [TEXT, DISPLAY, MONO] = ['Ysabeau Office', 'Noto Serif Display', 'IBM Plex Mono'];
const palette = { ink: '#16161a', ultramarine: '#3246d3', mist: '#c9d0f6', // mist: 4.6:1 on
  rule: '#cfc9bd', muted: '#6b6a70', paper: '#ffffff' }; // ultramarine, for labels on the field
// Every colour is linked to its palette entry; main-color catches any default left unstated.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = () => Object.entries({ ...palette, 'main-color': palette.ultramarine })
  .map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } }));
const label = { fontFamily: MONO, fontSize: pt(7.5), letterSpacing: pt(1.2),
  textTransform: 'uppercase' };
const display = { fontFamily: DISPLAY, fontWeight: 900, italic: true };

// #region type: the text face at 11 on 15.5 pt, and a waterfall of it on two leads a line
const bodyText = () => ({
  fontFamily: TEXT, fontSize: pt(11), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: true }); // ragged and spaced
// Every waterfall size and pangram is two leads (31 pt) deep, on the text's 15.5 pt rhythm.
const line = (size) => ({ fontSize: pt(size), lineHeight: pt(2 * LEAD) });
const paragraphStyles = () => [
  ...[7, 8, 9, 10, 11, 12, 14].map((size) => ({ id: `s${size}`, ...line(size) })),
  { id: 'pangram', ...line(13) },
  { id: 'colophon', fontSize: pt(7), lineHeight: pt(10), fontFamily: MONO, color: col('muted') }];
// Size labels: boxless mono chips. A Plex Mono letter is 0.6 em wide, so a one-digit label gets
// half a letter each side and the samples start on one edge.
const tag = { fontFamily: MONO, fontSize: pt(7), color: col('ultramarine'),
  backgroundEnabled: false, borderWidth: pt(0), paddingX: pt(0), gap: mm(2.5) };
const chipStyles = () => [{ id: 'size', ...tag }, { id: 'size-1', ...tag, paddingX: em(0.3) }];
// #endregion

// #region opener: the H1 as a bleed field, the display face at 240 pt, labels naming the faces
const Y = { kicker: 14, glyphs: 17, label: FIELD - 12, title: FIELD + 10, // mm from the top edge

O script.js montado funciona como está: cole-o como script de módulo em qualquer página ou abra a receita no CodePen. Pasta da receita no GitHub ↗ (abre em uma nova aba)

Variações

#Entregue os arquivos com resolve

kitFonts(FONTS), em de uma string Markdown a uma página diagramada, não declara nada: o Postext pede ao resolve os arquivos de cada fonte e os adiciona ele mesmo a document.fonts.

#Esqueça uma fonte

Deixe de fora o negrito da IBM Plex Mono, que compõe o chapéu, o cabeçalho da tabela e os rótulos das legendas: o navegador engrossa o redondo, a tabela marca a fonte com faked e a nota conta um aviso fontFallback, que indica IBM Plex Mono 700 como synthesized.

-  'IBM Plex Mono': ['400', '400i', '700', '700i'], // labels, chips, the table, captions
+  'IBM Plex Mono': ['400', '400i', '700i'], // labels, chips, the table, captions

#Incorpore as mesmas fontes num PDF

renderToPdf incorpora os bytes que seu fontProvider devolve para cada fonte, e o provedor de um PDF de verdade com as mesmas fontes incorporadas serve os arquivos latin do Fontsource, que param no Latin-1: para os ż, ł, ř e ů deste livreto, faça-o devolver o arquivo inteiro de cada fonte a partir de uma pasta própria.

Erros comuns

Erro comum

Os arquivos do Fontsource cobrem letras, não símbolos

O kit incorpora o arquivo latin do Fontsource de cada fonte e, quando o texto usa esses caracteres, o arquivo latin-ext para č, ł, † e o arquivo greek para α, χ (em uma família que o tenha: Lora e Gelasio não têm), na tela e no PDF. Símbolos como →, ≈, ✓ e ★ não estão em nenhum desses arquivos e somem no PDF: desenhe-os, componha-os como matemática ou escolha uma fonte cujos arquivos os tenham. Fontes incorporadas ao PDF →

Aviso de diagramação · fontFallback

Fonte substituta na diagramação

Por quê. Uma fonte com que o texto foi composto não estava no conjunto de fontes quando o documento foi composto (`reason: 'missing'`), ou a família não tem arquivo para esse peso ou essa inclinação e o navegador a desenha a partir de outra (`'synthesized'`); por isso, as quebras de linha foram medidas com uma fonte que não é a que o PDF incorpora.

Correção. Carregue as fontes antes da primeira composição: `prepareFonts(content, config, { resolve })`, ou componha com `buildDocumentWithFonts`, que também carrega qualquer fonte que as páginas usaram e compõe de novo. Para `synthesized`, carregue esse peso ou essa inclinação, ou escolha um peso que a família tenha. Docs →

Verificação do Sandbox · missingFont

Fonte ausente

Por quê. Uma família citada na configuração não chegou a carregar no navegador; por isso, o texto foi medido e desenhado com uma fonte substituta do sistema.

Correção. Corrija o nome da família (uma só família, sem pilha CSS) e carregue todas as fontes antes da primeira composição; num pen, inclua a família em FONTS. Docs →

Verificação do Sandbox · missingFontVariant

Variante de fonte ausente

Por quê. Uma família personalizada não tem arquivo para um peso e estilo que o documento usa, como o itálico ou o negrito.

Correção. Envie ou declare a variante que falta, ou deixe de usar esse peso ou estilo. Docs →

  • Se você carregar uma fonte por conta própria, document.fonts.load(font) sem texto de amostra carrega só o arquivo que cobre o espaço, o latin, e ż e ř caem numa fonte do sistema. prepareFonts passa os caracteres do próprio documento.
  • renderPageToCanvas e postext-pdf recortam cada coluna 2 pt além da borda, por isso uma linha medida com uma fonte substituta mais estreita perde as últimas letras. A composição que a mediu indica a fonte em doc.contentWarnings como fontFallback: leia essa lista antes de mostrar ou exportar uma página.

Créditos

Texto
Texto original, CC BY 4.0
Fontes
Ysabeau Office (SIL OFL 1.1) · Noto Serif Display (SIL OFL 1.1) · IBM Plex Mono (SIL OFL 1.1)
Sandbox