Kurz gesagt
Wenn zwei Zeilen hintereinander mit demselben Wort enden oder beginnen, kann das Auge in die falsche Zeile springen. Das Buch wird zweimal gesetzt: einmal mit den Stellen markiert, einmal so umbrochen, dass es nicht passiert.
Was Sie setzen
Zwei Korrekturabzüge einer Taschenbuchseite von 115 × 180 mm mit dem Anfang von A Christmas Carol, im Blocksatz aus der Spectral auf 83 mm Satzbreite. Eine schmale Satzbreite lässt dem Zeilenumbruch wenig Spielraum, und an fünf Stellen enden oder beginnen zwei Zeilen hintereinander mit demselben Wort: sole über sole, his über his, No über No. Die erste Korrektur wird mit stacks: 'warn' gesetzt. Sie ändert keinen Umbruch, meldet jede Wiederholung, markiert beide Wörter mit einem blassroten Band und listet sie auf einem Zettel nach dem Kolophon. Die zweite wird mit 'avoid' gesetzt, und vier der fünf verschwinden. Die spanische Ausgabe setzt den Anfang von Claríns ¡Adiós, Cordera! auf dieselbe Weise.
Dieses Rezept beantwortet
- Wie verhindere ich, dass zwei aufeinanderfolgende Zeilen mit demselben Wort enden oder beginnen?
Die kurze Antwort
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
};
Zutaten
- Funktionen
- Wiederholungen an Zeilenanfang und ZeilenendeOptimaler Zeilenumbruch (Knuth-Plass)Silbentrennung und DokumentspracheWitwen, Waisen und kurze AusgangszeilenGrundschriftGestaltete AuftakteBilder in SeitengestaltungenÜberschriftenattributeKolumnentitel und SeitenzahlenKopfzeilen nach SeitenrolleGespiegelte RänderKästenAbsatzformateSemantische Farbpalette
- Nutzt außerdem
- HervorhebungenAbbildungen und Tabellen als Ressourcen
- Schrift
- Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1)
- Dateien
carol-1100.jpgcordera-1100.jpg- Painting: Scrooge's counting-house on a foggy Christmas Eve (Generated With Diffusion Models, eigener Text)
- Painting: Rosa, Pinín and the Cordera by the telegraph pole (Generated With Diffusion Models, eigener Text)
Zubereitung
#1 · Erst melden, dann gewichten
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
};
Eine Wiederholung liegt vor, wenn zwei Zeilen hintereinander mit demselben Wort oder denselben letzten Zeichen enden oder gleich beginnen. stackMinCharacters legt fest, wie viele Zeichen dafür nötig sind: drei in der Voreinstellung, Leerzeichen mitgezählt, Akzente und Groß- und Kleinschreibung nicht, sodass The über the zählt. 'warn' meldet nur, so sieht der Setzer zuerst, wo sich ein Text wiederholt. 'avoid' schlägt stackPenalty auf die Kosten jedes Umbruchs, der eine Wiederholung erzeugen würde, und der Knuth–Plass-Umbruch sucht einen anderen Weg durch den Absatz. Dafür braucht es optimalLineBreaking: Der zeilenweise Umbruch hat keine Kosten, auf die sich etwas aufschlagen ließe.
Spanische Satzhandbücher zählen die Wiederholung zu den Satzfehlern, neben Gießbächen und Trennstrichtreppen. Wenn das Auge an den linken Rand zurückkehrt, kann es sich am wiederholten Wort in der falschen Zeile festhalten und eine Zeile zweimal lesen oder eine überspringen; am rechten Rand klingt die Wiederholung wie ein Echo. Die spanische Regel erfasst auch eine wiederholte Silbe, nicht nur ein Wort, deshalb setzt die spanische Ausgabe stackMinCharacters auf 2.
Die voreingestellte Strafe, 3000, entspricht den Kosten zweier Trennstriche hintereinander, und ein wiederholtes einsilbiges Wort kostet das Doppelte. In dieser Satzbreite ließ 3000 in jeder Ausgabe zwei Wiederholungen stehen, weil die Alternative eine Zeile gewesen wäre, die lockerer ist, als der Umbruch sie annimmt. Bei 10000 nimmt er diese Zeilen in Kauf. maxWordSpacing bleibt auf dem Standardwert 2: Mit einer engeren Grenze hatte der Umbruch keinen anderen Umbruch zur Wahl, und 'avoid' änderte nichts.
#2 · Die Wiederholungen im Text markieren
// 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);
}
Jede Warnung nennt die Position ihrer ersten Zeile im Quelltext. Das Skript sucht diese Zeile und die folgende im gesetzten Dokument, nimmt jeweils den wiederholten Rand und umschließt das ganze Wort mit :mark[…]. Eine Markierung malt ein Band unter gewöhnlichen Text und lässt die Umbrüche unberührt. Markiert werden nur ganze Wörter: Eine Markierung um einen Wortteil ändert, wie das Wort getrennt wird, und dann brechen die Zeilen nicht mehr dort, wo die Warnung gefunden wurde.

#3 · Zwei Korrekturen aus einem Text
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') };
Jede Korrektur wird zweimal gesetzt. Der erste Durchgang findet die Wiederholungen. Der zweite setzt denselben Text mit den Markierungen und einem Zettel nach dem Kolophon, der so auf die letzte Seite fällt. Der Pen hält den ersten Durchgang jeder Korrektur, den unmarkierten Text, aus den veröffentlichten Seiten heraus: capture.doc listet die beiden markierten Durchgänge, [1, 3].

Die Wiederholung, die in der englischen Ausgabe bleibt, ist even über event: Beide Wörter teilen die ersten drei Buchstaben, und jeder andere Umbruch dieses Absatzes kostete mehr. Im Spanischen findet die erste Korrektur mit zwei Zeichen fünf Wiederholungen, darunter co in con über como und ar in levantar über vacilar, und die zweite keine.
#4 · Der Auftakt über dem Text
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' }) },
] },
};
Das Attribut art der Überschrift nennt das Gemälde, sodass ein Stil für beide Ausgaben reicht. minHeight hält sechzehn Zeilen frei, und der Text beginnt auf der siebzehnten, im selben Raster wie die folgenden Seiten.
#5 · Kolumnentitel und Fußpagina
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
Der Autor steht auf der linken Seite, der Titel auf der rechten, jeweils neben der Seitenzahl. Auf der Auftaktseite entfallen die Kolumnentitel, und die Seitenzahl wandert an den Fuß.
Das ganze Rezept
// ═══ 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
Das zusammengesetzte script.js läuft unverändert: Fügen Sie es in das Modulskript einer beliebigen Seite ein, oder öffnen Sie das Rezept auf CodePen. Ordner des Rezepts auf GitHub ↗ (öffnet sich in einem neuen Tab)
Varianten
#Nur längere Wörter zählen
Drei Zeichen sind die Voreinstellung. Bei fünf zählen kurze Wörter wie his und No nicht mehr als Wiederholung, und der Umbruch behält um sie herum die engeren Zeilen.
- stackMinCharacters: t({ en: 3, es: 2 }),
+ stackMinCharacters: 5,#Das Buch mit der voreingestellten Strafe setzen
Die Voreinstellung hält den Satz enger und lässt zwei Wiederholungen je Ausgabe stehen, wo ihre Vermeidung eine Zeile weiter öffnen würde.
- stackPenalty: 10000,
+ stackPenalty: 3000,Häufige Fehler
Layoutwarnung · stack
Wiederholung
Ursache. Zwei Zeilen hintereinander eines Absatzes in derselben Spalte enden auf dasselbe Wort oder dieselben letzten bodyText.stackMinCharacters Zeichen (standardmäßig 3, Leerzeichen mitgezählt) oder beginnen gleich: „…in der“ über „…an der“. Akzente und Groß- und Kleinschreibung zählen nicht, und nur Schriften, die Wörter mit Leerzeichen trennen, haben Wiederholungen. Mit bodyText.stacks auf 'warn' wird jede gemeldet; auf 'avoid' die, die der Zeilenumbruch behielt, weil kein Satz innerhalb des Wortabstands sie für weniger als bodyText.stackPenalty vermied. Die Engine trägt jede in doc.contentWarnings ein, mit dem wiederholten Text, dem Rand (Ende oder Anfang), den beiden Zeilen und ihrer Seite.
Lösung. Setzen Sie bodyText.stacks auf 'avoid': Der Zeilenumbruch setzt den Absatz anders, wo der Wortabstand es erlaubt. Eine Wiederholung, die bleibt, kostet mehr als bodyText.stackPenalty: Erhöhen Sie den Strafwert, um sie gegen lockerere Zeilen zu tauschen, oder formulieren Sie eine der beiden Zeilen um. Bei der Portierung eines bestehenden Buchs bleiben Sie bei 'warn': Die Portierung gibt die Umbrüche des Originals wieder. Doku →
- Wiederholungen werden in den fertig umbrochenen Zeilen gesucht. Ändern Sie Format, Schriftgrad oder Text, findet die erste Korrektur andere. Lesen Sie die Warnungen jedes Durchgangs und übernehmen Sie keine Positionen aus einem früheren.
- Wiederholungen zählen nur innerhalb eines Absatzes und nur in Schriften, die Wörter durch Leerzeichen trennen: Zwei Absätze, die beide mit Scrooge beginnen, ergeben keine Wiederholung, und chinesischer oder japanischer Text meldet nie eine.
Nachweise
- Rezept
- Ignacio Ferro
- Text
- A Christmas Carol (1843), the opening of Stave One, from Project Gutenberg eBook #46, with typographic quotes and dashes · Charles Dickens · gemeinfrei
- ¡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 · gemeinfrei
- Bilder
- Painting: Scrooge's counting-house on a foggy Christmas Eve · Generated With Diffusion Models · eigener Text
- Painting: Rosa, Pinín and the Cordera by the telegraph pole · Generated With Diffusion Models · eigener Text
- Schriften
- Spectral (SIL OFL 1.1) · Spectral SC (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1)
- Code
- MIT, wie Postext
Diesen Text bearbeiten ↗ (öffnet sich in einem neuen Tab)Ordner des Rezepts auf GitHub ↗ (öffnet sich in einem neuen Tab)


