Vai al contenuto principale
Ricetta numero 184

Ricettario · Capitolo 2 · Caratteri e testo

Prosa giustificata senza ripetizioni ai margini della riga

Una pagina di Dickens composta due volte in una giustezza stretta: la prima bozza segnala e marca ogni ripetizione, la seconda la pesa nella divisione in righe.

In questa pagina
  • Esempio in inglese: non c’è ancora un’edizione italiana
  • Formato 115 × 180 mm
  • 1 colonna
  • Spectral 9,6/13,4
  • Cormorant Garamond
  • Spectral SC
  • 8 pagine
  • Livello
  • Postext 1.73.0
  • Impaginato in 36 ms
  • 180 righe di codice

In breve

Quando due righe di seguito finiscono o cominciano con la stessa parola, l’occhio può saltare alla riga sbagliata. Il libro è composto due volte: una mostra dove succede, l’altra spezza le righe perché non succeda.

Che cosa comporrai

Due bozze di una pagina tascabile di 115 × 180 mm con l’inizio di A Christmas Carol, giustificato in Spectral su una giustezza di 83 mm. Una giustezza stretta lascia poche scelte all’algoritmo che divide le righe, e in cinque punti due righe di seguito finiscono o cominciano con la stessa parola: sole sopra sole, his sopra his, No sopra No. La prima bozza è composta con stacks: 'warn'. Non cambia nessuna interruzione, segnala ogni ripetizione, marca le due parole con una banda rosso pallido e le elenca su un cartellino dopo il colophon. La seconda è composta con 'avoid', e quattro delle cinque spariscono. L’edizione spagnola compone allo stesso modo l’inizio di ¡Adiós, Cordera! di Clarín.

Questa ricetta risponde a

  • Come evito che due righe consecutive finiscano o comincino con la stessa parola?

La risposta breve

script.js · righe 41–58nel codice completo
const bodyText = {
  fontFamily: TEXT, fontSize: pt(BODY), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'justify', firstLineIndent: mm(4), indentAfterHeading: false,
  hyphenation: { enabled: true }, optimalLineBreaking: true, // stacks need the K–P breaker
  avoidWidows: true, avoidOrphans: true, avoidRunts: true,
  // A stack: two lines in a row that end on the same word or the same last characters
  // (“sole” over “sole”), or that start alike (“The” over “the”). 'warn' reports each one
  // and changes nothing; 'avoid' adds stackPenalty to the demerits of every break that
  // makes one, so the breaker sets the paragraph another way where the spacing allows.
  stacks: 'avoid', // the first proof sets 'warn' (see proofs)
  // Three characters by default; the Spanish rule counts a repeated syllable (co-/co-).
  stackMinCharacters: t({ en: 3, es: 2 }),
  // Default 3000, the cost of two hyphens in a row; a monosyllable (“his”, “lo”) costs twice.
  // 3000 kept two stacks of the first proof per edition: 10000 trades them for looser lines.
  stackPenalty: 10000,
  maxWordSpacing: 2, // the default: past it a line is never set, stack or not
};

Ingredienti

Tipo
Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1)
Risorse
  • carol-1100.jpg
  • cordera-1100.jpg
  • Painting: Scrooge's counting-house on a foggy Christmas Eve (Generated With Diffusion Models, originale)
  • Painting: Rosa, Pinín and the Cordera by the telegraph pole (Generated With Diffusion Models, originale)

Preparazione

#1 · Prima segnalare, poi pesare

script.js · righe 41–58nel codice completo
const bodyText = {
  fontFamily: TEXT, fontSize: pt(BODY), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'justify', firstLineIndent: mm(4), indentAfterHeading: false,
  hyphenation: { enabled: true }, optimalLineBreaking: true, // stacks need the K–P breaker
  avoidWidows: true, avoidOrphans: true, avoidRunts: true,
  // A stack: two lines in a row that end on the same word or the same last characters
  // (“sole” over “sole”), or that start alike (“The” over “the”). 'warn' reports each one
  // and changes nothing; 'avoid' adds stackPenalty to the demerits of every break that
  // makes one, so the breaker sets the paragraph another way where the spacing allows.
  stacks: 'avoid', // the first proof sets 'warn' (see proofs)
  // Three characters by default; the Spanish rule counts a repeated syllable (co-/co-).
  stackMinCharacters: t({ en: 3, es: 2 }),
  // Default 3000, the cost of two hyphens in a row; a monosyllable (“his”, “lo”) costs twice.
  // 3000 kept two stacks of the first proof per edition: 10000 trades them for looser lines.
  stackPenalty: 10000,
  maxWordSpacing: 2, // the default: past it a line is never set, stack or not
};

C’è ripetizione quando due righe di seguito finiscono con la stessa parola o con gli stessi ultimi caratteri, o cominciano allo stesso modo. stackMinCharacters stabilisce quanti caratteri servono: tre per impostazione predefinita, spazi compresi, senza contare accenti e maiuscole, quindi The sopra the conta. 'warn' si limita a segnalare, ed è così che il compositore vede dove un testo si ripete. 'avoid' aggiunge stackPenalty ai demeriti di ogni interruzione che ne creerebbe una, e l’algoritmo di Knuth–Plass cerca un altro modo di spezzare il paragrafo. Serve optimalLineBreaking: la divisione riga per riga non ha demeriti a cui aggiungere qualcosa.

I manuali di composizione spagnoli contano la ripetizione tra i difetti di composizione, accanto ai canaletti e alle scale di trattini. Tornando al margine sinistro, l’occhio può agganciarsi alla parola ripetuta sulla riga sbagliata e leggere due volte una riga o saltarne una; al margine destro la ripetizione suona come un’eco. La regola spagnola riguarda anche la sillaba ripetuta, non solo la parola, per questo l’edizione spagnola imposta stackMinCharacters a 2.

La penalità predefinita, 3000, è il costo di due trattini di seguito, e una parola ripetuta di una sola sillaba costa il doppio. In questa giustezza 3000 lasciava due ripetizioni in ogni edizione, perché l’alternativa era una riga più larga di quanto l’algoritmo accetti. Con 10000 accetta quelle righe. maxWordSpacing resta al valore predefinito, 2: con un limite più stretto l’algoritmo non aveva un’altra interruzione da scegliere e 'avoid' non cambiava nulla.

#2 · Marcare le ripetizioni nel testo

script.js · righe 173–201nel codice completo
// A warning names its first line by its place in the source. The repeated edge of that
// line and the next is found in each line's stretch of the source and the whole word
// around it wrapped in :mark[…]: a band under ordinary text, so the breaks stay the same.
const LETTER = /[\p{L}\p{N}’-]/u;
const edgeOf = (text, n, end) => { // the words at a line's edge holding its first/last n
  const s = text.replace(end ? /[^\p{L}\p{N}]+$/u : /^[^\p{L}\p{N}]+/u, '');
  const cut = end ? s.lastIndexOf(' ', s.length - n) + 1 : s.indexOf(' ', n);
  return end ? s.slice(cut) : s.slice(0, cut < 0 ? undefined : cut);
};
function markStacks(source, doc, stacks) {
  const lines = doc.blocks.flatMap((b) => b.lines.map((line, i) => [line, b.lines[i + 1]]));
  const spans = new Map(); // start → end of each marked word in the source
  for (const w of stacks) {
    const pair = lines.find(([line]) => line.sourceStart === w.sourceStart);
    for (const line of pair?.[1] ? pair : []) {
      const piece = edgeOf(line.text.trim(), w.text.length, w.edge === 'end');
      const range = source.slice(line.sourceStart, line.sourceEnd);
      let from = line.sourceStart
        + (w.edge === 'end' ? range.lastIndexOf(piece) : range.indexOf(piece));
      if (from < line.sourceStart) continue;
      let to = from + piece.length; // a piece of a hyphenated word takes the whole word
      while (from > 0 && LETTER.test(source[from - 1])) from--;
      while (to < source.length && LETTER.test(source[to])) to++;
      if (!/[*_[\]\n]/.test(source.slice(from, to))) spans.set(from, to);
    }
  }
  return [...spans].sort(([x], [y]) => y - x).reduce((md, [from, to]) => `${md.slice(0, from)}`
    + `:mark[${md.slice(from, to)}]{style="stack"}${md.slice(to)}`, source);
}

Ogni avviso indica la posizione nel sorgente della sua prima riga: lo script trova quella riga e la successiva nel documento composto, prende il margine ripetuto di ciascuna e avvolge la parola intera in :mark[…]. Una marcatura dipinge una banda sotto il testo normale e non tocca le interruzioni. Si marcano solo parole intere: una marcatura su una parte di parola cambia il modo in cui quella parola si divide, e allora le righe non si spezzano più dove è stato trovato l’avviso.

Prima bozza, pagina 2: sole sopra sole a fine riga, poi even sopra event e The sopra the a inizio riga.

#3 · Due bozze dallo stesso testo

script.js · righe 205–224nel codice completo
const quote = (s) => t({ en: `“${s}”`, es: `«${s}»` });
const SIDE = { end: t({ en: 'end', es: 'final' }), start: t({ en: 'start', es: 'principio' }) };
const tally = (n) => t({ en: `${n} stack${n === 1 ? '' : 's'}`,
  es: `${n} repetici${n === 1 ? 'ón' : 'ones'}` });
const byPage = (stacks) => Object.entries(Object.groupBy(stacks, (w) => w.pageIndex + 1))
  .map(([page, list]) => `${t({ en: 'p.', es: 'pág.' })} ${page}: ${list.map((w) =>
    `${quote(w.text)} (${SIDE[w.edge]})`).join(', ')}.`);
const slip = (mode, stacks) => ['', `:::callout{type="proof" title="${mode === 'warn'
  ? t({ en: 'First proof', es: 'Primeras pruebas' })
  : t({ en: 'Second proof', es: 'Segundas pruebas' })}"}`,
`${t({ en: 'Set with', es: 'Compuesto con' })} stacks: '${mode}' · ${tally(stacks.length)}.`,
...byPage(stacks).flatMap((line) => ['', line]), ':::', ''].join('\n');
const build = (md, stacks) => buildDocumentWithFonts({ markdown: md, resources },
  { ...config, bodyText: { ...bodyText, stacks } }, kitFonts(FONTS));
async function proof(mode) {
  const plain = await build(markdown, mode); // pass 1: where the stacks are
  const stacks = (plain.contentWarnings ?? []).filter((w) => w.kind === 'stack');
  return build(markStacks(markdown, plain, stacks) + slip(mode, stacks), mode); // pass 2
}
const docs = { warn: await proof('warn'), avoid: await proof('avoid') };

Ogni bozza è composta due volte. La prima composizione trova le ripetizioni. La seconda compone lo stesso testo con le marcature e un cartellino aggiunto dopo il colophon, che cade quindi sull’ultima pagina. Il pen lascia fuori dalle pagine pubblicate la prima composizione di ogni bozza, il testo senza marcature: capture.doc elenca le due composizioni marcate, [1, 3].

Seconda bozza, pagina 2: gli stessi paragrafi spezzati in un altro modo. Resta solo even sopra event.

La ripetizione che resta nell’edizione inglese è even sopra event: le due parole hanno in comune le prime tre lettere, e ogni altra divisione di quel paragrafo costava di più. In spagnolo, con due caratteri, la prima bozza trova cinque ripetizioni, tra cui co di con sopra como e ar di levantar sopra vacilar, e la seconda nessuna.

#4 · L’apertura sopra il testo

script.js · righe 62–77nel codice completo
const PICTURE = { width: MEASURE, height: 11 * LINE }; // 83 × 52 mm, the painting's 3:2
const at = (to, edge, y, size) => ({ anchor: { to, edge }, offset: { x: mm(0), y: mm(y) },
  ...(size && { size }) });
const opener = {
  enabled: true, minHeight: pt(16 * LEAD), // the text starts on the seventeenth line
  slot: { elements: [
    { kind: 'image', id: 'art', resourceId: '{attr.art}', fit: 'cover', placement: at('container',
      'top', 0, { width: mm(PICTURE.width), height: mm(PICTURE.height) }) },
    { kind: 'text', id: 'kicker', content: '{attr.kicker}', fontFamily: LABEL, fontWeight: 600,
      fontSize: pt(8.5), letterSpacing: pt(1.7), color: col('accent'), align: 'left',
      placement: at('container', 'top-left', PICTURE.height + 5.5) },
    { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY, italic: true,
      fontWeight: 500, fontSize: pt(27), lineHeight: 1.05, color: col('ink'), align: 'left',
      placement: at('#kicker', 'below', 1.5, { width: mm(MEASURE), height: 'auto' }) },
  ] },
};

L’attributo art del titolo nomina il dipinto, così un solo stile serve a entrambe le edizioni. minHeight riserva sedici righe e il testo comincia alla diciassettesima, sulla stessa griglia delle pagine seguenti.

#5 · Testatine e folio al piede

script.js · righe 81–93nel codice completo
const head = (id, content, parity, edge, x, extra = {}, y = 10.5) => ({ kind: 'text', id,
  content, parity, pages: 'body', fontFamily: LABEL, fontWeight: 500, fontSize: pt(8),
  letterSpacing: pt(1.2), color: col('muted'),
  placement: { anchor: { to: 'page', edge }, offset: { x: mm(x), y: mm(y) } }, ...extra });
const folio = { fontFamily: TEXT, letterSpacing: pt(0), color: col('ink') };
const header = { elements: [
  head('verso-folio', '{pageNumber}', 'even', 'top-left', OUTER, folio),
  head('verso-author', '{author}', 'even', 'top-left', OUTER + 8),
  head('recto-title', '{title}', 'odd', 'top-right', -(OUTER + 8)),
  head('recto-folio', '{pageNumber}', 'odd', 'top-right', -OUTER, folio),
] };
const footer = { elements: [head('drop-folio', '{pageNumber}', 'odd', 'bottom-right', -OUTER,
  { ...folio, pages: 'opener' }, -11)] }; // the opener's folio sits at the foot

L’autore va sul verso e il titolo sul recto, ciascuno accanto al suo folio. Nella pagina d’apertura le testatine spariscono e il folio scende al piede.

La ricetta completa

Sandbox
// ═══ Postext Cookbook · Nº 184 · Prose without stacks ═════════════════════════════
// https://postext.dev/en/cookbook/prose-without-stacks
// Code: MIT · Text: Dickens, 1843; Clarín, 1893 (public domain) · Paintings: diffusion model
// Fonts: Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1) · Needs postext ≥ 1.73.0
//
// A pocket edition set twice from the same text. The first proof keeps the line breaks the
// breaker finds and reports every stack (two lines in a row that end or start alike); the
// second weighs each stack in the breaker's demerits and sets the paragraph another way.
// Each proof marks its stacks in the text and lists them on a slip after the colophon.
import {
  buildDocumentWithFonts, renderPageToCanvas, registerResourceImage,
} from 'https://esm.sh/postext';

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

// ─── 1 · Design ─────────────────────────────────────────────────────────────
// #region palette: a proofreader's red pencil over a warm book ink
const palette = {
  ink: '#241f1b', // text: a warm near-black
  accent: '#8e2f1d', // kicker, the slip's stripe and label: the red of a proof pencil
  mark: '#f4cfc2', // the band under a stacked word, pale enough for ink on top
  tint: '#f5efe6', // the slip's background
  rule: '#d2c8bb', // hairlines
  muted: '#6b6158', // running heads, 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' } },
];
// #endregion
const [TEXT, LABEL, DISPLAY] = ['Spectral', 'Spectral SC', 'Cormorant Garamond'];
const [BODY, LEAD] = [9.6, 13.4]; // pt
const LINE = (LEAD * 25.4) / 72; // mm: one line, 4.73
const [TRIM_W, TRIM_H, TOP, INNER, OUTER, LINES] = [115, 180, 17, 15, 17, 30];
const MEASURE = TRIM_W - INNER - OUTER; // 83 mm: about 50 characters, a narrow pocket measure

// #region answer: stacks reported in the first proof and weighed in the second
const bodyText = {
  fontFamily: TEXT, fontSize: pt(BODY), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'justify', firstLineIndent: mm(4), indentAfterHeading: false,
  hyphenation: { enabled: true }, optimalLineBreaking: true, // stacks need the K–P breaker
  avoidWidows: true, avoidOrphans: true, avoidRunts: true,
  // A stack: two lines in a row that end on the same word or the same last characters
  // (“sole” over “sole”), or that start alike (“The” over “the”). 'warn' reports each one

Lo script.js composto funziona così com’è: incollalo nello script modulo di qualsiasi pagina, oppure apri la ricetta su CodePen. Cartella della ricetta su GitHub ↗ (si apre in una nuova scheda)

Varianti

#Conta solo le parole lunghe

Tre caratteri è il valore predefinito. Con cinque, parole brevi come his e No non contano più come ripetizioni, e l’algoritmo mantiene intorno a esse le interruzioni più strette.

-  stackMinCharacters: t({ en: 3, es: 2 }),
+  stackMinCharacters: 5,

#Componi il libro con la penalità predefinita

Il valore predefinito tiene la spaziatura più stretta e accetta due ripetizioni per edizione dove evitarle allargherebbe di più una riga.

-  stackPenalty: 10000,
+  stackPenalty: 3000,

Errori frequenti

Avviso di impaginazione · stack

Ripetizione

Perché. Due righe di seguito di un paragrafo, nella stessa colonna, finiscono con la stessa parola o gli stessi ultimi bodyText.stackMinCharacters caratteri (3 per impostazione predefinita, spazi compresi), o cominciano allo stesso modo: «…della» sopra «…nella». Accenti e maiuscole non contano, e hanno ripetizioni solo le scritture che separano le parole con spazi. Con bodyText.stacks su 'warn' si segnalano tutte; su 'avoid', quelle che la divisione in righe ha tenuto perché nessuna composizione entro la spaziatura tra le parole le evitava per meno di bodyText.stackPenalty. Il motore annota ciascuna in doc.contentWarnings con il testo ripetuto, il bordo (fine o inizio), le due righe e la loro pagina.

Soluzione. Imposta bodyText.stacks su 'avoid': la divisione in righe ricompone il paragrafo dove la spaziatura tra le parole lo permette. Una ripetizione che resta costa più di bodyText.stackPenalty da evitare: alza la penalità per scambiarla con righe più larghe, o riformula una delle due righe. Nel port di un libro esistente lascia 'warn': il port riproduce le divisioni dell’originale. Documentazione →

  • Le ripetizioni si cercano nelle righe già spezzate. Se cambi il formato, il corpo o il testo, la prima bozza ne trova altre: leggi gli avvisi di ogni composizione e non copiare le posizioni da una precedente.
  • Le ripetizioni si contano all’interno di un paragrafo e solo nelle scritture che separano le parole con spazi: due paragrafi che cominciano entrambi con Scrooge non fanno ripetizione, e un testo cinese o giapponese non ne segnala mai.

Crediti

Testo
Immagini
  • Painting: Scrooge's counting-house on a foggy Christmas Eve · Generated With Diffusion Models · originale
  • Painting: Rosa, Pinín and the Cordera by the telegraph pole · Generated With Diffusion Models · originale
Font
Spectral (SIL OFL 1.1) · Spectral SC (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1)
Sandbox