Zum Hauptinhalt springen
Rezept Nummer 184

Rezepte · Kapitel 2 · Schrift und Text

Blocksatz ohne Wortwiederholungen am Zeilenrand

Eine Seite Dickens, zweimal in schmaler Satzbreite gesetzt: Die erste Korrektur meldet und markiert jede Wiederholung, die zweite gewichtet sie im Umbruch.

Auf dieser Seite
Ausgabe
Canvas
Stufe
Mittel
Postext
Getestet mit Postext 1.73.0
Erfordert ≥ 1.73.0
Lizenz
Aktualisiert am 10. Nov. 2026
Code MIT · Text CC BY 4.0

S. 1 von 8

  • Englisches Beispiel: noch keine deutsche Ausgabe
  • Endformat 115 × 180 mm
  • 1 Spalte
  • Spectral 9,6/13,4
  • Cormorant Garamond
  • Spectral SC
  • 8 Seiten
  • Stufe
  • Postext 1.73.0
  • In 36 ms gesetzt
  • 180 Zeilen Code

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

script.js · Zeilen 41–58im vollständigen Code
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

Schrift
Spectral, Spectral SC, Cormorant Garamond (SIL OFL 1.1)
Dateien
  • carol-1100.jpg
  • cordera-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

script.js · Zeilen 41–58im vollständigen Code
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

script.js · Zeilen 173–201im vollständigen Code
// 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.

Erste Korrektur, Seite 2: sole über sole am Zeilenende, dann even über event und The über the am Zeilenanfang.

#3 · Zwei Korrekturen aus einem Text

script.js · Zeilen 205–224im vollständigen Code
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].

Zweite Korrektur, Seite 2: dieselben Absätze, anders umbrochen. Nur even über event bleibt.

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

script.js · Zeilen 62–77im vollständigen Code
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

script.js · Zeilen 81–93im vollständigen Code
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

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

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

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)
Sandbox