En bref
Quand deux lignes de suite finissent ou commencent par le même mot, l’œil peut sauter à la mauvaise ligne. Le livre est composé deux fois : une fois pour montrer où cela arrive, une fois avec des lignes coupées pour l’éviter.
Ce que vous allez composer
Deux épreuves d’une page de poche de 115 × 180 mm, avec le début d’A Christmas Carol justifié en Spectral sur 83 mm. Une justification étroite laisse peu de choix à l’algorithme de coupure, et à cinq endroits deux lignes de suite finissent ou commencent par le même mot : sole sur sole, his sur his, No sur No. La première épreuve est composée avec stacks: 'warn'. Elle ne change aucune coupure, signale chaque répétition, marque les deux mots d’une bande rouge pâle et les liste sur un bulletin après le colophon. La seconde est composée avec 'avoid', et quatre des cinq disparaissent. L’édition espagnole compose de la même façon le début d’¡Adiós, Cordera! de Clarín.
Cette recette répond à
- Comment éviter que deux lignes consécutives finissent ou commencent par le même mot ?
La réponse courte
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
};
Ingrédients
- Fonctionnalités
- Répétitions en début et en fin de ligneCoupure optimale des lignes (Knuth–Plass)Césure et langue du documentVeuves, orphelines et fins de paragraphe trop courtesTexte courantOuvertures composéesImages dans les maquettes de pageAttributs de titreTitres courants et foliosTitres courants selon le rôle de la pageMarges en miroirEncadrésStyles de paragraphePalette de couleurs sémantique
- Utilise aussi
- SurlignagesFigures et tableaux comme ressources
- Typographie
- Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1)
- Ressources
carol-1100.jpgcordera-1100.jpg- Painting: Scrooge's counting-house on a foggy Christmas Eve (Generated With Diffusion Models, original)
- Painting: Rosa, Pinín and the Cordera by the telegraph pole (Generated With Diffusion Models, original)
Préparation
#1 · Signaler d’abord, peser ensuite
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
};
Il y a répétition quand deux lignes de suite finissent par le même mot ou les mêmes derniers caractères, ou commencent de la même façon. stackMinCharacters fixe le nombre de caractères requis : trois par défaut, espaces compris, sans tenir compte des accents ni de la casse, si bien que The sur the compte. 'warn' se contente de signaler, et le compositeur voit ainsi où un texte se répète. 'avoid' ajoute stackPenalty aux démérites de chaque coupure qui en créerait une, et l’algorithme de Knuth–Plass cherche une autre façon de couper le paragraphe. Il faut optimalLineBreaking : la coupure gloutonne n’a pas de démérites auxquels ajouter quoi que ce soit.
Les manuels de composition espagnols comptent la répétition parmi les défauts de composition, avec les lézardes et les échelles de traits d’union. En revenant à la marge de gauche, l’œil peut s’accrocher au mot répété sur la mauvaise ligne et lire une ligne deux fois ou en sauter une ; à droite, la répétition sonne comme un écho. La règle espagnole vise aussi la syllabe répétée, pas seulement le mot, d’où stackMinCharacters à 2 dans l’édition espagnole.
La pénalité par défaut, 3000, est ce que coûtent deux traits d’union de suite, et un mot répété d’une seule syllabe coûte le double. Dans cette justification, 3000 laissait deux répétitions dans chaque édition, car l’autre choix était une ligne plus lâche que ce que l’algorithme accepte. À 10000, il accepte ces lignes. maxWordSpacing reste à sa valeur par défaut, 2 : avec une limite plus serrée, l’algorithme n’avait aucune autre coupure à choisir et 'avoid' ne changeait rien.
#2 · Marquer les répétitions dans le texte
// 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);
}
Chaque avertissement donne la position de sa première ligne dans la source : le script retrouve cette ligne et la suivante dans le document composé, prend le bord répété de chacune et enveloppe le mot entier dans :mark[…]. Une marque peint une bande sous un texte ordinaire et ne touche pas aux coupures. Seuls des mots entiers sont marqués : une marque sur une partie de mot change la façon dont ce mot se coupe, et les lignes ne se coupent plus là où l’avertissement a été trouvé.

#3 · Deux épreuves d’un même texte
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') };
Chaque épreuve est composée deux fois. La première composition trouve les répétitions. La seconde compose le même texte avec les marques et un bulletin ajouté après le colophon, qui tombe donc sur la dernière page. Le pen écarte des pages publiées la première composition de chaque épreuve, le texte sans marques : capture.doc liste les deux compositions marquées, [1, 3].

La répétition qui reste dans l’édition anglaise est even sur event : les deux mots ont les mêmes trois premières lettres, et toute autre coupure de ce paragraphe coûtait plus. En espagnol, avec deux caractères, la première épreuve trouve cinq répétitions, dont co de con sur como et ar de levantar sur vacilar, et la seconde n’en a aucune.
#4 · L’ouverture au-dessus du texte
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’attribut art du titre nomme la peinture, si bien qu’un seul style sert aux deux éditions. minHeight réserve seize lignes et le texte commence à la dix-septième, sur la même grille que les pages suivantes.
#5 · Titres courants et folio en pied
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’auteur va au verso et le titre au recto, chacun à côté de son folio. Sur l’ouverture, les titres courants disparaissent et le folio descend en pied de page.
La recette complète
// ═══ 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
Le script.js composé s’exécute tel quel : collez-le dans le script de module de n’importe quelle page, ou ouvrez la recette sur CodePen. Dossier de la recette sur GitHub ↗ (s’ouvre dans un nouvel onglet)
Variantes
#Ne compter que les mots longs
Trois caractères, c’est la valeur par défaut. À cinq, des mots courts comme his et No ne comptent plus comme répétitions, et l’algorithme garde autour d’eux les coupures plus serrées.
- stackMinCharacters: t({ en: 3, es: 2 }),
+ stackMinCharacters: 5,#Composer le livre avec la pénalité par défaut
La valeur par défaut garde un espacement plus serré et accepte deux répétitions par édition là où les éviter ouvrirait davantage une ligne.
- stackPenalty: 10000,
+ stackPenalty: 3000,Erreurs fréquentes
Avertissement de mise en page · stack
Répétition
Pourquoi. Deux lignes de suite d’un paragraphe, dans une même colonne, finissent sur le même mot ou les mêmes derniers bodyText.stackMinCharacters caractères (3 par défaut, espaces compris), ou commencent de même : « …de la » sous « …à la ». Les accents et la casse ne comptent pas, et seules les écritures qui séparent les mots par des espaces ont des répétitions. Avec bodyText.stacks sur 'warn', toutes sont signalées ; sur 'avoid', celles que la coupure des lignes a gardées parce qu’aucune composition dans l’espacement des mots ne les évitait pour moins que bodyText.stackPenalty. Le moteur note chacune dans doc.contentWarnings avec le texte répété, le bord (fin ou début), les deux lignes et leur page.
Correction. Réglez bodyText.stacks sur 'avoid' : la coupure des lignes recompose le paragraphe là où l’espacement des mots le permet. Une répétition qui reste coûte plus à éviter que bodyText.stackPenalty : augmentez la pénalité pour l’échanger contre des lignes plus lâches, ou reformulez l’une des deux lignes. Dans le portage d’un livre existant, gardez 'warn' : le portage reproduit les coupures de l’original. Docs →
- Les répétitions se cherchent dans les lignes déjà coupées. Changez le format, le corps ou le texte et la première épreuve en trouve d’autres : lisez les avertissements de chaque composition et ne recopiez pas les positions d’une composition antérieure.
- Les répétitions se comptent à l’intérieur d’un paragraphe, et seulement dans les écritures qui séparent les mots par des espaces : deux paragraphes qui commencent tous deux par Scrooge ne font pas de répétition, et un texte chinois ou japonais n’en signale jamais.
Crédits
- Recette
- Ignacio Ferro
- Texte
- A Christmas Carol (1843), the opening of Stave One, from Project Gutenberg eBook #46, with typographic quotes and dashes · Charles Dickens · domaine public
- ¡Adiós, Cordera!, the opening of the story, from El Señor y lo demás son cuentos (Madrid, 1919), with « » quotation marks · Leopoldo Alas, Clarín · domaine public
- Images
- Painting: Scrooge's counting-house on a foggy Christmas Eve · Generated With Diffusion Models · original
- Painting: Rosa, Pinín and the Cordera by the telegraph pole · Generated With Diffusion Models · original
- Polices
- Spectral (SIL OFL 1.1) · Spectral SC (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1)
Modifier ce texte ↗ (s’ouvre dans un nouvel onglet)Dossier de la recette sur GitHub ↗ (s’ouvre dans un nouvel onglet)


