Configurazione: stili e parti

#Stili di paragrafo

La proprietà paragraphStyles dichiara stili con nome che un documento applica a una serie di paragrafi con un contenitore :::paragraphs{style="…"}: bibliografie, glossari, note, qualunque blocco di voci che voglia un proprio carattere, peso, inclinazione, corpo, interlinea, maiuscole, maiuscoletto o un rientro sporgente. Ogni campo tipografico è facoltativo e, se non è impostato, eredita dal testo corrente, quindi uno stile esplicita solo ciò che differisce dal testo corrente.

const config: PostextConfig = {
  paragraphStyles: [
    {
      id: 'bibliography',
      name: 'Bibliography',
      fontSize: { value: 7, unit: 'pt' },
      lineHeight: { value: 1.2, unit: 'em' },
      hangingIndent: { value: 2, unit: 'em' },
      spaceBetween: { value: 0.25, unit: 'em' },
      marginTop: { value: 1, unit: 'em' },
      marginBottom: { value: 1, unit: 'em' },
    },
  ],
};

## References
 
:::paragraphs{style="bibliography"}
Knuth, D. E. (1984). *The TeXbook*. Addison-Wesley.
 
Bringhurst, R. (2004). *The Elements of Typographic Style*. Hartley & Marks.
:::

Un testo teatrale compone le didascalie di scena in corsivo e l’elenco dei personaggi in maiuscoletto:

paragraphStyles: [
  { id: 'direction', italic: true, fontSize: { value: 9, unit: 'pt' } },
  { id: 'cast', smallCaps: true, textAlign: 'center', fontWeight: 600 },
],

:::paragraphs{style="direction"}
Elsinore. A platform before the castle. *Francisco* at his post.
:::

La didascalia esce in corsivo e il nome al suo interno in tondo; i pesi, italic e smallCaps di uno stile valgono anche dentro i riquadri.

Un libro di versi rientra alcune righe e fa sporgere la continuazione di un verso troppo lungo per la giustezza più in profondità del verso stesso. indent sposta verso l’interno ogni riga del paragrafo, e il rientro sporgente si conta da lì:

paragraphStyles: [
  { id: 'verse', textAlign: 'left', firstLineIndent: { value: 0, unit: 'em' }, hangingIndent: { value: 4, unit: 'em' } },
  { id: 'verse-indented', textAlign: 'left', indent: { value: 1.5, unit: 'em' }, hangingIndent: { value: 2.5, unit: 'em' } },
],

Un verso in verse-indented comincia a 1,5 em e la sua continuazione a 4 em, allineata con le continuazioni dei versi in verse. Senza indent uno stile può rientrare la prima riga o far sporgere le altre, non entrambe le cose: firstLineIndent viene ignorato appena si imposta hangingIndent.

Un menu allinea ogni prezzo alla fine della giustezza, dietro una linea guida di punti:

paragraphStyles: [
  {
    id: 'menu',
    textAlign: 'left',
    firstLineIndent: { value: 0, unit: 'em' },
    tabStops: [{ position: 'end', align: 'end', leader: '. ' }],
  },
],

:::paragraphs{style="menu"}
Onion soup :tab 8.50
 
Grilled sea bream with fennel and lemon :tab 21.00
:::

I punti di ogni riga finiscono mezzo em prima del prezzo (leaderGap). Un piatto troppo lungo per la sua riga va a capo, e la sua ultima riga mantiene la linea guida e il prezzo; quando il prezzo non entra accanto all’ultima parola, quella parola scende con lui.

#Il contenitore :::paragraphs

Una riga :::paragraphs{style="<id>"} apre il contenitore e una riga ::: da sola lo chiude; ogni paragrafo compreso tra le due prende lo stile indicato, mentre titoli, elenchi e altri blocchi al suo interno mantengono il loro stile abituale. I contenitori si possono annidare dentro altri contenitori recintati. Un id di style sconosciuto non è un errore: i paragrafi vengono resi come semplice testo corrente.

La recinzione accetta anche align (start, end, left, right, center, justify), indent ed endIndent (i numeri senza unità sono em), con o senza uno stile: con uno stile, lo sostituiscono; senza, si applicano sopra lo stile del contenitore che lo racchiude, o sopra lo stile del testo nel punto in cui sta la recinzione (il testo corrente, una parte, una sezione con stile o un riquadro). :::paragraphs{align=end} compone un blocco allineato alla fine della riga (地付き) e :::paragraphs{align=end endIndent=1} un carattere prima. Da postext 1.16.

Dentro il contenitore il flusso lascia la griglia della linea di base (una voce a 7 pt con interlinea di 1,2 em non può stare su una griglia di 8 pt/1,5 em) e l’ultimo paragrafo riporta il flusso sulla griglia (vince la griglia; lo spazio sottostante è un minimo, la stessa convenzione che seguono i titoli). Le voci si dividono tra colonne e pagine come i paragrafi del testo corrente, con la stessa protezione da orfane e vedove; un titolo subito prima del contenitore resta unito al suo primo paragrafo.

Lo spazio sotto il contenitore è il maggiore tra spaceBetween e marginBottom dello stile e la spaziatura tra paragrafi del testo circostante (una riga quando bodyText.paragraphSpacing è attivo), e si fonde con lo spazio che il blocco successivo tiene sopra di sé, come fa lo spazio tra due paragrafi del testo corrente: un titolo dopo una bibliografia sta al suo marginTop sotto l’ultima voce (o allo spazio dello stile, quando questo è maggiore), e un paragrafo dopo un gruppo di voci più strette mantiene la spaziatura tra paragrafi del testo. Il flusso torna prima sulla griglia sotto il testo, e ciò che l’allineamento non ha coperto viene riportato in righe intere di griglia, così il testo dopo il contenitore cade sulla griglia. Fino a postext 1.4 lo spazio dello stile veniva messo sotto l’ultima riga prima dell’allineamento e lo spazio superiore del blocco successivo veniva aggiunto sotto di esso, e la spaziatura tra paragrafi veniva tralasciata; bodyText.paragraphContainerSpacing: 'add' mantiene quella regola, e le configurazioni salvate prima si leggono con essa. Uno stile con snapToGrid: false non si allinea: il testo dopo il contenitore sta esattamente a quello spazio sotto, fuori griglia fino al blocco successivo che si allinea. Un contenitore che si chiude su un elenco viene composto come nella 1.4 con entrambe le regole: l’elenco mantiene il proprio spazio sotto di sé, e marginBottom segue quello spazio, fondendosi con quello del blocco successivo.

Uno stile può impostare la regola per i propri contenitori con containerSpacing: 'add' nello stile di una figura grande o di un elenco di riferimenti chiude i suoi gruppi sullo spazio proprio dello stile, nel testo e dentro un riquadro, mentre ogni altro contenitore del documento mantiene 'collapse'; 'collapse' in uno stile fa il contrario in un documento che si legge con 'add'. Un contenitore che non cita nessuno stile segue il documento.

Dentro un :::callout il contenitore prende i margini del suo stile allo stesso modo: marginTop e marginBottom si fondono con la spaziatura dei blocchi attorno (uno negativo li avvicina), e un contenitore che apre il riquadro non prende margine superiore, come in cima a una colonna. Un riquadro non ha una griglia della linea di base su cui riallinearsi, quindi lo spazio sotto l’ultimo paragrafo è il maggiore tra marginBottom, spaceBetween e la spaziatura tra paragrafi propria del riquadro (il suo body.paragraphSpacing, una riga del suo testo; tralasciata con paragraphContainerSpacing: 'add'), oppure il margine superiore proprio del blocco successivo, quando è ancora maggiore; un marginBottom negativo tira invece su il blocco successivo. (Fino a postext 1.4 un contenitore dentro un riquadro ignorava entrambi i margini.)

const resolved = resolveParagraphStylesConfig(config.paragraphStyles, resolvedBodyText);
// => every unset field filled from the resolved body text
 
const minimal  = stripParagraphStylesDefaults(config.paragraphStyles);
// => undefined when the list is empty; zero margins and `name === id` dropped

#Stili dei chip

La proprietà chipStyles dichiara gli stili con nome del :chip[text]{style="…"} in linea: le caselle arrotondate e colorate di una banca di parole, un tasto della tastiera, un’etichetta (la sintassi e le sue regole di divisione in righe sono nel riferimento del formato del documento). Uno stile, chip, è presente di serie (un riempimento azzurro chiaro con un filetto sottile nel colore principale, leggermente arrotondato, il testo uguale alle parole attorno), così :chip[…] funziona senza alcuna configurazione; dichiarare chipStyles sostituisce quell’elenco predefinito. Un chip senza style, o con un id che nessuno stile dichiara, prende il primo stile.

const config: PostextConfig = {
  chipStyles: [
    { id: 'chip', name: 'Word bank' },
    {
      id: 'key',
      name: 'Keyboard key',
      background: { hex: '#fff4d6', model: 'hex' },
      borderColor: { hex: '#8a6d1f', model: 'hex' },
      borderRadius: { value: 2, unit: 'pt' },
      bold: true,
    },
  ],
};

Classify: :chip[battery] :chip[cable] :chip[switch]
 
Press :chip[Ctrl]{style="key"} + :chip[C]{style="key"}.

Le lunghezze in em della casella (paddingX, paddingY, borderRadius, borderWidth, gap) sono relative al corpo proprio del chip. La casella è una fascia che va da 0,8 em sopra a 0,25 em sotto la linea di base, ingrandita da paddingY e dal contorno; si dipinge fuori dal riquadro della riga e non cambia mai l’interlinea, quindi la griglia della linea di base regge. Quando la casella risulta più alta del passo di riga, un chip può urtare un chip della riga sopra o sotto: la Sandbox mostra un avviso «Chip che toccano la riga successiva» quando due chip su righe diverse si sovrappongono, con la sovrapposizione in punti, così puoi ridurre paddingY, il contorno o fontSize. Un chip alto senza chip sopra o sotto non viene segnalato.

Nel VDT un chip è un segmento di riga di kind: 'chip' il cui campo chip porta i tratti di testo (ciascuno con la sua stringa di font e la sua larghezza), la geometria della casella (boxWidth, ascent, descent, paddingX, borderWidth, borderRadius, i margini di distanza) e i suoi colori; il text del segmento è un segnaposto di un carattere, quindi gli offset del testo semplice e le mappe del sorgente contano un chip come un carattere.

const resolved = resolveChipStylesConfig(config.chipStyles);
// => the built-in `chip` style when unset; every field filled
 
const minimal  = stripChipStylesDefaults(config.chipStyles);
// => undefined for the built-in default; static defaults dropped
 
const style = pickChipStyle(resolved, 'key');
// => the `key` style, else the first one

#Listati di codice

La proprietà codeStyle stabilisce l’aspetto dei listati di codice: le recinzioni ``` e ~~~ del testo (vedi Formato del documento › Blocchi di codice), e il codice in linea quando chiede un carattere da codice. Un listato si compone riga per riga così com’è scritto, in un carattere monospaziato, dentro un riquadro: nessuna riga viene sillabata o giustificata, ogni spazio mantiene la sua larghezza e una tabulazione passa all’arresto successivo. Il riquadro nasce dallo stesso meccanismo di un :::callout, quindi un listato si divide tra una riga e l’altra attraverso colonne e pagine, ogni parte nel proprio riquadro, e una recinzione dentro un riquadro è un riquadro annidato in esso. Ogni proprietà è facoltativa. Da postext 1.23.

const config: PostextConfig = {
  codeStyle: {
    fontFamily: 'JetBrains Mono',
    fontSize: { value: 0.8, unit: 'em' },
    background: { hex: '#0e1116', model: 'hex' },
    color: { hex: '#d3d9df', model: 'hex' },
    padding: { top: { value: 4, unit: 'mm' }, right: { value: 5, unit: 'mm' }, bottom: { value: 4, unit: 'mm' }, left: { value: 5, unit: 'mm' } },
    borderRadius: { value: 2, unit: 'pt' },
    lineNumbers: true,
    tokens: {
      keyword: { color: { hex: '#f2b134', model: 'hex' }, bold: true },
      string: { color: { hex: '#3ddc84', model: 'hex' } },
      comment: { color: { hex: '#8a939d', model: 'hex' }, italic: true },
    },
    inline: { background: { hex: '#eef1f4', model: 'hex' } },
  },
};

#Colorazione della sintassi

Un piccolo tokenizzatore incorporato nel motore riconosce i token di js e ts (javascript, jsx, typescript, tsx), json, python, bash (sh, zsh, shell), console (una sessione di shell), css, html e xml (svg), markdown e sql; un listato in qualunque altro linguaggio, o senza linguaggio, si compone in color. Legge l’intero listato, quindi un commento o una stringa che prosegue su più righe resta un solo token. In un listato console, una riga che si apre con un prompt ($ , % , # , > , >>> , PS …> ) è ciò che l’utente ha digitato (prompt) e ogni altra riga è ciò che hanno stampato i programmi (output).

Un’applicazione ospite collega il proprio evidenziatore (Shiki, Prism, highlight.js) con registerCodeHighlighter. Le configurazioni sono dati serializzabili, quindi la funzione si registra presso il motore, non si scrive in codeStyle:

import { registerCodeHighlighter } from 'postext';
 
// fn(code, lang) returns the listing's lines, each as runs whose texts join into the line.
registerCodeHighlighter('rust', (code) => code.split('\n').map((line) => [
  { text: line, token: line.trimStart().startsWith('//') ? 'comment' : undefined },
]));
registerCodeHighlighter('*', null); // remove the one registered for every language

Un evidenziatore registrato per un linguaggio ha la precedenza su uno registrato per '*', che a sua volta ha la precedenza sul tokenizzatore incorporato. Un tratto indica un tipo di token (colorato da tokens) o un proprio color (un esadecimale CSS). Un evidenziatore che restituisce undefined, solleva un’eccezione o restituisce righe che, unite, non danno quelle del listato viene scavalcato. L’impaginazione legge il registro quando compone un listato: registra prima di comporre e, in un web worker (la Sandbox impagina in uno), registra dentro il worker.

#Codice in linea

codeStyle.inline compone il testo tra apici inversi in un carattere da codice: come un’unica unità, al modo di un chip, dentro la quale una riga non va mai a capo. Se non è impostato, il codice in linea mantiene il carattere del testo.

#Come si compone un listato

• Una riga per ogni riga del sorgente. Le righe si costruiscono con gli avanzamenti propri del carattere da codice, non con l’algoritmo di divisione dei paragrafi: gli spazi mantengono la loro larghezza, una serie di spazi viene conservata, gli spazi iniziali fanno da rientro. Un listato in un libro da destra a sinistra si legge da sinistra a destra, con le righe composte dal lato opposto del riquadro come una citazione da sinistra a destra, e i numeri nella colonna alla loro sinistra. In un libro verticale un listato segue il flusso verticale (con il latino ruotato su un fianco, come lo compone il testo verticale) e non prende numeri di riga.
• Divisione. Un listato più alto dello spazio rimasto si divide tra le righe attraverso colonne e pagine, ogni parte incorniciata come un riquadro a sé, senza mai lasciare meno di splitMinLines righe su un lato; il resto di una riga andata a capo resta con essa quando c’è un altro taglio possibile.
• Output. Il canvas, il visualizzatore HTML e il PDF dipingono le righe e il riquadro così come sono impaginati. Il visualizzatore HTML mantiene gli spazi (white-space: pre), così una selezione copia il listato con il suo rientro e un a capo dopo ogni riga del sorgente, senza numeri né segni di ritorno a capo. Un PDF marcato compone ogni listato come un paragrafo che contiene un elemento Code, con veri glifi di spazio, e i numeri e i segni di ritorno a capo come artefatti. L’EPUB a layout fluido scrive <pre><code class="language-…"> con i colori dei token e un foglio di stile ricavato da codeStyle; l’EPUB a layout fisso è la versione di stampa.
• Font. La Sandbox e configFontFamilies caricano il carattere del codice quando il testo contiene una recinzione (o la configurazione ha una sezione codeStyle), nei pesi normale e grassetto, in tondo e in corsivo; il PDF incorpora i caratteri usati dalle righe.

#Stili dei riquadri

La proprietà calloutStyles dichiara gli stili di riquadro con nome che un documento applica con un contenitore :::callout{type="…"}: note, suggerimenti, avvertenze, obiettivi di apprendimento, qualsiasi contenuto separato dal testo corrente in un riquadro colorato o bordato. Per impostazione predefinita è incluso uno stile neutro, note (sfondo grigio chiaro, nessun bordo, nessuna fascia, nessuna icona, nessun titolo), così :::callout funziona senza alcuna configurazione; dichiarare calloutStyles sostituisce questo elenco predefinito.

const config: PostextConfig = {
  calloutStyles: [
    { id: 'note', name: 'Note' },
    {
      id: 'objectives',
      name: 'Learning objectives',
      title: 'Objectives',
      stripe: { enabled: true, side: 'left' },
      icon: { kind: 'glyph', glyph: '✓' },
      titleStyle: { textTransform: 'uppercase' },
      lists: { bulletChar: '–' },
    },
    {
      id: 'warning',
      title: 'Warning',
      backgroundEnabled: false,
      border: { enabled: true, color: { hex: '#AA0000', model: 'hex' }, width: { value: 1, unit: 'pt' } },
      borderRadius: { value: 1, unit: 'mm' },
      titleStyle: { color: { hex: '#AA0000', model: 'hex' } },
    },
  ],
};

:::callout{type="objectives"}
- Describe the parts of the lantern.
- Trim the wick at dusk.
:::
 
:::callout{type="warning" title="Do not touch the lens"}
The glass stays hot for an hour after the flame is out.
:::

#Il contenitore :::callout

Una riga :::callout{type="<id>"} apre il riquadro e una riga ::: da sola lo chiude. Il recinto accetta cinque attributi, type (l’id dello stile), title (sostituisce il titolo dello stile), span, placement e columns (sostituiscono i valori dello stile), e il contenuto tra le due righe si impagina dentro il riquadro: un titolo facoltativo, poi i paragrafi, gli elenchi, le citazioni in blocco, le formule o le risorse incorporate, ciascuno composto con la tipografia body / lists dello stile (i titoli mantengono i loro stili consueti). I margini tra i figli si fondono come nel testo corrente; l’interno esce dalla griglia della linea di base, e il flusso vi si riaggancia dopo il riquadro con almeno marginBottom sotto (vince la griglia; il margine è un minimo, la stessa convenzione seguita dalle risorse). Uno stile con snapToGrid: false mantiene invece il marginBottom esatto, e il testo dopo il riquadro resta fuori griglia fino al titolo successivo o alla fine di un elenco. Un titolo subito prima di un riquadro resta unito a esso.

Limiti di questa versione:

• Un riquadro resta intero a meno che il suo stile non imposti keepTogether: false. Quando non sta nello spazio rimanente della colonna passa intero alla colonna o alla pagina successiva, anche uscendo da una colonna vuota che fasce di elementi flottanti o un limite di fascia hanno accorciato, purché una colonna intera possa contenerlo. Un riquadro più alto di una colonna intera si divide invece, come uno divisibile; solo uno che nessun taglio può dividere (una figura o una tabella più alta della colonna, o uno splitMinLines che nessun taglio soddisfa) viene collocato comunque ed eccede; l’impaginazione registra allora un avviso calloutOverflow (VDTDocument.warnings), che la Sandbox elenca. Un gruppo :::columns si taglia come il riquadro che lo contiene, tra le sue sottocolonne (da postext 1.25); resta intero, e può eccedere allo stesso modo, solo con layout.flowColumns: false o dentro un riquadro annidato. Un riquadro divisibile lascia indietro la parte che ci sta (figli interi, o le righe di un paragrafo fino a splitMinLines su ciascun lato; una figura, una tabella o una formula in evidenza da sola basta per un lato) e prosegue in un riquadro senza icona nella colonna o pagina successiva, senza il titolo a meno che lo stile non lo ripeta, e facoltativamente con un segno sotto la parte che lascia (vedi Segni su un riquadro diviso).
• Gli elementi flottanti cedono il passo a un riquadro indivisibile. Quando il blocco subito dopo il richiamo di una figura è un riquadro keepTogether, uno slot che non lascerebbe al riquadro alcuna colonna della fascia corrente in cui finire (la colonna del richiamo o una vuota dopo di essa, che lo conteneva prima dell’elemento flottante) non viene preso: la figura passa al suo slot successivo, di solito la pagina successiva, e il riquadro resta nel flusso, come lo comporrebbe un compositore, invece di spingere il riquadro fuori dalla pagina lasciando la colonna con la sola figura.
• span: 'page' in un’impaginazione a più colonne fa del riquadro un blocco a tutta larghezza: si impagina all’intera larghezza del contenuto e divide la pagina in fasce di colonne; le colonne di testo sopra di esso si chiudono alla linea di taglio, il riquadro prende una propria colonna a tutta larghezza, e sotto di esso si apre una nuova fascia di colonne di testo, così il flusso prosegue sotto il riquadro in ogni colonna. Dove le colonne sono livellate (in cima a una pagina, subito sotto un titolo di apertura span: 'page', subito sotto un altro blocco a tutta larghezza, o subito sotto una fascia di elementi flottanti in testa) il riquadro taglia semplicemente lì. Quando arriva a metà pagina, con le colonne disuguali, si compone come farebbe un compositore: il testo sopra di esso viene tagliato alla stessa altezza in tutte le colonne (il motore ripete il posizionamento con le colonne della fascia accorciate allo stesso numero di righe della griglia, così il testo trabocca naturalmente da una colonna all’altra e tutte le regole su orfane, vedove e tieni con il successivo continuano ad applicarsi), il riquadro occupa tutta la larghezza della pagina, e le colonne riprendono sotto di esso. Il taglio richiede un paio di passaggi di posizionamento in più; quando la linea di taglio non lascerebbe spazio per il riquadro più il minimo di righe di testo per le vedove sotto di esso, o nessuna disposizione funziona dopo alcuni tentativi, il riquadro passa in cima alla pagina successiva. Il testo sopra rispetta il taglio: un paragrafo che non può iniziare nelle poche righe che una colonna sotto una figura conserva sopra di esso passa alla colonna successiva (la figura resta allora sola nella sua colonna), e quando un blocco supererebbe comunque il taglio, il taglio si prende una riga più in basso invece che dove termina quel blocco. Anche un riquadro diviso che apre la fascia viene tagliato lì, così il suo resto non supera mai il taglio. Con headings.balancing.beforeSpan (il valore predefinito) la fascia che lascia viene tagliata livellata dietro di esso, come la fascia di chiusura di un capitolo, e, quando lo stile consente la divisione (keepTogether: false), la parte del riquadro che sta sotto le colonne livellate chiude la pagina e il resto apre la successiva; con beforeSpan: false la pagina che lascia viene semplicemente bilanciata come al solito, senza forzare un’interruzione di pagina. Un titolo subito prima di un blocco a tutta larghezza non viaggia con esso. Nelle impaginazioni a una colonna span: 'page' è semplicemente in linea.
• placement: 'fixed' toglie il riquadro dal flusso: viene impaginato (width: 'auto' si adatta al titolo; 'fill' prende la larghezza della colonna di testo sotto il punto di ancoraggio) e fissato alla pagina in cui compare nel flusso, nella posizione descritta da fixed.anchor / fixed.offset (per impostazione predefinita l’angolo inferiore sinistro dell’area del contenuto). Le colonne di testo che copre cedono quella zona (tagliate dal basso, o dall’alto quando la colonna è ancora vuota), esattamente come una fascia di elementi flottanti; quando la zona contiene già testo, un elemento flottante o un blocco a tutta larghezza, il riquadro passa alla pagina successiva. Un riquadro fisso che chiude il capitolo (il blocco successivo è un’apertura di capitolo, un :::part, un riquadro barriera o la fine del documento) livella prima le colonne sopra di esso (headings.balancing.trailing), così una breve pagina di chiusura termina livellata con l’etichetta sottostante. La cornice e i figli vivono in page.floats e si disegnano fuori dal ritaglio delle colonne in ogni backend.
• placement: 'top' | 'bottom' fa flottare il riquadro come una risorsa: esce dal flusso nel punto in cui compare e prende la prima fascia libera dopo quel punto (il piede della pagina corrente, con 'bottom', o la testa / il piede della pagina successiva che il flusso apre) alla larghezza della colonna (span: 'column') o all’intera larghezza del contenuto (span: 'page'); il testo che lo segue riempie la pagina che ha lasciato. La sua cornice e i suoi figli vanno in page.floats, come per un riquadro fisso. Un riquadro flottante in testa a una pagina nuova si colloca prima delle figure in attesa di quella pagina, e una figura citata in una pagina precedente che ci sta poi sotto di esso prende il resto di quella pagina anche quando resterebbero meno di tre righe di testo (una pagina da galleria: riquadro più figura, senza testo in mezzo). Un riquadro span: 'side' non flotta mai: si impila accanto al testo qualunque sia il suo posizionamento. Con columns superiore a 1 (nello stile o come attributo del recinto, da postext 1.18) un riquadro span: 'column' occupa altrettante colonne adiacenti: la testa di una serie di colonne vuote che iniziano alla stessa altezza, o il piede della colonna corrente e di quelle vuote che la seguono, come in :::callout{placement="top" columns="2"}.
• width: 'auto' si adatta solo al titolo; i figli vengono ignorati.
• Un :::callout annidato dentro un altro riquadro è un riquadro a sé: si impagina con il proprio stile (sfondo, bordo, raggio, spaziatura interna, fascia, titolo, icona, segno, linguetta, tipografia) all’intera larghezza interna del genitore e si impila come uno dei suoi figli, con marginTop / marginBottom che si fondono con quelli dei vicini. I suoi span e placement (del recinto o dello stile) vengono ignorati, perché un riquadro annidato scorre sempre dentro il genitore, e così floatBarrier e snapToGrid. I riquadri si annidano a qualsiasi profondità e possono stare dentro un gruppo :::columns (ciascuno intero, in una colonna). Quando il genitore si divide, il taglio cade prima o dopo un riquadro annidato, o al suo interno quando lo stile annidato consente la divisione; ogni frammento ridisegna le cornici che attraversa, e un riquadro annidato che continua dal frammento precedente perde il titolo e l’icona, come una continuazione di primo livello.
• Un gruppo :::columns{count=N} … ::: tra i figli impagina quei figli in N colonne di uguale larghezza, a distanza columnGap, dentro il riquadro: la sequenza si taglia ai confini di blocco o di riga che livellano meglio le colonne (un paragrafo o un elemento di elenco tagliato a metà prosegue in testa alla colonna successiva senza il suo punto elenco), ogni colonna inizia alla sommità del gruppo e il gruppo è alto quanto la sua colonna più alta; i figli successivi tornano all’intera larghezza. Un riquadro che si divide (keepTogether: false, o più alto di una colonna) taglia anche dentro un gruppo, tra le sue colonne: un gruppo a serpentina riempie a turno le sue colonne e prosegue nel frammento successivo, uno parallelo (breaks) prosegue flusso per flusso (da postext 1.25; vedi Formato del documento › :::columns). Un gap sul recinto sostituisce columnGap per quel gruppo, e rule traccia un filetto lungo ogni intercolonna. Usalo per un riepilogo dei punti chiave su due colonne, o per affiancare le tabelle di un riquadro largo.
• Il sesto attributo del recinto, label, si stampa sulla linguetta dello stile (vedi label sopra): :::callout{type="box" label="BOX 1-1" title="The octet rule"}; senza uno stile label l’attributo viene ignorato.

Nel VDT il riquadro è un blocco cornice type: 'callout' la cui decorazione (sfondo, fascia, icona, titolo) vive in designOverlay, seguito dai suoi blocchi figli nella stessa colonna; la cornice e ogni figlio portano il containerId del recinto. Un riquadro annidato è una cornice type: 'callout' a sé tra i figli, seguita dai suoi blocchi; questi mantengono il containerId del recinto di primo livello (il posizionamento e il bilanciamento continuano a vedere un’unica unità) e aggiungono calloutPath, gli id dei contenitori dei recinti annidati che li circondano, dal più esterno (l’id proprio di una cornice annidata è l’ultima voce). Il PDF con tag dà a ogni riquadro annidato un Div dentro quello del genitore. Le immagini delle icone si risolvono come le immagini delle risorse: il registro delle immagini del canvas, l’opzione HTML resourceImageUrl e il provider PDF resourceBytes.

const resolved = resolveCalloutStylesConfig(config.calloutStyles, resolvedBodyText, resolvedHeadings, resolvedUnorderedLists, config.locale);
// => every inherited field filled from the resolved sections; the optional
//    locale picks the language of the continuation strings
 
const minimal  = stripCalloutStylesDefaults(config.calloutStyles);
// => undefined for the built-in `note` default; static defaults dropped

#Enunciati numerati e dimostrazioni

Uno stile con numbering conta i suoi riquadri, come amsthm di LaTeX conta gli ambienti teorema (da postext 1.19). Ogni riquadro stampa la sua etichetta e il suo numero («Theorem 2.» in apertura del suo primo paragrafo) e il title del recinto segue il numero tra parentesi: :::callout{type="theorem" title="Bradley–Terry"} si apre con «Theorem 2 (Bradley–Terry).». Un riquadro aperto con un identificatore ({#thm:main}) è una destinazione dei rimandi, che stampano «Theorem 2» (:ref{id="thm:main"}), e \ref{thm:main} o style=number stampa 2.

Una dimostrazione è uno stile con un’etichetta non numerata e un segno finale:

calloutStyles: [
  { id: 'theorem', numbering: { label: 'Theorem' }, body: { italic: true } },
  { id: 'lemma', numbering: { label: 'Lemma', counter: 'theorem' }, body: { italic: true } },
  { id: 'definition', numbering: { label: 'Definition' } },
  { id: 'proof', backgroundEnabled: false, endMark: '□',
    numbering: { label: 'Proof', counter: false, bold: false, italic: true } },
]

In un libro impaginato capitolo per capitolo i contatori proseguono dal capitolo precedente (LayoutContinuation.statementCounters, che continuationAfter compila), e la struttura del libro assegna all’ancora di ogni riquadro numerato la sua etichetta (OutlineEntry.numberLabel), così un rimando da un altro capitolo la stampa.

#Tipografia dentro un riquadro

Un riquadro compone il suo contenuto con la propria tipografia body e lists; tutto il resto mantiene gli stili del documento:

• I paragrafi prendono il body del riquadro: carattere, dimensione, interlinea, colore, colori dell’enfasi, pesi, italic, smallCaps, allineamento, sillabazione, rientro e spaziatura tra paragrafi. Un campo non impostato eredita da bodyText. Un colore dell’enfasi ereditato mantiene il suo collegamento alla tavolozza, quindi grassetto, corsivo ed etichette :ref in un riquadro cambiano con colorPalette come fanno fuori da esso. (Fino a postext 1.4 il grassetto in un riquadro restava #295AA3 qualunque fosse il colore principale.)
• Gli elenchi puntati prendono il lists del riquadro (carattere del punto elenco, colore, dimensione e peso del glifo, rientro, spazio, spaziatura tra gli elementi) al posto di unorderedLists, e il loro testo è il testo del riquadro. Un lists.bulletChar o lists.color diverso da quello del documento (unorderedLists) sostituisce il punto elenco o il colore di ogni livello; uno che lo ripete, o che resta non impostato, lascia a ogni livello il proprio (unorderedLists.levels), così i trattini annidati sopravvivono nel riquadro.
• Gli elenchi ordinati prendono lists.indent, gap e itemSpacing, e lists.color ogni volta che lo stile lo imposta, anche quando è il colore del punto elenco del documento; uno stile che lo lascia non impostato mantiene i numeri in orderedLists.color. (Fino a postext 1.4 il colore arrivava ai numeri solo quando era diverso da unorderedLists.color, quindi impostarlo proprio su quel colore non faceva nulla.) Il numero stesso (il suo carattere, la sua dimensione e il suo separatore) viene dall’orderedLists globale, perché lists ha solo campi per i punti elenco: definisci lì lo stile dei numeri di un riquadro.
• I :::paragraphs dentro un riquadro usano il loro stile di paragrafo, anche nei riquadri annidati. I campi che lo stile lascia non impostati ereditano dal bodyText del documento, non dal body del riquadro (né dal suo corsivo o dal suo maiuscoletto).
• I gruppi :::columns non hanno uno stile proprio: ogni colonna condivide la tipografia del testo e degli elenchi del riquadro, e columnGap imposta lo spazio tra di esse.
• Le citazioni in blocco prendono il carattere, la dimensione e i pesi del testo del riquadro (corsivo e grigio, come nel testo corrente), e il suo maiuscoletto. I titoli mantengono gli stili dei titoli; le formule in evidenza le impostazioni delle formule.
• Le figure e le tabelle mantengono gli stili delle didascalie e delle tabelle del documento, alla larghezza interna del riquadro; i loro pesi normale e grassetto seguono i pesi del body del riquadro.
• I chip mantengono il loro stile di chip; una dimensione in em si legge rispetto al corpo del testo del riquadro.
• :::space si misura in righe del testo del riquadro (vedi :::space per i casi in cui viene scartato).
• Un riquadro annidato prende per intero il proprio stile; i suoi span, placement, floatBarrier e snapToGrid vengono ignorati.

#Segni su un riquadro diviso

Quando un riquadro si divide tra colonne o pagine (keepTogether: false, o un riquadro più alto di una colonna), ogni parte dopo la prima si apre senza il titolo e l’icona, e per impostazione predefinita nulla dice al lettore che il riquadro prosegue. Due opzioni aggiungono i segni che usano un libro o una sceneggiatura:

• repeatTitle: true ripete il titolo in testa a ogni continuazione, seguito da continuedSuffix, per impostazione predefinita «Key points (cont.)». La ripetizione prende lo stile del titolo, quindi con textTransform: 'uppercase' dà il «HAMLET (CONT'D)» di una sceneggiatura. L’icona e la linguetta restano sulla prima parte.
• continuesMarkerEnabled: true colloca continuesMarker («Continued», o «Continúa» in un documento spagnolo) sotto l’ultima riga di ogni parte che prosegue, dentro il riquadro, nel carattere e nel corpo del testo del riquadro: in corsivo a meno che continuesMarkerItalic non sia false, allineato a destra a meno che continuesMarkerAlign non indichi 'left' o 'center'. Il segno occupa spazio nella parte che chiude, e il taglio viene scelto in modo che ci stia.

calloutStyles: [{
  id: 'speech',
  keepTogether: false,
  titleStyle: { textTransform: 'uppercase' },
  repeatTitle: true,
  continuedSuffix: "(CONT'D)",
  continuesMarkerEnabled: true,
  continuesMarker: '(MORE)',
  continuesMarkerAlign: 'center',
  continuesMarkerItalic: false,
}],

:::callout{type="speech" title="Hamlet"}
A speech long enough to run over the foot of the page…
:::

La parte che chiude la pagina termina con «(MORE)», e la pagina successiva si apre con «HAMLET (CONT'D)». Entrambi sono elementi di servizio dell’impaginazione: in un PDF accessibile sono artefatti e nell’HTML sono nascosti alle tecnologie assistive, così il titolo si legge una sola volta. Nel VDT sono blocchi di testo designOverlay contrassegnati artifact: true.

#Parti

La proprietà parts configura le pagine di parte che un documento apre con un contenitore :::part{number="…" title="…"}: la pagina «Parte I — Fondamenti» che raggruppa una serie di capitoli. Una parte occupa sempre una pagina propria: il contenitore passa a una pagina nuova della parità configurata, la converte in una pagina a una colonna la cui area del testo viene da parts.margins, stende il design di apertura sull’intera pagina, e interrompe di nuovo dopo il recinto di chiusura così il capitolo successivo (con il proprio breakBefore.parity) inizia pulito: con le impostazioni predefinite dell’H1 si ottiene la classica pagina di parte su recto, verso bianco, capitolo sul recto successivo.

const config: PostextConfig = {
  parts: {
    breakBefore: { parity: 'odd' },
    breakAfter: { enabled: true, parity: 'any' },
    margins: { top: { value: 9, unit: 'cm' }, left: { value: 3, unit: 'cm' }, right: { value: 3, unit: 'cm' } },
    design: {
      elements: [
        {
          kind: 'text', id: 'number', content: 'Part {numberRoman}',
          fontSize: { value: 12, unit: 'pt' }, fontWeight: 600, align: 'left',
          placement: { anchor: { to: 'page', edge: 'top-left' }, offset: { x: { value: 3, unit: 'cm' }, y: { value: 5, unit: 'cm' } }, size: { width: 'auto', height: 'auto' } },
        },
        {
          kind: 'text', id: 'title', content: '{titleText}',
          fontSize: { value: 28, unit: 'pt' }, fontWeight: 700, align: 'left', overflow: 'wrap',
          placement: { anchor: { to: '#number', edge: 'below' }, size: { width: { value: 15, unit: 'cm' }, height: 'auto' } },
        },
      ],
    },
    bodyStyle: { fontSize: { value: 11, unit: 'pt' }, numberColor: { hex: '#AA0000', model: 'hex' } },
  },
};

:::part{number="I" title="Foundations"}
1. The lantern and its parts
2. Trimming the wick
3. Reading the weather
:::
 
# The lantern and its parts

#Segnaposto del design di parte

Lo slot di design risolve l’insieme dei segnaposto dei titoli con i valori propri della parte: {titleText} è il title del recinto; {number} il number esattamente come è scritto; {numberDecimal}, {numberRoman}, {numberRomanLower}, {numberAlpha}, {numberAlphaLower} lo riformattano (il numero si interpreta come decimale, numero romano o numerali cinesi, con o senza le parole che li incorniciano: "IV", "iv", "4", "４", "四", "卷四" e "第四卷" danno tutti {numberDecimal} = 4), e si risolvono in '' per qualsiasi altra cosa. Sono disponibili anche {partTitle} / {partNumber}, {chapterTitle} / {chapterNumber} (il capitolo prima della parte), {pageNumber}, {totalPages}, {bookTotalPages} e i segnaposto dei metadati. {attr.<key>} legge gli attributi dell’H1 del capitolo corrente.

#Il design del verso

versoDesign decora la pagina subito dopo una pagina di parte quando quella pagina non contiene nulla: il retro del foglio di parte. La parte di per sé non lascia mai bianca quella pagina. breakAfter.parity vale 'any' per impostazione predefinita, quindi il contenuto dopo il recinto inizia proprio nella pagina successiva a meno che qualcosa non chieda una parità:

• Il titolo del capitolo successivo. Il breakBefore predefinito dell’H1 è 'always-odd', e 'odd' fa lo stesso dopo una pagina di parte su recto: il capitolo passa al recto successivo e il verso resta bianco. Il design del verso si disegna.
• parts.breakAfter: { enabled: true, parity: 'odd' }. È la parte stessa a chiedere il recto successivo, qualunque cosa faccia il titolo successivo. Usalo quando i capitoli possono aprirsi su entrambi i lati (breakBefore.parity: 'any', o breakBefore.enabled: false).

Senza nessuno dei due, il capitolo si apre sul verso e non si disegna alcun design del verso. Con breakAfter.enabled: false il contenuto prosegue sulla pagina di parte stessa. Il verso prende la tavolozza della parte, quindi un palette="band=#…" sul recinto ricolora anche lui.

parts: {
  breakBefore: { parity: 'odd' },
  breakAfter: { enabled: true, parity: 'odd' },   // always a blank verso to paint
  versoDesign: {
    elements: [{
      kind: 'box', id: 'field',
      style: { backgroundColor: { hex: '#b07d2b', model: 'hex', paletteId: 'band' } },
      placement: { anchor: { to: 'page', edge: 'top-left' }, size: { width: 'fill', height: 'fill' } },
    }],
  },
}

Una parte che chiude il suo capitolo. In un libro impaginato capitolo per capitolo (la Sandbox, buildBundle), un recinto :::part può essere un capitolo a sé, o la fine di uno. La sua pagina di parte è allora l’ultima pagina del capitolo, e il capitolo successivo si fa carico di ciò che la parte deve ancora: applica breakAfter prima del suo primo blocco e disegna versoDesign sulla sua prima pagina quando quella pagina resta bianca. Le pagine escono come uscirebbero con l’intero libro in un unico documento. Solo le direttive che non collocano nulla (:::numbering, :::space) possono seguire il recinto; qualsiasi altra cosa è contenuto del capitolo, che allora prende su di sé l’interruzione. Un capitolo vuoto subito dopo la parte è una pagina a sé: quella pagina è il verso. Un host che impagina da sé i capitoli ottiene questo da continuationAfter(), che riporta afterPartPage: true per un capitolo che termina con una parte; passalo nella continuation del capitolo successivo.

#Il contenitore :::part

Una riga :::part{number="…" title="…"} apre la parte e una riga ::: da sola la chiude; entrambi gli attributi sono facoltativi (predefiniti a ''). I blocchi tra le due righe (di solito l’elenco dei capitoli) scorrono nell’unica colonna della pagina di parte con bodyStyle, a partire da margins.top; un corpo più lungo della pagina prosegue su pagine ordinarie. La pagina è classificata role: 'part' (VDTPage.partInfo porta il numero e il titolo), così gli elementi di intestazione e piè di pagina possono indirizzarla o saltarla con pages: 'part' / pages: 'body'; il backend PDF aggiunge la parte ai segnalibri sopra i suoi capitoli. Un corpo vuoto (:::part{…} seguito direttamente da :::) è il caso comune e produce comunque la pagina: parti consecutive non ne condividono mai una. Un :::part annidato in un’altra parte viene appiattito in quella esterna.

Un terzo attributo, palette="<id>=<hex>[, <id>=<hex>…]", dà alla parte colori propri: sulla pagina di parte e su ogni pagina che la segue, fino alla parte successiva, ogni colore di design (intestazione, piè di pagina, fascia di apertura, design di parte e del verso) collegato a uno di quegli id della tavolozza prende il valore della parte invece di quello della tavolozza del documento. È così che le sezioni di un libro ricolorano la linguetta d’angolo, il punto della testatina e la fascia di apertura dei capitoli senza un secondo design: :::part{number="II" title="…" palette="band=#f6c297"}. Anche il flusso del testo si adegua: sulle stesse pagine, ogni colore del flusso uguale al valore di base di una voce della tavolozza sostituita (colori dei titoli, del grassetto, del corsivo e dei rimandi, punti elenco e numeri degli elenchi, etichette e barre delle didascalie, testo, filetti e riempimenti delle tabelle, cioè intestazione, corpo, righe alternate e riempimento proprio di una cella, riquadri, cioè sfondo, bordo, fascia e titolo, e chip, cioè riempimento, contorno e testo) prende il valore della parte, quindi headings.levels[1].color collegato a band compone i titoli di ogni sezione nel suo colore. I campioni di colore in linea mantengono il colore scritto in essi. Le coppie si separano con virgole, punti e virgola o spazi, = o : uniscono id e colore, il # è facoltativo. Una parte resta in vigore dopo la chiusura del suo recinto: {partTitle}, {partNumber} e la tavolozza seguono il flusso nei capitoli successivi e, tramite continuation.part, che continuationAfter() riporta, nei capitoli impaginati separatamente, così il secondo capitolo di una sezione mostra la sezione nelle testatine esattamente come il primo.

Due voci della tavolozza possono condividere un valore di base e prendere comunque valori diversi in una parte, quando la parte ne sostituisce una e non l’altra o assegna loro colori diversi. Il solo valore non dice da quale voce provenga un colore del flusso, quindi ogni colore del flusso si abbina alle impostazioni da cui può provenire, e prende il valore a cui quelle impostazioni sono collegate. Si distinguono questi casi:

• i colori del testo di un blocco: il colore del testo, i colori del grassetto, del corsivo e dei rimandi, il segno dell’elenco (un punto elenco o un numero) e il separatore dopo un numero. Con bodyText.color collegato a ink e bodyText.boldColor collegato a accent, entrambi #1a1a1a, una parte con palette="accent=#b8413d" ricolora i tratti in grassetto e lascia il testo; con unorderedLists.color collegato invece a accent, ricolora i punti elenco e lascia il testo degli elementi;
• ogni livello di titolo, e ogni stile di titolo che imposta un colore;
• il testo di una riga del sommario, il suo numero, e il suo numero di pagina e il suo sottotitolo;
• in ogni stile di riquadro, i riempimenti (sfondo, fascia, linguetta), il bordo, i filetti (segno e linguetta) e il testo (titolo, icona, glifo del segno, linguetta);
• ogni colore di ogni stile di tabella, di chip e di didascalia. Uno stile di tabella con nome è distinto da tableStyle, e lo stile di didascalia di un tipo di risorsa da captionStyle. Il riempimento proprio di una cella segue il proprio collegamento.

Un caso si decide ancora in base al valore: impostazioni in posti diversi che impostano lo stesso colore di un blocco. bodyText.color, bodyText.blockquote.color, il color di uno stile di paragrafo e il body.color di uno stile di riquadro impostano tutti il colore del testo di un blocco, per esempio. Quando due di essi sono collegati a voci che condividono un valore di base e la parte le distingue, il colore prende la sostituzione (l’ultima scritta, quando sono sostituite entrambe). Assegna a tali voci valori di base propri.

const resolved = resolvePartsConfig(config.parts, resolvedPage, resolvedBodyText, resolvedUnorderedLists, resolvedOrderedLists);
// => margins filled from the page, bodyStyle from the body / list configs
 
const minimal = stripPartsDefaults(config.parts);
// => undefined when only static defaults remain

#Stili dei titoli

La proprietà headingStyles dichiara stili con nome che un documento applica a un titolo con # Title {style="<id>"}. Uno stile fa due cose. Sostituisce la tipografia, il progetto grafico e la numerazione del livello del titolo (ogni campo di una voce di livello tranne level: font, dimensione, colore, breakBefore, span, advancedDesign, textTransform, hidden, numberingTemplate…) e governa la sezione che il titolo apre: le sue pagine, fino al titolo successivo di livello uguale o superiore, prendono le testatine, la geometria della pagina, la tipografia del corpo e la palette dello stile. È così che le pagine preliminari di un libro (una prefazione in un’unica colonna larga con folio romani e bande blu) trovano posto in un manuale a due colonne con numerazione decimale senza una seconda configurazione.

const config: PostextConfig = {
  headingStyles: [
    {
      id: 'front-matter',
      numbered: false,
      breakBefore: { enabled: true, parity: 'odd' },
      span: 'page',
      advancedDesign: { enabled: true, minHeight: { value: 52, unit: 'mm' }, slot: { elements: [/* bands, `{titleText}` */] } },
      header: { elements: [/* folio | rule | `{title}. {subtitle}` */] },
      margins: { left: { value: 50, unit: 'mm' }, right: { value: 17, unit: 'mm' } },
      layout: { layoutType: 'single' },
      bodyStyle: { fontSize: { value: 10.5, unit: 'pt' }, textAlign: 'justify' },
      palette: { band: '#547396' },
    },
  ],
};

# Preface {style="front-matter"}

Una sezione si chiude al titolo successivo di livello uguale o superiore: un # senza stile dopo uno con stile torna alle testatine e alla geometria del documento; uno con stile apre una sezione propria. Le pagine che la sezione ha lasciato bianche per la parità le appartengono, come accade per i titoli di capitolo.

Un’interruzione di pagina non sostituisce l’interruzione propria del titolo. Uno stile eredita il breakBefore del suo livello (il valore predefinito del livello 1 è { enabled: true, parity: 'always-odd' }), e un titolo lo applica ovunque si trovi, anche subito dopo un :::pagebreak. L’interruzione di pagina apre una pagina nuova, e il titolo chiede comunque il suo lato della doppia pagina. Con parity: 'odd', un’interruzione che cade su un verso è seguita da una pagina bianca, così il titolo si apre sul recto successivo. Con 'always-odd' arriva anche la pagina bianca di separazione, e l’interruzione di pagina non cambia nulla, perché il titolo avrebbe aperto quella pagina comunque. Uno stile pensato per cominciare nella pagina aperta da un’interruzione manuale, come una pagina di indice dopo il frontespizio, disattiva la propria interruzione:

headingStyles: [
  // Starts where the text puts it: on the page the `:::pagebreak` before it opened.
  { id: 'contents', numbered: false, toc: false, breakBefore: { enabled: false } },
],

Per avere una pagina propria senza scegliere un lato, imposta invece breakBefore: { parity: 'any' } e togli il :::pagebreak.

A quale sezione appartiene una pagina. Testatine e palette si scelgono per pagina, non per titolo. Una pagina prende la sezione in vigore dopo l’ultimo cambio di sezione che contiene: dove una sezione finisce e un’altra comincia nella stessa pagina (due lettere brevi di un dizionario, per esempio) la pagina porta le testatine e la palette della seconda; dove una sezione con stile finisce a metà pagina con un titolo senza stile, la pagina torna a quelle del documento. {chapterTitle} segue la stessa regola: una pagina in cui si incontrano due capitoli mostra il titolo del secondo. Le pagine bianche seguono la regola dei titoli di capitolo: una pagina bianca di parità (blankForParity) appartiene alla sezione che si apre dopo di essa, e quella di separazione che aggiunge un’interruzione 'always-odd' / 'always-even' (blankForForce) alla sezione precedente. Una pagina di parte chiude la sezione aperta.

# A {style="letter"}
 
Aardvark, abacus.
 
# B {style="letter"}
 
Babble, badger… (runs on to the next page)

Entrambe le lettere cominciano a pagina 1, quindi la pagina 1 prende le testatine della sezione B: un’unghiatura posta nell’intestazione dello stile mostra lì «B», e nessuna pagina porta l’unghiatura di «A». Dai a ogni sezione una pagina propria (breakBefore) quando ognuna ha bisogno della sua unghiatura. Appendici con lettere dopo capitoli numerati, e una pagina di dedica che l’indice e i segnalibri PDF elencano ma che nella pagina non mostra il titolo:

headingStyles: [
  { id: 'appendix', numberingTemplate: 'Appendix {1:A}' },
  { id: 'silent', hidden: true, numbered: false },
],

# Dedication {style="silent"}
 
For M., who read every draft.
 
# Method
 
…
 
# Survey instrument {style="appendix" startAt=1}
 
# Raw data {style="appendix"}

Con numberingTemplate: '{1}.' al livello 1, i capitoli stampano 1., 2.…, le appendici Appendix A e Appendix B. La dedica apre la sua pagina (il breakBefore del suo livello), stampa solo il suo paragrafo, e compare comunque come Dedication in :::toc, nelle testatine {chapterTitle} e nella struttura del PDF: aggiungi toc: false allo stile per escluderla dall’indice. Una tavola o una carta geografica composta come H1 a metà di un capitolo vuole il contrario della dedica: uno stile con runningChapter: false (di solito con numbered: false e toc: false) mantiene le testatine sul capitolo che interrompe.

const resolved = resolveHeadingStylesConfig(config.headingStyles, resolvedPage, resolvedBodyText, resolvedUnorderedLists, resolvedOrderedLists);
// => level overrides normalised, margins filled from the page, bodyStyle from the body
 
const minimal = stripHeadingStylesDefaults(config.headingStyles);
// => undefined when no style remains