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

Receitas · Capítulo 2 · Tipo e texto

Sinais de lógica e de conjuntos com uma fonte de símbolos

Uma cartilha de lógica em fontes sem ∀, ∈ nem ℵ: symbolFont nomeia Noto Sans Math, que desenha esses sinais e o grego na tela e no PDF.

Nesta página
Saída
Canvas · PDF
Postext
Testada com o Postext 1.73.0
Requer ≥ 1.73.0 · postext-pdf ≥ 1.73.0
Licença
Atualizada em 10 de nov. de 2026
Código MIT · Texto CC BY 4.0
  • Amostra em inglês: ainda sem edição em português
  • Refile 155 × 235 mm
  • 1 coluna
  • Crimson Pro 11/15
  • Cormorant Garamond
  • IBM Plex Sans Condensed
  • 4 páginas
  • Nível
  • Postext 1.73.0
  • Diagramado em 17 ms
  • 163 linhas de código

Em poucas palavras

Um capítulo curto que ensina a ler os sinais da lógica e da teoria dos conjuntos. As fontes do livro não têm esses sinais, então uma segunda fonte os fornece, na tela e no PDF impresso.

O que você vai compor

O primeiro capítulo de uma cartilha de lógica de bolso, numa página de 155 × 235 mm: uma faixa grená com os sinais do capítulo em corpo grande e depois quatro seções que leem em voz alta ∀, ∃, ∈, ∪, ∅ e ℵ, com as fórmulas no texto corrido e destacadas entre os parágrafos. O livro é composto em Crimson Pro, os títulos em Cormorant Garamond e os rótulos em IBM Plex Sans Condensed. Nenhuma das três tem ∀, ∈ ou letra grega nos arquivos que a Fontsource serve. Um único ajuste, symbolFont, coloca a Noto Sans Math atrás de cada uma, e assim todos os sinais saem da mesma fonte no texto, nos títulos, nos cabeços e nas células das tabelas, e o PDF imprime todos.

Esta receita responde a

  • Como imprimo os sinais de lógica e de conjuntos (∀, ∈, ℵ) e o grego que minha fonte de texto não tem, sem caixas vazias no PDF?

A resposta curta

script.js · linhas 34–47no código completo
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));

Ingredientes

Tipografia
Crimson Pro, Cormorant Garamond, IBM Plex Sans Condensed, Noto Sans Math (SIL OFL 1.1)
Materiais
Nenhum: todas as imagens são desenhadas em código

Preparo

#1 · Uma fonte de símbolos atrás de todas

O código deste passo é a resposta curta, mais acima. symbolFont: 'Noto Sans Math' (fonte de símbolos) põe essa família atrás de todas as que a configuração nomeia: um caractere que a fonte não tem é desenhado com a Noto Sans Math, no corpo e na cor da fonte, e o resto da linha continua na dela. A Fontsource serve a Noto Sans Math inteira no arquivo latin, com 3.033 caracteres, mas o kit declara esse arquivo só para a faixa latina, e o navegador não pediria ∀ a ele. O resolve e o pdfFonts da receita entregam o mesmo arquivo sem faixa, na tela e ao renderToPdf. Só mudam de fonte os caracteres que faltam: a Crimson Pro tem ¬, então a negação no texto continua em Crimson Pro.

#2 · Uma primeira composição sem ela mostra o que falta

script.js · linhas 243–250no código completo
// Each paragraph that sets a character its face lacks is a glyphFallbackAt warning with its
// page; with no symbol font it names no family that draws them, and the PDF would print
// empty boxes. The pages shown are the second build's.
const fonts = { ...kitFonts(FONTS), resolve }; // the kit's resolver, with the symbol file
const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
  fonts);
console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
  .map(formatWarning).join('\n'));

A primeira composição deixa symbolFont vazio e imprime seus avisos glyphFallbackAt, um para cada parágrafo, título ou tabela que traz caracteres para os quais sua fonte não tem glifo, com a página e os caracteres. A edição em inglês dá dezoito: catorze parágrafos em Crimson Pro, três títulos em Cormorant Garamond e a linha de cabeçalho da tabela 1.1 em IBM Plex Sans Condensed negrito. Sem uma família que os desenhe, a tela toma os sinais de uma fonte do sistema do leitor e o PDF imprime uma caixa vazia para cada um. A segunda composição, com a fonte de símbolos, é a que aparece na página; seus avisos nomeiam "Noto Sans Math" como a família que os desenha.

#3 · Os sinais da abertura são texto

script.js · linhas 51–67no código completo
const BAND = 78; // mm from the trim to the foot of the band
const onBand = { color: col('paper'), align: 'left' };
const below = (id, y, width) => ({ anchor: { to: `#${id}`, edge: 'below' }, offset: { y: mm(y) },
  size: { width: mm(width) } });
const opener = { enabled: true, minHeight: mm(BAND - TOP + 2), slot: { elements: [
  { kind: 'box', id: 'band', style: { backgroundColor: col('accent') },
    placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { height: mm(BAND) } } },
  { kind: 'text', id: 'kicker', content: '{attr.kicker}', ...onBand, fontFamily: LABEL,
    fontWeight: 600, fontSize: pt(8.5), letterSpacing: pt(1.8), textTransform: 'uppercase',
    placement: { anchor: { to: 'container', edge: 'top-left' }, offset: { y: mm(2) } } },
  { kind: 'text', id: 'title', content: '{titleText}', ...onBand, fontFamily: DISPLAY,
    fontWeight: 600, fontSize: pt(38), lineHeight: 1.02, placement: below('kicker', 3, 110) },
  // The signs are text in Cormorant Garamond, which has none of them: Noto Sans Math draws
  // every one, at 30 pt, in the band's white.
  { kind: 'text', id: 'signs', content: '{attr.signs}', ...onBand, fontFamily: DISPLAY,
    fontSize: pt(30), lineHeight: 1, letterSpacing: pt(9), placement: below('title', 7, 114) },
] } };

A linha de sete sinais sob o título é um texto de design em Cormorant Garamond a 30 pt, alimentado pelo atributo signs do título. A Cormorant Garamond não tem nenhum deles, então os sete saem da fonte de símbolos, no branco da faixa. Um espacejamento de 9 pt os distribui pela largura da mancha.

#4 · Células e cabeços usam a mesma fonte

script.js · linhas 212–230no código completo
const [T, F] = t({ en: ['T', 'F'], es: ['V', 'F'] });
const connectives = [['¬*p*', (p) => !p], ['*p* ∧ *q*', (p, q) => p && q],
  ['*p* ∨ *q*', (p, q) => p || q], ['*p* → *q*', (p, q) => !p || q],
  ['*p* ↔ *q*', (p, q) => p === q]];
const cell = (content, isHeader = false) => ({ content, align: 'center', isHeader });
const truth = [[true, true], [true, false], [false, true], [false, false]].map(([p, q]) =>
  [p, q, ...connectives.map(([, f]) => f(p, q))].map((v) => cell(v ? T : F)));
const table = (id, rows, columnWidths, caption, position) => ({ id, typeId: 'table',
  kind: 'table', caption, createdAt: 0, updatedAt: 0, placement: { position },
  table: { model: { headerRowCount: 1, columnWidths, rows } } });
const resources = [
  table('truth', [['*p*', '*q*', ...connectives.map(([s]) => s)].map((s) => cell(s, true)),
    ...truth],
    [1, 1, 1.3, 1.6, 1.6, 1.6, 1.6], t({ en: 'The five connectives, row by row.',
      es: 'Las cinco conectivas, fila a fila.' }), 'top'), // to the head of a page
  table('signs', parseTSV(signs.trim()).rows.map((row, r) => row.map(({ content }, c) => ({
    content, align: c === 0 ? 'center' : 'left', isHeader: r === 0 }))), [0.8, 2.1, 5.3],
  t({ en: 'Where the signs come from.', es: 'De dónde vienen los signos.' }), 'here'),
];

A tabela-verdade é construída com os próprios conectivos: o cabeçalho de cada coluna é a fórmula, e cada célula, o que a fórmula dá naquela linha. As células de cabeçalho vão em IBM Plex Sans Condensed negrito itálico e as do corpo em Crimson Pro; a fonte de símbolos atende às duas. Seu único estilo redondo desenha para todos os pesos e inclinações, de modo que o ∧ do cabeçalho em negrito e o ∈ de uma fórmula em itálico são o mesmo sinal reto. O cabeço da página ímpar imprime a seção em curso, {firstMark.h2}, e SETS: ∈, ∪, ∩ AND ∅, na página 3, também tira seus sinais da Noto Sans Math.

Página 3: as fórmulas de conjuntos, em Crimson Pro itálico, com todos os sinais da Noto Sans Math.

A receita completa

Sandbox
// ═══ Postext Cookbook · Nº 185 · Logic signs from a symbol font ═════════════════════
// https://postext.dev/en/cookbook/symbol-font-for-logic
// Code: MIT · Text: original (CC BY 4.0) · Pictures: none
// Fonts: Crimson Pro, Cormorant Garamond, IBM Plex, Noto Sans Math (OFL) · Needs postext ≥ 1.73.0
// A primer of logical notation set in faces that have no ∀, no ∈, no ℵ and no Greek:
// symbolFont names Noto Sans Math, which draws those characters on the canvas and in the PDF.
import {
  buildDocumentWithFonts, renderPageToCanvas, defaultResourceTypes, parseTSV, formatWarning,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'symbol-font-for-logic';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = {
  ink: '#1f1c22', // text: a cool near-black
  accent: '#7b2a3b', // claret: the opener band, labels, the table heads
  tint: '#f4ece9', // the even rows of the truth table
  rule: '#c3b4b2', // hairlines
  muted: '#6a6064', // running heads, the colophon
  paper: '#ffffff',
};
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
  ...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
  { id: 'main-color', name: 'accent (defaults)', value: { hex: palette.accent, model: 'hex' } },
];
const TEXT = 'Crimson Pro', DISPLAY = 'Cormorant Garamond', LABEL = 'IBM Plex Sans Condensed';
const TRIM = [155, 235], INNER = 20, OUTER = 21, TOP = 23; // mm: a trade-size primer
const LEAD = 15; // pt: the body leading

// #region answer: one symbol font behind every face, on the canvas and in the PDF
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));
// #endregion

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

#Tire a primeira composição

Lidos os avisos, uma composição basta.

-const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
-  fonts);
-console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
-  .map(formatWarning).join('\n'));

Erros comuns

Aviso de diagramação · glyphFallbackAt

Caracteres que a fonte não tem, aqui

Por quê. Um parágrafo tem caracteres que a fonte do seu texto não tem: letras e operadores matemáticos (∪, ℵ), grego numa fonte latina, setas (glyphFallback nomeia a fonte, este o parágrafo). supplier é a família que os desenha, normalmente a symbolFont; sem ela, o PDF imprime-os como caixas vazias.

Correção. Indique uma symbolFont que os tenha (Noto Sans Math cobre quase toda a matemática) ou escolha uma família de texto que os tenha. Se o caractere estiver errado (um álef hebraico onde o autor queria um complemento), corrija o texto. Docs →

  • Uma fonte cujos arquivos da Fontsource incluem o grego (Source Serif 4, Alegreya) compõe φ e Γ por conta própria, e o kit carrega esse arquivo quando o texto tem grego: nesse caso só os sinais vão para a fonte de símbolos. A Crimson Pro não tem arquivo grego, então o grego dela sai da Noto Sans Math.
  • A fonte de símbolos tem um único estilo, redondo e regular. Um título em negrito ou uma fórmula em itálico compõe seus sinais nesse estilo, que é como a matemática os imprime.

Créditos

Texto
  • The primer of logical notation, in English and Spanish · Ignacio Ferro · CC BY 4.0
Fontes
Crimson Pro (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1) · IBM Plex Sans Condensed (SIL OFL 1.1) · Noto Sans Math (SIL OFL 1.1)
SandboxPDF