Saltar al contenido principal
Receta número 184

Recetario · Capítulo 2 · Texto y tipografía

Prosa justificada sin repeticiones en los bordes de línea

Una página de Clarín compuesta dos veces en una medida estrecha: las primeras pruebas señalan cada repetición; las segundas la pesan en el corte de líneas.

En esta página
  • Formato 115 × 180 mm
  • 1 columna
  • Spectral 9,6/13,4
  • Cormorant Garamond
  • Spectral SC
  • 8 páginas
  • Nivel
  • Postext 1.73.0
  • Compuesto en 33 ms
  • 180 líneas de código

En pocas palabras

Cuando dos líneas seguidas acaban o empiezan con la misma palabra, la vista puede saltar a la línea equivocada. El libro se compone dos veces: una enseña dónde pasa y otra corta las líneas para que no pase.

Lo que vas a componer

Dos pruebas de una página de bolsillo de 115 × 180 mm con el comienzo de ¡Adiós, Cordera!, de Clarín, justificado en Spectral sobre una medida de 83 mm. Una medida estrecha deja al cortador de líneas pocas salidas, y en cinco sitios dos líneas seguidas acaban o empiezan igual: con sobre como, lo sobre los, levantar sobre vacilar. Las primeras pruebas se componen con stacks: 'warn': no cambian ningún corte, avisan de cada repetición, marcan las dos palabras con una banda rojo pálido y las listan en una papeleta tras el colofón. Las segundas se componen con 'avoid', y las cinco desaparecen. La edición inglesa compone igual el comienzo de A Christmas Carol.

Esta receta responde a

  • ¿Cómo evito que dos líneas seguidas terminen o empiecen con la misma palabra?

La respuesta corta

script.js · líneas 41–58en el código 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
};

Ingredientes

Tipografía
Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1)
Recursos
  • carol-1100.jpg
  • cordera-1100.jpg
  • Pintura: el despacho de Scrooge en una Nochebuena de niebla (Generated With Diffusion Models, original)
  • Pintura: Rosa, Pinín y la Cordera junto al poste del telégrafo (Generated With Diffusion Models, original)

Elaboración

#1 · Primero avisar, después pesar

script.js · líneas 41–58en el código 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
};

Hay repetición cuando dos líneas seguidas acaban en la misma palabra o en los mismos últimos caracteres, o empiezan igual. stackMinCharacters fija cuántos caracteres hacen falta: tres por omisión, con los espacios, sin contar tildes ni mayúsculas, de modo que Los sobre los cuenta. 'warn' solo avisa, y así ve quien compone dónde se repite un texto. 'avoid' suma stackPenalty a los deméritos de cada corte que produciría una repetición, y el cortador de Knuth–Plass busca otra forma de partir el párrafo. Necesita optimalLineBreaking: el cortador voraz no tiene deméritos a los que sumar nada.

Los manuales de composición en español cuentan la repetición entre los vicios de composición, junto a los ríos y las escaleras de guiones. Al volver al margen izquierdo, la vista puede engancharse a la palabra repetida en la línea equivocada y leer dos veces una línea o saltarse otra; en el margen derecho, la repetición suena a eco. La norma española alcanza también a la sílaba repetida, no solo a la palabra, y por eso la edición española fija stackMinCharacters en 2.

La penalización por omisión, 3000, es lo que cuestan dos guiones seguidos, y una palabra repetida de una sola sílaba cuesta el doble. En esta medida, 3000 dejaba dos repeticiones en cada edición, porque la alternativa era una línea más abierta de lo que el cortador acepta. Con 10000 acepta esas líneas. maxWordSpacing se queda en su valor por omisión, 2: con un límite más estrecho el cortador no tenía otro corte que elegir y 'avoid' no cambiaba nada.

#2 · Marcar las repeticiones en el texto

script.js · líneas 173–201en el código 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);
}

Cada aviso da la posición en el texto fuente de su primera línea, así que el script busca esa línea y la siguiente en el documento compuesto, toma el borde repetido de cada una y envuelve la palabra entera en :mark[…]. Una marca pinta una banda bajo el texto normal y no toca los cortes. Solo se marcan palabras enteras: una marca sobre media palabra cambia cómo se divide esa palabra, y entonces las líneas ya no se cortan donde se encontró el aviso.

Primeras pruebas, página 2: con sobre como y lo sobre los, al principio de línea.

#3 · Dos pruebas de un mismo texto

script.js · líneas 205–224en el código 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') };

Cada prueba se compone dos veces. La primera composición encuentra las repeticiones. La segunda compone el mismo texto con las marcas y una papeleta añadida tras el colofón, de modo que la papeleta cae en la última página. El pen deja fuera de las páginas publicadas la primera composición de cada prueba, el texto sin marcar: capture.doc lista las dos composiciones marcadas, [1, 3].

Segundas pruebas, página 2: los mismos párrafos cortados de otra manera, sin ninguna repetición.

En la edición inglesa, con tres caracteres, queda una: even sobre event, que comparten sus tres primeras letras, porque cualquier otro corte de ese párrafo costaba más.

#4 · La apertura sobre el texto

script.js · líneas 62–77en el código 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' }) },
  ] },
};

El atributo art del título nombra la pintura, así que un solo estilo sirve a las dos ediciones. minHeight reserva dieciséis líneas y el texto empieza en la decimoséptima, sobre la misma retícula que las páginas siguientes.

#5 · Titulillos y folio caído

script.js · líneas 81–93en el código 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

El autor va en la página par y el título en la impar, cada uno junto a su folio. En la apertura no hay titulillos y el folio baja al pie.

La receta 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 = 'es'; // @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

El script.js compuesto funciona tal cual: pégalo como script de módulo en cualquier página o abre la receta en CodePen. Carpeta de la receta en GitHub ↗ (se abre en una nueva pestaña)

Variantes

#Contar solo palabras largas

Con cinco caracteres, palabras cortas como lo o los dejan de contar como repetición, y el cortador mantiene los cortes más apretados alrededor de ellas.

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

#Componer con la penalización por omisión

La penalización por omisión aprieta más el espaciado y acepta dos repeticiones por edición donde evitarlas abriría más una línea.

-  stackPenalty: 10000,
+  stackPenalty: 3000,

Errores frecuentes

Aviso de maquetación · stack

Repetición

Por qué. Dos líneas seguidas de un párrafo, en una misma columna, terminan con la misma palabra o los mismos últimos bodyText.stackMinCharacters caracteres (3 por defecto, espacios incluidos), o empiezan igual: «…en la» sobre «…de la». No cuentan las tildes ni las mayúsculas, y solo hay repeticiones en las escrituras que separan las palabras con espacios. Con bodyText.stacks en 'warn' se informa de todas; en 'avoid', de las que el corte de líneas mantuvo porque ninguna composición dentro del espaciado entre palabras las evitaba por menos que bodyText.stackPenalty. El motor anota cada una en doc.contentWarnings con el texto repetido, el extremo (final o comienzo), las dos líneas y su página.

Solución. Pon bodyText.stacks en 'avoid': el corte de líneas compone el párrafo de otro modo donde el espaciado entre palabras lo permite. Una repetición que sigue cuesta más de evitar que bodyText.stackPenalty: sube la penalización para cambiarla por líneas más sueltas, o reescribe una de las dos líneas. En un port de un libro existente deja 'warn': el port reproduce los cortes del original. Documentación →

  • Las repeticiones se buscan en las líneas ya cortadas. Si cambias el formato, el cuerpo o el texto, las primeras pruebas encuentran otras, así que lee los avisos de cada composición y no copies posiciones de una anterior.
  • Las repeticiones se cuentan dentro de un párrafo y solo en escrituras que separan las palabras con espacios: dos párrafos que empiezan con Rosa no hacen repetición, y un texto en chino o en japonés nunca avisa de ninguna.

Créditos

Texto
  • Cuento de Navidad (A Christmas Carol, 1843), el comienzo de la primera estrofa, del eBook n.º 46 de Project Gutenberg, con comillas y rayas tipográficas · Charles Dickens · dominio público
  • ¡Adiós, Cordera!, el comienzo del cuento, de El Señor y lo demás son cuentos (Madrid, 1919), con comillas « » · Leopoldo Alas, Clarín · dominio público
Imágenes
  • Pintura: el despacho de Scrooge en una Nochebuena de niebla · Generated With Diffusion Models · original
  • Pintura: Rosa, Pinín y la Cordera junto al poste del telégrafo · Generated With Diffusion Models · original
Fuentes
Spectral (SIL OFL 1.1) · Spectral SC (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1)
Sandbox