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

Receitas · Capítulo 2 · Tipo e texto

Espaçamento uniforme em colunas estreitas justificadas

Quebra Knuth–Plass com os espaços entre 0,8 e 1,6 vez o normal, ao lado de um controle guloso com linhas frouxas, isoladas e curtas marcadas a partir do VDT.

Nesta página
Saída
Canvas
Nível
Avançado
Postext
Testada com o Postext 1.65.0
Requer ≥ 1.34.0
Licença
Atualizada em 16 de out. de 2026
Código MIT · Texto CC BY 4.0
  • Amostra em inglês: ainda sem edição em português
  • Refile 148 × 210 mm
  • 2 colunas, medianiz de 5 mm
  • Petrona 9,5/13
  • Bricolage Grotesque
  • Source Code Pro
  • 3 páginas
  • Nível
  • Postext 1.65.0
  • Diagramado em 24 ms
  • 247 linhas de código

Em poucas palavras

Uma pequena revista sobre tipografia, em colunas estreitas com as duas bordas do texto alinhadas. Mostra como manter iguais os espaços entre as palavras, ao lado de uma versão com as linhas desiguais marcadas em amarelo.

O que você vai compor

O número 12 de Galley, a revista de um laboratório de tipografia, composta em A5 em duas colunas de uns quarenta caracteres, em que uma linha justificada só tem cinco ou seis espaços entre palavras para absorver a folga. A abertura desenha o modelo de Knuth–Plass sobre uma faixa grafite: uma linha de caixas de palavras cujas molas amarelas de cola se esticam até preencher a medida. O ensaio explica por que as colunas estreitas ficam frouxas e imprime em fonte monoespaçada, entre os parágrafos, os ajustes por trás de cada regra. No pé da página 3, uma bancada de testes compõe um mesmo parágrafo alinhado à esquerda, justificado sem hífens e justificado com eles. O pen também compõe o número com a quebra de primeiro ajuste e sem as proteções contra viúvas e órfãs, e mostra as duas páginas 2 lado a lado acima das páginas, como no cartão desta receita, com as linhas frouxas pintadas de amarelo marca-texto e as linhas isoladas e curtas sinalizadas na margem.

Esta receita responde a

  • Como consigo boa justificação e hifenização em textos em espanhol, francês ou alemão?
  • Como evito viúvas, órfãs e últimas linhas de uma só palavra, e mantenho cada título junto do seu texto?
  • Por que uma linha sai alinhada à esquerda ou esticada demais (URLs, palavras compostas longas, palavras longas em células)?
  • Como descubro o que está errado no meu documento (avisos, transbordamento, layout que não converge)?

A resposta curta

script.js · linhas 39–55no código completo
// Knuth–Plass breaking, hyphenation and the widow, orphan and runt penalties are all on by
// default. A narrow column also needs a tighter fence round the glue, in multiples of a
// normal word space (defaults 0.6 and 2): lines past the upper fence cost more than any
// hyphen, so the breaker hyphenates or re-breaks the paragraph before it stretches that far.
const FENCES = { minWordSpacing: 0.8, maxWordSpacing: 1.6 };
const bodyText = { // config().bodyText
  fontFamily: TEXT, fontSize: pt(BODY), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  firstLineIndent: mm(4), indentAfterHeading: false, // justified and hyphenated by default
  ...FENCES,
};
// Hyphenation follows the document's locale:
const locale = t({ en: 'en-us', es: 'es' }); // config().locale: each edition's patterns
// The control: first-fit breaking, which sets each line once and moves on, with the widow and
// orphan guards off (runts are priced inside Knuth–Plass only). Same text, fonts and measure.
const GREEDY = { optimalLineBreaking: false, avoidWidows: false, avoidOrphans: false };
const control = () => ({ ...config(), bodyText: { ...bodyText, ...GREEDY } });

Ingredientes

Tipografia
Petrona, Bricolage Grotesque, Source Code Pro (SIL OFL 1.1)
Materiais
Nenhum: todas as imagens são desenhadas em código

Preparo

#1 · Aperte os limites e mantenha as proteções

O código deste passo é a resposta curta logo acima. O Knuth–Plass, a hifenização, as penalidades de viúvas, órfãs e linhas curtas e os títulos presos ao texto seguinte vêm ativados por padrão, de modo que a edição publicada só estreita os limites do espaçamento entre palavras para 0,8 e 1,6 vez um espaço normal (os padrões são 0,6 e 2). Uma linha acima do limite superior custa mais que qualquer hífen ou linha curta, por isso o algoritmo tenta outras quebras antes; tire os dois limites e este ensaio compõe duas linhas acima de 1,6. A hifenização segue locale: 'es', 'fr' e 'de' têm os próprios padrões do TeX, uma etiqueta regional como 'es-ES' usa os do idioma, e um idioma sem padrões é hifenizado como inglês americano, com um aviso no console.

#2 · Marque as linhas frouxas a partir da árvore de layout

script.js · linhas 303–345no código completo
// findLooseLines gives the justified lines whose word spaces stretch past a threshold, here the
// upper fence. The rest is read from the VDT: a line past 3× is set ragged (line.ragged), and a
// paragraph cut by a column is two blocks.
function marks(doc, page) {
  const body = doc.pages.flatMap((p) => p.columns.flatMap((c) => c.blocks)).filter((b) =>
    b.type === 'paragraph' && b.containerId === undefined && b.textAlign === 'justify');
  const loose = findLooseLines(doc, { threshold: FENCES.maxWordSpacing, pageIndex: page.index });
  const out = loose.map(({ x, y, width: w, height: h }) => ({ x, y, w, h, kind: 'loose' }));
  for (const column of page.columns) {
    for (const b of column.blocks.filter((x) => body.includes(x))) {
      const parts = body.filter((o) => o.contentIndex === b.contentIndex);
      b.lines.forEach((line) => {
        const at = { x: b.bbox.x, y: line.bbox.y, w: b.bbox.width, h: line.bbox.height, column };
        if (line.ragged) out.push({ ...at, kind: 'loose' }); // past 3×: no ratio, set ragged
        if (b.lines.length === 1 && parts.length > 1) { // Postext's names (see the essay):
          out.push({ ...at, kind: b === parts[0] ? 'widow' : 'orphan' }); // foot : head
        } else if (line.isLastLine && !/\s/.test(line.text.trim())) {
          out.push({ ...at, kind: 'runt' }); // one word alone on a paragraph's last line
        }
      });
    }
  }
  return out;
}
const TAGS = t({ en: { widow: 'widow', orphan: 'orphan', runt: 'runt' },
  es: { widow: 'viuda', orphan: 'huérfana', runt: 'corta' } });
function paintMarks(canvas, list, scale) {
  const ctx = canvas.getContext('2d');
  ctx.setTransform(scale, 0, 0, scale, 0, 0); // page px from here on
  for (const m of list) { // loose lines: a wash; lone lines and runts: a tag in the margin
    const loose = m.kind === 'loose';
    ctx.globalCompositeOperation = loose ? 'multiply' : 'source-over'; // the ink shows through
    ctx.fillStyle = loose ? palette.marker : palette.graphite;
    if (loose) { ctx.fillRect(m.x - 2, m.y + 1, m.w + 4, m.h - 1); continue; }
    ctx.font = `600 ${m.h * 0.48}px "${MONO}"`;
    const w = ctx.measureText(TAGS[m.kind]).width + m.h * 0.5;
    const x = m.column.index === 0 ? m.x - w - m.h * 0.35 : m.x + m.w + m.h * 0.35;
    ctx.fillRect(x, m.y + m.h * 0.12, w, m.h * 0.8);
    ctx.fillStyle = palette.marker;
    ctx.fillText(TAGS[m.kind], x + m.h * 0.25, m.y + m.h * 0.7);
  }
  ctx.setTransform(1, 0, 0, 1, 0, 0);
}

findLooseLines devolve as linhas justificadas cujos espaços se esticam além de um limite, aqui o limite superior, cada uma com a faixa que o realce cobre (Linhas frouxas no seu próprio canvas). marks() acrescenta o que essa lista deixa de fora, lido do VDT: uma linha acima de 3× não tem proporção, porque o motor a compõe alinhada à esquerda e a marca com line.ragged, e um parágrafo dividido entre duas colunas volta como um bloco por fragmento, que é como as linhas isoladas são encontradas. Com quarenta caracteres, os limites sozinhos não mantêm todas as linhas abaixo de 1,6; enquanto o texto do ensaio era ajustado, as marcas mostravam quais frases reescrever.

#3 · Ponha o controle ao lado da página publicada

script.js · linhas 349–383no código completo
function compare(pairs) {
  document.head.insertAdjacentHTML('beforeend', `<style>
    #compare { background: ${palette.graphite}; color: ${palette.haze}; padding: 36px 24px 44px;
      font: 500 12px/1.4 "${MONO}", monospace; } #compare > * { max-width: 860px; margin: 0 auto; }
    #compare h2 { font: 800 clamp(30px, 6vw, 72px)/0.95 "${DISPLAY}", sans-serif; color: #fff;
      margin: 6px auto 26px; letter-spacing: -0.01em; } #compare figure { margin: 0; }
    #compare .kicker { color: ${palette.marker}; letter-spacing: .16em; text-transform: uppercase; }
    #compare .pair { display: grid; grid-template-columns: 1fr 1fr; gap: 28px; }
    #compare canvas { width: 100%; display: block; }
    #compare figcaption { margin-bottom: 12px; text-transform: uppercase; letter-spacing: .12em; }
    #compare figcaption b { display: block; margin-bottom: 6px; color: #fff; letter-spacing: 0;
      font: 800 clamp(18px, 2.4vw, 26px)/1 "${DISPLAY}"; text-transform: none; }
    @media (max-width: 640px) { #compare .pair { grid-template-columns: 1fr; } }</style>`);
  const section = Object.assign(document.createElement('section'), { id: 'compare' });
  section.innerHTML = `<p class="kicker">${t({ en: 'Same text · same design · page 2',
    es: 'El mismo texto · el mismo diseño · página 2' })}</p><h2>${t({
    en: 'Two line breakers', es: 'Dos formas de cortar' })}</h2><div class="pair"></div>`;
  for (const [name, doc] of pairs) {
    const page = doc.pages[1];
    const list = marks(doc, page); // one walk per edition: the counts and the paint share it
    const n = (...kinds) => list.filter((m) => kinds.includes(m.kind)).length;
    const counts = `${t({ en: 'loose', es: 'flojas' })} ${n('loose')} · `
      + `${t({ en: 'lone', es: 'solas' })} ${n('widow', 'orphan')} · `
      + `${t({ en: 'runts', es: 'cortas' })} ${n('runt')}`;
    const figure = document.createElement('figure');
    figure.innerHTML = `<figcaption><b>${name}</b><span>${counts}</span></figcaption>`;
    const canvas = figure.appendChild(document.createElement('canvas'));
    canvas.setAttribute('role', 'img');
    canvas.setAttribute('aria-label', `${name}, ${t({ en: 'page', es: 'página' })} 2: ${counts}`);
    renderPageToCanvas(page, doc, canvas, { scale: 1000 / page.width });
    paintMarks(canvas, list, 1000 / page.width);
    section.querySelector('.pair').append(figure);
  }
  document.getElementById('pages').before(section); // #pages: the desk showPages() builds
}

As duas edições usam o mesmo design, por isso qualquer diferença entre as duas páginas 2 vem do algoritmo de quebra e das proteções. Em inglês, o controle guloso deixa 47 das 110 linhas justificadas acima de 1,6 e 30 acima de 2, três delas acima de 3× e alinhadas à esquerda pelo motor, enquanto a edição Knuth–Plass mantém todas as 105 entre 0,80 e 1,60. Na página 2, o controle também leva a última linha de um parágrafo, sozinha, para o alto de uma coluna, o que avoidOrphans: false permite, e termina outro parágrafo numa linha curta.

#4 · Dê a cada ajuste um boxe próprio

script.js · linhas 107–130no código completo
// A box sets all its :::columns in one body style, so each setting is a nested box; breaks="3"
// counts a nested box as one block. The bench floats to a page foot.
const [SLIP_GAP, FRAME] = [3, 4]; // mm: between slips; the bench's frame round them
const slip = (id, body) => ({ id, background: col('paper'), marginBottom: mm(SLIP_GAP),
  padding: { top: mm(2.2), right: mm(2.6), bottom: mm(2.4), left: mm(2.6) },
  titleStyle: { fontFamily: MONO, fontSize: pt(6.6), fontWeight: 600, color: col('muted'),
    gap: mm(1.6) }, // code keeps its case: textAlign, not TEXTALIGN
  body: { fontSize: pt(8.6), lineHeight: pt(11.6), firstLineIndent: pt(0), ...body } });
const calloutStyles = [
  { id: 'bench', span: 'page', placement: 'bottom', background: col('graphite'),
    columnGap: mm(FRAME), // the foot needs a FRAME too: the last slip's marginBottom is dropped
    padding: { top: mm(3.4), right: mm(FRAME), bottom: mm(FRAME), left: mm(FRAME) },
    titleStyle: { ...caps(7.5, 600), color: col('marker'), gap: mm(2.4) },
    body: { fontSize: pt(8.6), lineHeight: pt(11.6), color: col('paper'), textAlign: 'left',
      firstLineIndent: pt(0) } },
  slip('ragged', { textAlign: 'left' }), // ragged text keeps its words whole by default
  slip('unhyphenated', { hyphenation: false }), // justified, like the body text
  slip('justified', {}), // justified and hyphenated: the body text's own settings
  { id: 'settings', backgroundEnabled: false, marginTop: pt(3), marginBottom: pt(3), // config
    stripe: { enabled: true, side: 'left', width: pt(2), color: col('graphite') },
    padding: { top: pt(1), right: pt(0), bottom: pt(1), left: mm(3) },
    body: { fontFamily: MONO, fontSize: pt(7), lineHeight: pt(9.5), color: col('graphite'),
      firstLineIndent: pt(0) } },
];

Um boxe compõe todas as colunas de um grupo :::columns com um só estilo de texto, de modo que cada ficha é um boxe aninhado com o próprio body, e breaks="3" empilha na primeira coluna a ficha alinhada à esquerda e a ficha sem hifenização. A ficha alinhada à esquerda dispensa hyphenation: false: texto alinhado à esquerda só é hifenizado quando bodyText.hyphenation.ragged está ativado. A bancada flutua para o pé da página 3 com placement: 'bottom', e o espaçamento interno inferior repete a moldura de 4 mm porque o marginBottom da última ficha é descartado no fim do boxe.

#5 · Desenhe o modelo na abertura

script.js · linhas 59–87no código completo
const BAND = 104; // mm from the trim's top edge to the band's foot
const DIAGRAM = { y: 64, w: MEASURE + 8, h: 34 }; // mm: its top on the page, width, height
const LABEL = 7; // pt: the diagram's labels, tracked less than caps() so the legend fits
const text = (id, content, family, size, color, x, y, extra) => ({ kind: 'text', id, content,
  fontFamily: family, fontSize: pt(size), color: col(color), align: 'left', overflow: 'wrap',
  placement: { anchor: { to: 'page', edge: 'top-left' }, offset: { x: mm(x), y: mm(y) },
    size: { width: mm(MEASURE) } }, ...extra });
const opener = () => ({ // a function: the diagram's constants are defined further down
  enabled: true,
  slot: { elements: [
    // The band reaches below the diagram, so it sets the height the opener reserves; the H1's
    // default marginBottom adds a line of white, and the body starts on the second grid line
    // under the band.
    { kind: 'box', id: 'band', style: { backgroundColor: col('graphite') },
      placement: { anchor: { to: 'bleed', edge: 'top-left' },
        size: { width: 'fill', height: mm(BAND) } } },
    text('kicker', '{attr.kicker}', MONO, 7.5, 'marker', INNER, TOP, caps(7.5, 600)),
    text('title', '{titleText}', DISPLAY, 29, 'paper', INNER, TOP + 5, // one line in both
      { fontWeight: 800, lineHeight: 1.02 }),
    text('standfirst', '{attr.standfirst}', TEXT, 10.5, 'haze', INNER, TOP + 19,
      { italic: true, lineHeight: 1.3 }),
    { kind: 'image', id: 'diagram', resourceId: 'diagram', placement: { anchor: { to: 'page',
      edge: 'top-left' }, offset: { x: mm(INNER), y: mm(DIAGRAM.y) },
    size: { width: mm(DIAGRAM.w), height: mm(DIAGRAM.h) } } },
    // The diagram's labels are design text: set and tracked like the opener's other labels.
    ...diagramLabels().map(([id, words, x, y]) => text(id, words, MONO, LABEL, 'haze',
      INNER + x, DIAGRAM.y + y, { ...caps(LABEL), letterSpacing: pt(0.5) })),
  ] },
});

O diagrama é um elemento de imagem do design do H1. Como figura, seria um flutuante top na largura da página, e um flutuante top citado na página 1 abre a página 2. A faixa desce além do diagrama, e uma abertura reserva altura até o elemento mais baixo, por isso o texto começa sob a faixa sem minHeight, uma linha mais abaixo por causa do marginBottom padrão do H1. Os rótulos são texto de design posto sobre as coordenadas do próprio desenho, composto e espacejado como os outros rótulos da abertura.

A receita completa

Sandbox
// ═══ Postext Cookbook · Nº 014 · Justification lab ════════════════════════════════
// https://postext.dev/en/cookbook/justification-lab
// Code: MIT · Text: original (CC BY 4.0) · Diagram: generated in code (CC BY 4.0)
// Fonts: Petrona, Bricolage Grotesque, Source Code Pro (SIL OFL 1.1) · Needs postext ≥ 1.34.0
// A type journal's essay set twice from one design, Knuth–Plass and greedy: the two page 2s
// side by side with their loose lines marked from the layout tree, then the published pages.
import {
  buildDocumentWithFonts, renderPageToCanvas, registerResourceImage, parseMarkdownWithIssues,
  findLooseLines,
} from 'https://esm.sh/postext';

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

// ─── 1 · Design ─────────────────────────────────────────────────────────────
// Graphite, paper and one highlighter yellow; col() links each colour to its palette entry.
const palette = {
  ink: '#1f2124', // text: a graphite near-black
  graphite: '#2e3136', // the accent: the opener band, the bench box, folios
  marker: '#ffe14d', // highlighter yellow: glue and loose lines, never type on white
  haze: '#c3c7cc', // type on graphite: the standfirst, the diagram's labels
  muted: '#66686c', // running heads, settings lines, 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: 'defaults', value: { hex: palette.graphite, model: 'hex' } }, // no blue
];
const [TEXT, DISPLAY, MONO] = ['Petrona', 'Bricolage Grotesque', 'Source Code Pro'];
const [BODY, LEAD] = [9.5, 13]; // pt: body size and leading, the grid both columns share
// mm: an A5 trim, mirrored margins and a narrow gutter: two columns of about 40 characters
const [TRIM_W, TRIM_H, TOP, BOTTOM, INNER, OUTER, GUTTER] = [148, 210, 20, 20, 16, 13, 5];
const MEASURE = TRIM_W - INNER - OUTER; // mm: 119, the text width the opener aligns to
const caps = (size, weight = 500) => ({ fontFamily: MONO, fontSize: pt(size), fontWeight: weight,
  letterSpacing: pt(size * 0.16), textTransform: 'uppercase' }); // tracked mono labels

// #region answer: one design, two line breakers: Knuth–Plass inside fences, greedy without
// Knuth–Plass breaking, hyphenation and the widow, orphan and runt penalties are all on by
// default. A narrow column also needs a tighter fence round the glue, in multiples of a
// normal word space (defaults 0.6 and 2): lines past the upper fence cost more than any
// hyphen, so the breaker hyphenates or re-breaks the paragraph before it stretches that far.
const FENCES = { minWordSpacing: 0.8, maxWordSpacing: 1.6 };
const bodyText = { // config().bodyText
  fontFamily: TEXT, fontSize: pt(BODY), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  firstLineIndent: mm(4), indentAfterHeading: false, // justified and hyphenated by default
  ...FENCES,

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

#Hifenize um texto em alemão

O locale escolhe os padrões, por isso um texto em alemão leva 'de', ou uma etiqueta regional como 'de-AT'.

-const locale = t({ en: 'en-us', es: 'es' }); // config().locale: each edition's patterns
+const locale = 'de'; // German patterns; 'de-AT' picks them too

#Marque só as piores linhas

Suba o limiar de 1,6 para 2 e o marca-texto pinta só as linhas cujos espaços passaram do dobro.

-  const loose = findLooseLines(doc, { threshold: FENCES.maxWordSpacing, pageIndex: page.index });
+  const loose = findLooseLines(doc, { threshold: 2, pageIndex: page.index });

Erros comuns

Erro comum

avoidWidows cuida do pé da coluna, avoidOrphans do alto

O Postext dá nomes próprios às duas linhas isoladas: avoidWidows (widowMinLines, widowPenalty) impede que a primeira linha de um parágrafo fique sozinha no pé de uma coluna, e avoidOrphans (orphanMinLines, orphanPenalty) impede que a última fique sozinha no alto da seguinte. Muitos manuais de estilo usam os dois nomes ao contrário, então escolha a configuração pelo lugar onde ela age. As duas vêm ativadas, exceto numa grade de caracteres (cjk.grid): ali avoidWidows vem desativada, e avoidOrphans também na região do Japão, para que a página contenha as linhas que a grade conta (desde o postext 1.28). Elas funcionam como penalidades: a diagramação compara cada uma com as linhas vazias que obedecê-la deixaria. Viúvas, órfãs e linhas curtas →

Erro comum

Um flutuante 'top' vai para a página seguinte à sua citação, a menos que possa encabeçar a página que o cita

Por padrão um flutuante nunca fica acima da própria referência, então um flutuante 'top' na largura da página citado na página N abre a página N+1. Com placement.citingPage: true no recurso ou no defaultPlacement do seu tipo (ou layout.floatsAtCitingPage para o livro todo, desde o postext 1.25) ele encabeça a página N, e o texto acima da referência desce para baixo dele, quando cabe dentro de layout.maxTopFraction e a linha que o cita continua nessa página. Nunca encabeça a primeira página de um capítulo nem uma página depois de uma quebra forçada: ali continua abrindo a página seguinte, e 'auto' ou 'bottom' podem ocupar o pé da página que o cita. Posicionamento de figuras →

Verificação do Sandbox · looseLine

Linha frouxa

Por quê. Uma linha justificada estica os espaços além do limite, quase sempre por causa de uma palavra longa, uma URL ou uma medida estreita.

Correção. Ative a hifenização no idioma certo, aumente a medida, reescreva o trecho ou componha essa passagem alinhada à esquerda. Docs →

  • Um boxe que fica no fim de uma coluna desce para o pé dela quando as colunas são equilibradas, longe do parágrafo a que pertence. Ajuste o texto para que a coluna fique cheia, como foi preciso com o boxe de ajustes sob “Fences for the glue”, ou defina headings.balancing.closingBox como 'off', que nunca move o boxe.
  • A ficha sem hifenização não mostra os espaços mais largos de que precisaria. Uma linha justificada cujos espaços passariam de três vezes um espaço normal é composta alinhada à esquerda, com o espaçamento natural, num boxe tal como no texto corrido, e por isso as duas primeiras linhas da ficha terminam antes da medida. As linhas abaixo desse teto continuam justificadas, e são delas os espaços largos que a ficha mostra.

Créditos

Texto
  • The essay “The river problem” and its Spanish version “El problema de los ríos”, the bench test and the diagram, written and drawn for this recipe · Postext Cookbook · CC BY 4.0
Fontes
Petrona (SIL OFL 1.1) · Bricolage Grotesque (SIL OFL 1.1) · Source Code Pro (SIL OFL 1.1)
Sandbox