>` | uma paleta discreta | A aparência de cada tipo de elemento, mesclada tipo a tipo sobre os padrões (veja abaixo). Uma cor vinculada à paleta acompanha `colorPalette` e a paleta de uma parte. |
| `inline` | `InlineCodeStyleConfig` | não definido | O código em linha numa fonte de código (veja abaixo). Sem definir, o código em linha é composto na fonte do texto, como antes da 1.23. |
### Coloração de sintaxe
Um pequeno tokenizador embutido no motor identifica os elementos de `js` e `ts` (`javascript`, `jsx`, `typescript`, `tsx`), `json`, `python`, `bash` (`sh`, `zsh`, `shell`), `console` (uma sessão de terminal), `css`, `html` e `xml` (`svg`), `markdown` e `sql`; uma listagem em qualquer outra linguagem, ou sem linguagem, é composta em `color`. Ele lê a listagem inteira, de modo que um comentário ou uma string que ocupa várias linhas continua sendo um só elemento. Numa listagem `console`, uma linha que abre com um prompt (`$ `, `% `, `# `, `> `, `>>> `, `PS …> `) é o que o usuário digitou (`prompt`), e todas as outras linhas são o que os programas imprimiram (`output`).
| Tipo | Padrão | O que identifica |
| --- | --- | --- |
| `keyword` | `#8b2c8f` | Palavras reservadas: `const`, `def`, `if`, `SELECT`, o nome de uma tag HTML, uma regra @ do CSS. |
| `string` | `#3d7a2a` | Strings, template literals, valores de atributo. |
| `number` | `#985f00` | Números e constantes (`true`, `None`, `null`), cores, entidades. |
| `comment` | `#7a7f87`, itálico | Comentários. |
| `function` | `#2b5fb4` | Um nome seguido de parêntese; os comandos embutidos do shell. |
| `type` | `#99540a` | Tipos e nomes de classe com maiúscula inicial, seletores CSS. |
| `operator` | a cor do código | Operadores, pipes e redirecionamentos do shell. |
| `punctuation` | a cor do código | Parênteses, colchetes e chaves, separadores. |
| `variable` | `#b23b2e` | Variáveis do shell, chaves JSON, propriedades CSS, atributos HTML, `self`. |
| `meta` | `#985f00` | Decoradores, opções de linha de comando (`-l`, `--all`), um doctype. |
| `prompt` | a cor do código, em negrito | A linha digitada de uma sessão de terminal. |
| `output` | `#5c6168` | O que os programas imprimiram. |
Uma aplicação conecta o seu próprio realçador (Shiki, Prism, highlight.js) com `registerCodeHighlighter`. As configurações são dados serializáveis, então a função é registrada no motor, não escrita em `codeStyle`:
```ts
import { registerCodeHighlighter } from 'postext';
// fn(code, lang) devolve as linhas da listagem, cada uma como trechos cujos textos, unidos, formam a linha.
registerCodeHighlighter('rust', (code) => code.split('\n').map((line) => [
{ text: line, token: line.trimStart().startsWith('//') ? 'comment' : undefined },
]));
registerCodeHighlighter('*', null); // remove o registrado para todas as linguagens
```
Um realçador registrado para uma linguagem tem precedência sobre um registrado para `'*'`, que tem precedência sobre o tokenizador embutido. Um trecho indica um tipo de elemento em `token` (colorido por `tokens`) ou uma `color` própria (um hex CSS). Um realçador que devolve `undefined`, lança um erro ou devolve linhas que, unidas, não formam as da listagem é ignorado. A diagramação consulta o registro ao compor uma listagem: registre antes de construir o documento e, num Web Worker (o Sandbox diagrama num), registre dentro do worker.
### Código em linha
`codeStyle.inline` compõe o texto entre acentos graves numa fonte de código: como uma unidade, como um chip, que uma linha nunca quebra por dentro. Sem definir, o código em linha mantém a fonte do texto.
| Propriedade | Tipo | Padrão | Descrição |
| --- | --- | --- | --- |
| `fontFamily` | `string` | `codeStyle.fontFamily` | A fonte. |
| `fontSize` | `Dimension` | `0.9em` | `em` é o tamanho do texto em volta. |
| `color` | `ColorValue` | a do texto | |
| `bold` / `italic` | `boolean` | `false` | Somam-se às marcas do próprio texto (o código dentro de negrito sai em negrito). |
| `background` | `ColorValue` | nenhum | Um preenchimento atrás do trecho. |
| `borderColor` / `borderWidth` | `ColorValue` / `Dimension` | nenhum / `0.5pt` | Um contorno. |
| `borderRadius` | `Dimension` | `0.2em` | `em` é o tamanho do trecho. |
| `paddingX` / `paddingY` | `Dimension` | `0.2em` com preenchimento ou contorno, senão `0` / `0.1em` | Espaço dentro do preenchimento; o espaçamento vertical é pintado fora da caixa da linha. |
### Como uma listagem é composta
- **Uma linha por linha do código-fonte.** As linhas são construídas a partir dos avanços da própria fonte de código, não pelo algoritmo de quebra de parágrafos: os espaços mantêm a sua largura, uma sequência deles é mantida, e os espaços iniciais recuam. Uma listagem num livro da direita para a esquerda é lida da esquerda para a direita, com as linhas compostas a partir do lado oposto da caixa, como uma citação da esquerda para a direita, e os números na margem à esquerda delas. Num livro vertical, uma listagem segue o fluxo vertical (o seu texto latino girado de lado, como o texto vertical o compõe) e não leva números de linha.
- **Divisão.** Uma listagem mais alta que o espaço restante se divide entre linhas através de colunas e páginas, cada parte emoldurada como uma caixa própria, sem nunca deixar menos de `splitMinLines` linhas de um lado; o resto de uma linha partida fica com ela quando outro corte é possível.
- **Saídas.** O canvas, o visualizador HTML e o PDF pintam as linhas e a caixa como foram diagramadas. O visualizador HTML mantém os espaços (`white-space: pre`), de modo que uma seleção copia a listagem com o seu recuo e uma quebra de linha depois de cada linha do código-fonte, sem números nem marcas de continuação. Um PDF marcado compõe cada listagem como um parágrafo que contém um elemento `Code`, com glifos de espaço reais, e os números e as marcas de continuação como artefatos. O EPUB refluível escreve `` com as cores dos elementos e uma folha de estilos derivada de `codeStyle`; o EPUB de layout fixo é o impresso.
- **Fontes.** O Sandbox e `configFontFamilies` carregam a fonte de código quando o texto tem uma cerca (ou a configuração tem uma seção `codeStyle`), nos pesos regular e negrito, em redondo e itálico; o PDF incorpora as fontes que as linhas usam.
## Estilos de boxe
A propriedade `calloutStyles` declara os estilos de boxe nomeados que um documento aplica com um contêiner `:::callout{type="…"}`: notas, dicas, avisos, objetivos de aprendizagem, qualquer conteúdo separado do texto corrido em um boxe com fundo ou contorno. Um estilo neutro, `note`, vem por padrão (fundo cinza-claro, sem contorno, sem faixa, sem ícone, sem título), de modo que `:::callout` funciona sem nenhuma configuração; declarar `calloutStyles` substitui essa lista padrão.
```ts
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' } },
},
],
};
```
```md
:::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.
:::
```
| Propriedade | Tipo | Padrão | Descrição |
| --- | --- | --- | --- |
| `id` | `string` | — | Identificador escolhido por `:::callout{type="…"}`. Um delimitador com `type` desconhecido ou ausente usa o primeiro estilo configurado (o Sandbox sinaliza os tipos desconhecidos). |
| `name` | `string` | `id` | Nome legível (só na interface do editor). |
| `title` | `string` | `''` | Texto padrão do título; vazio significa sem título. O atributo `title` do delimitador o substitui em cada ocorrência. |
| `span` | `'column' \| 'page' \| 'side'` | `'column'` | Extensão horizontal: a coluna, a largura total do conteúdo ou a coluna lateral reservada a flutuantes de um layout de coluna e meia (`layout.sideColumnRole: 'floats'`); nesse caso o boxe sai do fluxo e se empilha nessa coluna, ao lado do texto que interrompe. Pode ser substituído em cada ocorrência pelo atributo `span`. Em layouts de várias colunas, um boxe `'page'` vira um *bloco de largura de página*: divide a página em faixas de colunas e ocupa uma coluna própria de largura total (veja a seção sobre o contêiner, abaixo). Um boxe lateral que não cabe na coluna lateral da sua página ocupa a da página seguinte; se o capítulo (ou o documento) termina antes, cada boxe ainda à espera é composto na coluna lateral de uma página depois do texto, na ordem dos seus delimitadores, e a diagramação avisa (`afterText`; até o postext 1.24 os boxes depois da primeira dessas páginas se perdiam). |
| `columns` | `number` | `1` | Quantas colunas adjacentes um boxe flutuante (`placement` `'auto'`, `'top'` ou `'bottom'`, com `span: 'column'`) ocupa, como faz `placement.columns` para uma figura: o boxe de uma matéria em três das cinco colunas de um jornal. Tantas colunas quantas a página tiver, ou mais, fazem dele um boxe da largura da página. Um boxe composto no fluxo (`'here'`) fica na sua coluna. Pode ser substituído em cada ocorrência pelo atributo `columns`. Desde o postext 1.18. |
| `placement` | `'here' \| 'auto' \| 'top' \| 'bottom' \| 'fixed'` | `'here'` | Onde o boxe fica. `'here'` o compõe em linha, no fluxo; `'top'` / `'bottom'` o fazem **flutuar** como um recurso (`'auto'` toma a faixa que ficar livre primeiro, no alto ou no pé): ele sai do fluxo onde aparece e toma a primeira faixa livre a partir desse ponto (o pé da página atual, ou o alto / o pé da próxima página que o fluxo abrir), e o texto que vem depois preenche a página em volta dele; `'fixed'` o ancora em coordenadas da página por meio de `fixed`, abaixo, fora do fluxo das colunas. Os detalhes estão na seção sobre o contêiner. Pode ser substituído em cada ocorrência pelo atributo `placement`. |
| `sideAtColumnEnd` | `'before' \| 'after'` | `'before'` | Onde fica um boxe lateral (`span: 'side'`) quando o texto depois do seu delimitador não continua na mesma coluna: a coluna não tem mais espaço para ele, ou as regras de quebra o mandam adiante (um parágrafo que as regras de viúvas e órfãs movem inteiro, um título mantido com o seu texto). `'before'` o mantém no seu delimitador, nessa página, ao lado do texto anterior, subindo a partir do pé da coluna quando não cabe abaixo do delimitador: o lugar de uma glosa escrita depois do trecho que explica. `'after'` o alinha com a primeira linha do texto depois do delimitador, na coluna lateral da página em que esse texto continua: o lugar de um número de linha ou de um título marginal escrito antes da sua linha. Quando o texto continua na mesma coluna, os dois põem o boxe no seu delimitador. Um boxe que não é seguido de nada no seu capítulo fica com o texto anterior em qualquer caso, e boxes laterais delimitados um depois do outro mantêm a sua ordem. Até o postext 1.4 todo boxe lateral se comportava como `'before'`, que continua sendo o padrão: um estilo para glosas mantém os seus boxes na página do trecho que explicam. |
| `fixed` | `{ anchor?, offset? }` | `{ anchor: { to: 'container', edge: 'bottom-left' } }` | Posição de um boxe `'fixed'`: um `ElementAnchor` (`to`: `'container'` = a área de conteúdo da página, espelhada nas páginas pares; `'page'` = a caixa de refile; `'bleed'` = a caixa de sangria; `edge`: uma das nove bordas do contêiner) mais um `offset` opcional (dimensões `x` / `y`). |
| `floatBarrier` | `boolean` | `false` | Torna o boxe uma barreira de flutuantes: toda figura ou tabela referenciada antes dele é colocada antes dele (nos espaços livres da página ou, se não houver, em páginas abertas antes do boxe), de modo que nenhum flutuante escapa para depois do boxe que fecha um capítulo (normalmente um resumo de “pontos-chave”). Aberturas de capítulo, `:::part` e o fim do documento são sempre barreiras. |
| Um boxe `span: 'page'` em uma página de várias colunas corta a faixa sob o texto que ele segue; uma figura de largura total referenciada antes dele fica com esse corte primeiro: o texto é nivelado, a figura se assenta logo onde ele terminou e o boxe continua abaixo dela (ou na página seguinte, quando já não cabe). Uma figura alta demais para vir depois do texto nivelado abre a página seguinte, com o boxe depois dela, e a faixa que ela deixou termina nivelada mesmo assim. Um boxe divisível (`keepTogether: false`) começa sob o texto e a figura com tantos itens quantos couberem, e o resto continua na página seguinte. | | | |
| `width` | `'fill' \| 'auto'` | `'fill'` | `'fill'` ocupa a largura disponível; `'auto'` se ajusta ao título (uso como selo) e ignora os filhos. |
| `backgroundEnabled` / `background` | `boolean` / `ColorValue` | `true` / `#f4f4f4` | Preenchimento do boxe. |
| `border` | `{ enabled, color, width }` | `false`, `#cccccc`, `0.5pt` | Contorno do boxe, traçado por dentro da borda do boxe, como a borda de um elemento de caixa (veja [Elementos de caixa](https://postext.dev/pt/docs/configuration-page-layout.md#elementos-de-caixa)). |
| `borderRadius` | `Dimension` | `0` | Raio dos cantos do fundo / do contorno (limitado à metade da largura e da altura do boxe). A faixa o acompanha: em um boxe arredondado, a faixa é recortada pelo quadro arredondado, como o CSS recorta um `border-left` pelo `border-radius`. A aba `label` mantém os cantos retos. |
| `padding` | `{ top, right, bottom, left }` | `0.75em` cada | Recuo entre a borda do boxe e o seu conteúdo. Os valores em `em` são relativos ao tamanho do corpo do boxe. |
| `stripe` | `{ enabled, side, width, color }` | `false`, `'left'`, `1.5em`, cor principal | Faixa sólida ao longo de uma borda. Uma faixa `'left'` / `'right'` estreita o conteúdo; uma faixa `'top'` o empurra para baixo. `'left'` e `'right'` são lados do fluxo do corpo (em um livro da direita para a esquerda, `'left'` é o lado direito da folha); `'start'` e `'end'` seguem a direção do próprio boxe, de modo que um `:::callout{dir=ltr}` em um livro árabe põe uma faixa `'start'` à esquerda. Em um boxe com `borderRadius`, os seus cantos externos são arredondados com os do quadro (até o postext 1.4 ficavam retos e passavam do arredondamento). |
| `icon` | `{ kind, glyph, resourceId, fontFamily, fontWeight, size, width, color, align, position, cornerSide }` | `'none'`, fonte dos títulos, `400`, `1.5em`, cor principal, `'top'`, `'inline'`, `'right'` | Um glifo de texto (`kind: 'glyph'`) ou um recurso bitmap / SVG (`kind: 'resource'` + `resourceId`) ao lado do conteúdo. Com uma faixa lateral, o ícone é centralizado sobre a faixa; caso contrário, reserva uma coluna própria (`size` + `titleStyle.gap`). `align: 'center'` o centraliza verticalmente em relação ao conteúdo. Uma imagem de recurso é ajustada dentro do quadrado mantendo a proporção, ou dentro de uma caixa `width` × `size` quando `width` está definido (uma tira larga de ícones); um ícone mais alto que o conteúdo faz o boxe crescer para contê-lo (e, com `align: 'center'`, centraliza o conteúdo nele). `position: 'corner'` pendura o ícone em um canto superior como um selo, com metade dele para fora da borda, sem tirar espaço do conteúdo; um ícone largo (`width`) é centralizado no canto pela largura com que é desenhado, e no canto esquerdo o título começa depois da sua metade interna (até o postext 1.4 era posicionado pela altura, de modo que uma tira larga ficava pendurada para fora do boxe e sobre o título); `cornerSide` escolhe o canto: `'right'` / `'left'`, ou `'outer'` / `'inner'`, que seguem a paridade da página das margens espelhadas (externo = direita em uma página ímpar, esquerda em uma par). |
| `marker` | `{ kind, glyph, resourceId, fontFamily, fontWeight, size, color, align, gap, rule }` | `'none'`, fonte dos títulos, `400`, `1.5em`, cor principal, `'center'`, `0.5em`, fio desligado (`0.5pt`, cor principal, comprimento `0`) | Um segundo ícone desenhado *fora* do boxe, em uma coluna à esquerda dele, com um `rule` (fio vertical) opcional entre ele e o boxe: a mãozinha de “toque aqui” ao lado de um selo de autoavaliação. O quadro passa a ser `[marker][rule][gap][box]`, com a altura do mais alto dos três; `align` os centraliza entre si ou os alinha pelo alto. `rule.length` é um mínimo: o fio sempre cobre pelo menos a altura do boxe. |
| `titleStyle` | `{ fontFamily, fontSize, fontWeight, italic, color, textTransform, gap, letterSpacing, indent, lineHeight }` | fonte dos títulos, tamanho do corpo, `700`, `false`, cor principal, `'none'`, `0.5em`, `0`, `0`, `1.2em` | Tipografia do título. `gap` é o espaço entre o título e o primeiro filho (e o espaço da coluna do ícone). `lineHeight` é a entrelinha das linhas do título, com o `em` contado sobre o tamanho do próprio título; a linha de base fica a 0,8 dela abaixo do topo de cada linha, como no texto corrido, de modo que um título na entrelinha do corpo (`lineHeight: 12pt` sobre uma grade de 12 pt) mantém o boxe com um número inteiro de linhas e o título na grade, enquanto o padrão de 1,2 em acrescenta uma fração de linha a cada boxe. `textTransform: 'uppercase'` preserva o comprimento. `letterSpacing` aplica tracking ao título (`letterSpacing` do canvas / `Tc` do PDF); `indent` o afasta para a direita da borda interna do boxe. Um selo de canto pendurado do lado do título (o canto esquerdo) reserva primeiro o seu próprio espaço (a metade interna do selo mais `gap`), para que o título não o toque em qualquer página em que caia; `indent` só soma além disso. |
| `body` | `{ fontFamily, fontSize, lineHeight, color, boldColor, italicColor, fontWeight, boldFontWeight, italic, smallCaps, textAlign, hyphenation, paragraphSpacing, firstLineIndent, tabStops, tabInterval }` | herda `bodyText`; `italic` / `smallCaps` `false` | Tipografia dos parágrafos e itens de lista dentro do boxe. Todo campo não definido herda o texto do corpo; `italicColor` define a cor dos trechos em itálico (uma citação em destaque em itálico na cor do boxe). `fontWeight` / `boldFontWeight` definem os pesos dos trechos regulares e em negrito; `italic` compõe o boxe em itálico, com os trechos `*…*` voltando ao redondo; `smallCaps` o compõe em versaletes; `tabStops` e `tabInterval` substituem os do corpo dentro do boxe (veja [Paradas de tabulação](https://postext.dev/pt/docs/configuration-text.md#paradas-de-tabulação)). Veja [Tipografia dentro de um boxe](https://postext.dev/pt/docs/configuration-styles.md#tipografia-dentro-de-um-boxe) para o que mais o texto do boxe recebe. |
| `lists` | `{ bulletChar, color, indent, gap, itemSpacing, bulletFontSize, bulletFontWeight }` | herda `unorderedLists` | Tipografia das listas dentro do boxe (`color`, `indent`, `gap` e `itemSpacing` também valem para as listas numeradas). `bulletFontSize` / `bulletFontWeight` compõem o glifo do marcador na fonte do corpo do boxe nesse tamanho e peso (um marcador colorido e pesado). |
| `label` | `{ fontFamily, fontSize, fontWeight, color, background, position, height, paddingX, offset, inset, icon, rule }` | não definido (sem aba) | Uma aba na borda superior do boxe que imprime o atributo `label` do delimitador: o número de um boxe numerado (“BOXE 1-1”). Ela encosta no canto indicado por `position` (`'top-right'` / `'top-left'`), recuada em `inset`, sobe `offset` acima do topo do boxe (esse espaço faz parte do bloco, somado a `marginTop`, para que a aba o mantenha também no alto de uma coluna), tem `height` de altura com `paddingX` de cada lado do texto e pode levar um recurso `icon` ao lado (`{ resourceId, width, gap }`, do lado oposto ao canto) e um `rule` (`{ enabled, color, width }`) ao longo da borda superior, do canto oposto até ela. Padrões: fonte dos títulos, tamanho do corpo, `700`, branco sobre a cor principal, `1.4em` de altura, `0.6em` de margem interna. A aba é uma forma própria apoiada sobre o quadro, por isso mantém os cantos retos qualquer que seja o `borderRadius` do boxe. |
| `columnGap` | `Dimension` | `1.5em` | Espaço entre as colunas de um grupo `:::columns` dentro do boxe (veja a seção sobre o contêiner, abaixo). |
| `marginTop` / `marginBottom` | `Dimension` | `0.75em` / `0.75em` | Espaço acima do boxe (funde-se com a margem do bloco anterior) e espaço mínimo abaixo dele (o espaço exato com `snapToGrid: false`). Um boxe flutuante (`placement: 'top'`, `'bottom'` ou `'auto'`) mantém o espaço de flutuante, uma linha do corpo, entre a sua faixa e o texto; um `marginBottom` maior que isso define o espaço sob um boxe em uma faixa superior, e um `marginTop` maior, o espaço sobre um boxe em uma faixa inferior, arredondado para cima até a grade junto com a faixa. Até o postext 1.4 um boxe flutuante ignorava as suas margens. |
| `snapToGrid` | `boolean` | `true` | Com `true`, o fluxo depois do boxe volta a se encaixar na grade de linhas de base, de modo que o espaço sob ele é `marginBottom` arredondado para cima até linhas inteiras da grade. Com `false`, o boxe mantém o seu `marginBottom` exato, que se funde com a margem superior do bloco seguinte (dois boxes seguidos de um estilo assim ficam exatamente a `max(marginBottom, marginTop)` um do outro), e o texto depois dele pode ficar fora da grade até o próximo ponto de encaixe (um título, o fim de uma lista), como depois de um título com `headings.snapToGrid: false`. Pensado para documentos feitos de boxes empilhados (fichas de exercícios, formulários). Vale para os boxes no fluxo; os boxes de largura de página em um layout de várias colunas e os boxes flutuantes, fixos e laterais mantêm a grade, porque as faixas de colunas e as zonas de flutuantes são dispostas sobre ela. As alavancas de equilíbrio de colunas não mudam: um boxe que fecha uma coluna continua sendo empurrado até a última posição da grade da coluna. |
| `keepTogether` | `boolean` | `true` | Com `true`, o boxe é mantido inteiro: um boxe que não cabe no espaço restante passa inteiro para a coluna ou página seguinte. Só um boxe mais alto que uma coluna vazia e completa (uma página inteira para um boxe `span: 'page'`) não pode ser mantido inteiro: ele se divide pelas regras de `false` abaixo em vez de transbordar, começando onde aparece, e uma continuação que caiba em uma coluna passa inteira adiante; um boxe flutuante (`placement: 'top' \| 'bottom' \| 'auto'`) com essa altura não flutua, fica no fluxo onde aparece. Com `false`, qualquer boxe pode quebrar entre os seus blocos filhos ou entre as linhas de um parágrafo ou item de lista: o corte mais fundo que couber fecha a coluna atual (ou, para um boxe `span: 'page'`, a página, rente ao pé das colunas) e o resto continua no alto da seguinte, em um boxe próprio (mesmo quadro e faixa, sem ícone e sem título, a menos que `repeatTitle` o repita), dividindo-se de novo se ainda for alto demais. O texto de cada fragmento mantém, vazia, a coluna que um ícone em linha ocupa no primeiro trecho, para que o boxe tenha uma única medida em todas as páginas. Um corte dentro de um item de lista deixa o marcador com o primeiro trecho. O quadro de cada fragmento compartilha o `contentIndex` / `containerId` do delimitador e registra `callout.part` / `callout.continued`. Use-o em um boxe longo de “pontos-chave” no fim do capítulo junto com `headings.balancing.beforeSpan`, ou em um estilo de nota cujos boxes nunca devem empurrar uma figura para fora da página. Um boxe aninhado (um `:::callout` dentro de outro) é um filho do seu pai: um corte pode cair antes ou depois dele, e dentro dele só quando o seu próprio estilo permite a divisão (`keepTogether: false`, ou mais alto que uma coluna completa), segundo o seu próprio `splitMinLines`. |
| `splitMinLines` | `number` | `2` | Número mínimo de linhas de texto que um fragmento de um boxe dividido (`keepTogether: false`, ou um boxe indivisível mais alto que uma coluna completa) mantém de cada lado do corte. Ele protege apenas o texto: um lado que contenha pelo menos uma figura, tabela, fórmula em destaque ou boxe aninhado é aceitável qualquer que seja o seu número de linhas, de modo que um boxe de imagens pode deixar uma só em uma página. Um corte dentro de um parágrafo ou item de lista continua contando todas as linhas de cada lado (uma figura ou fórmula ali conta como uma linha) e também deixa pelo menos `layout.boxChildSplitMinLines` linhas desse parágrafo ou item de cada lado (duas por padrão; este mínimo quando for menor, de modo que 1 permite uma). Com os padrões, um item de duas ou três linhas nunca é dividido, e um de quatro só se divide em duas e duas. Com o padrão, nenhum boxe quebra deixando uma linha de texto solitária no pé de uma coluna ou no alto da seguinte; quando nenhum corte satisfaz o mínimo, o boxe passa inteiro. (Antes do postext 1.5, um corte dentro de um parágrafo verificava só as linhas do lado inteiro, de modo que um item de duas linhas podia se dividir em uma e uma quando outras linhas do boxe completavam o mínimo.) |
| `repeatTitle` | `boolean` | `false` | Repete o título no alto de cada continuação de um boxe dividido, seguido de `continuedSuffix` (“Pontos-chave (cont.)”). A repetição usa o estilo do título. Um boxe sem título não repete nada. Veja [Marcas em um boxe dividido](https://postext.dev/pt/docs/configuration-styles.md#marcas-em-um-boxe-dividido). |
| `continuedSuffix` | `string` | `'(cont.)'` | Texto depois do título repetido, no idioma do documento (`locale` ou, na falta dele, o idioma de hifenização), como o de uma tabela dividida, e unido ao título como o de uma tabela. |
| `continuesMarkerEnabled` | `boolean` | `false` | Põe `continuesMarker` sob a última linha de cada parte de um boxe dividido que continua, dentro do boxe. |
| `continuesMarker` | `string` | `'Continued'` / `'Continúa'` | Texto dessa marca (o “(MORE)” de um roteiro), na fonte e no tamanho do corpo do boxe, conforme o idioma do documento. |
| `continuesMarkerAlign` | `'left' \| 'center' \| 'right'` | `'right'` | Onde a marca fica na largura interna do boxe. |
| `continuesMarkerItalic` | `boolean` | `true` | Compõe a marca em itálico. |
| `numbering` | `{ label, counter, numberingTemplate, resetOn, counterFormat, placement, bold, italic, suffix }` | não definido | Conta os boxes deste estilo como enunciados numerados: teoremas, lemas, definições. Veja [Enunciados numerados e demonstrações](https://postext.dev/pt/docs/configuration-styles.md#enunciados-numerados-e-demonstrações). |
| `endMark` | `string` | `''` | Uma marca alinhada à direita no fim da última linha do boxe, como uma demonstração termina com `'∎'` ou `'□'`: na última linha quando cabe depois de um espaço, senão em uma linha própria. Um boxe que termina em uma fórmula em destaque sem número a recebe como etiqueta da fórmula. Com a matemática ativada, os quadrados (∎ □ ■ ▪ ◻ ▫) são desenhados com os glifos do próprio TeX, de modo que uma fonte que não os tenha (os arquivos latin da Fontsource) também os imprime; com a matemática desativada, são compostos na fonte do corpo do boxe. |
### O contêiner `:::callout`
Uma linha `:::callout{type=""}` abre o boxe e uma linha `:::` sozinha o fecha. O delimitador aceita cinco atributos, `type` (o id do estilo), `title` (substitui o título do estilo), `span`, `placement` e `columns` (substituem os valores do estilo), e o conteúdo entre as duas linhas é composto dentro do boxe: um título opcional e depois os parágrafos, listas, citações, fórmulas ou recursos incorporados, cada um com a tipografia `body` / `lists` do estilo (os títulos mantêm os seus estilos habituais). As margens entre os filhos se fundem como no texto corrido; o interior sai da grade de linhas de base, e o fluxo volta a ela depois do boxe com pelo menos `marginBottom` abaixo (a grade prevalece; a margem é um mínimo, a mesma convenção que os recursos seguem). Um estilo com `snapToGrid: false` mantém, em vez disso, o `marginBottom` exato, e o texto depois do boxe fica fora da grade até o próximo título ou fim de lista. Um título imediatamente antes de um boxe fica junto dele.
Limites desta versão:
- Um boxe é mantido inteiro, a menos que o seu estilo defina `keepTogether: false`. Quando não cabe no espaço restante da coluna, passa inteiro para a coluna ou página seguinte, inclusive saindo de uma coluna vazia que as faixas de flutuantes ou um limite de faixa encurtaram, desde que uma coluna completa o comportasse. Um boxe mais alto que uma coluna completa se divide em vez disso, como um divisível; só aquele que nenhum corte consegue dividir (uma figura, tabela ou grupo `:::columns` mais alto que a coluna, ou um `splitMinLines` que nenhum corte satisfaz) é colocado mesmo assim e transborda; o layout registra então um aviso `calloutOverflow` (`VDTDocument.warnings`), que o Sandbox lista. Um boxe divisível deixa para trás a parte que cabe (filhos inteiros, ou as linhas de um parágrafo até `splitMinLines` de cada lado; uma figura, tabela ou fórmula em destaque sozinha basta para um lado) e continua em um boxe sem ícone na coluna ou página seguinte, sem o título a menos que o estilo o repita e, opcionalmente, com uma marca sob a parte que deixa (veja [Marcas em um boxe dividido](https://postext.dev/pt/docs/configuration-styles.md#marcas-em-um-boxe-dividido)).
- Os flutuantes cedem a um boxe indivisível. Quando o bloco logo depois da referência a uma figura é um boxe `keepTogether`, um espaço que deixaria o boxe sem nenhuma coluna da faixa atual onde cair (a coluna da referência ou uma vazia depois dela, que o comportava antes do flutuante) não é tomado: a figura passa para o seu próximo espaço, normalmente a página seguinte, e o boxe continua no fluxo, como um compositor o comporia, em vez de empurrar o boxe para fora da página e deixar a coluna só com a figura.
- `span: 'page'` em um layout de várias colunas faz do boxe um **bloco de largura de página**: ele é composto na largura total do conteúdo e divide a página em faixas de colunas. As colunas de texto acima dele são fechadas na linha de corte, o boxe ocupa uma coluna própria de largura total e uma nova faixa de colunas de texto se abre abaixo dele, de modo que o fluxo continua sob o boxe em todas as colunas. Onde as colunas estão *niveladas* (no alto de uma página, logo abaixo de um título de abertura `span: 'page'`, logo abaixo de outro bloco de largura de página ou logo abaixo de uma faixa de flutuantes superior), o boxe simplesmente corta ali. Chegando no meio da página, com as colunas desiguais, ele é composto como um compositor faria: o texto acima é cortado nivelado em todas as colunas (o motor refaz a colocação com as colunas da faixa encurtadas para o mesmo número de linhas da grade, de modo que o texto passa de coluna em coluna naturalmente e todas as regras de órfãs, viúvas e manter com o seguinte continuam valendo), o boxe ocupa a largura da página e as colunas continuam abaixo dele. O corte custa algumas passadas extras de colocação; quando a linha de corte não deixaria espaço para o boxe mais o mínimo de linhas do corpo para viúvas abaixo dele, ou nenhuma disposição cabe depois de algumas tentativas, o boxe passa para o alto da página seguinte. O texto acima respeita o corte: um parágrafo que não consegue começar nas poucas linhas que uma coluna mantém acima, sob uma figura, passa para a coluna seguinte (a figura fica então sozinha na sua coluna), e quando um bloco ainda ultrapassaria o corte, o corte é feito uma linha abaixo em vez de onde esse bloco termina. Um boxe dividido que abre a faixa também é cortado ali, de modo que o resto dele nunca ultrapassa o corte. Com `headings.balancing.beforeSpan` (o padrão), a faixa que ele deixa é cortada nivelada atrás dele, como a faixa de fechamento de um capítulo, e, quando o estilo permite a divisão (`keepTogether: false`), a parte do boxe que cabe sob as colunas niveladas fecha a página e o resto abre a seguinte; com `beforeSpan: false`, a página que ele deixa é simplesmente equilibrada como de costume, sem forçar uma quebra de página. Um título logo antes de um bloco de largura de página não o acompanha. Em layouts de uma coluna, `span: 'page'` é simplesmente em linha.
- `placement: 'fixed'` tira o boxe do fluxo: ele é composto (`width: 'auto'` se ajusta ao título; `'fill'` toma a largura da coluna de texto sob o ponto de ancoragem) e fixado na página em que aparece no fluxo, na posição descrita por `fixed.anchor` / `fixed.offset` (por padrão, o canto inferior esquerdo da área de conteúdo). As colunas de texto que ele cobre cedem essa zona (cortada por baixo, ou por cima quando a coluna ainda está vazia), exatamente como uma faixa de flutuantes; quando a zona já contém texto, um flutuante ou um bloco de largura de página, o boxe passa para a página seguinte. Um boxe fixo que fecha o capítulo (o bloco seguinte é uma abertura de capítulo, um `:::part`, um boxe barreira de flutuantes ou o fim do documento) primeiro nivela as colunas acima dele (`headings.balancing.trailing`), de modo que uma página final curta termina nivelada, com o selo embaixo. O quadro e os filhos ficam em `page.floats` e são renderizados fora do recorte das colunas em todos os renderizadores.
- `placement: 'top' | 'bottom'` faz o boxe **flutuar** como um recurso: ele sai do fluxo onde aparece e toma a primeira faixa livre depois desse ponto, isto é, o pé da página atual (`'bottom'`) ou o alto / o pé da próxima página que o fluxo abrir, na largura da coluna (`span: 'column'`) ou na largura total do conteúdo (`span: 'page'`); o texto que vem depois preenche a página que ele deixou. O seu quadro e os seus filhos vão para `page.floats`, como os de um boxe fixo. Um boxe flutuante no alto de uma página nova é colocado antes das figuras que esperam por essa página, e uma figura citada em uma página anterior que então caiba sob ele fica com o resto da página, mesmo que restem menos de três linhas de texto (uma página de galeria: boxe mais figura, sem texto entre eles). Um boxe `span: 'side'` nunca flutua: ele se empilha ao lado do texto, qualquer que seja a sua posição. Com `columns` acima de 1 (no estilo ou como atributo do delimitador, desde o postext 1.18), um boxe `span: 'column'` ocupa esse número de colunas adjacentes: o alto de uma sequência de colunas vazias que começam niveladas, ou o pé da coluna atual e das vazias depois dela, como em `:::callout{placement="top" columns="2"}`.
- `width: 'auto'` se ajusta só ao título; os filhos são ignorados.
- Um `:::callout` aninhado dentro de outro boxe é um boxe próprio: é composto com o seu próprio estilo (fundo, contorno, raio, margem interna, faixa, título, ícone, marcador, aba, tipografia) na largura interna total do pai e se empilha como um filho dele, com o seu `marginTop` / `marginBottom` se fundindo com os vizinhos. O seu `span` e o seu `placement` (do delimitador ou do estilo) são ignorados (um boxe aninhado sempre flui dentro do pai), assim como `floatBarrier` e `snapToGrid`. Os boxes se aninham em qualquer profundidade e podem ficar dentro de um grupo `:::columns` (cada um inteiro, em uma coluna). Quando o pai se divide, o corte cai antes ou depois de um boxe aninhado, ou dentro dele quando o estilo aninhado permite a divisão; cada fragmento redesenha os quadros que atravessa, e um boxe aninhado que continua do fragmento anterior perde o título e o ícone, como uma continuação de primeiro nível.
- Um grupo `:::columns{count=N}` … `:::` entre os filhos compõe esses filhos em `N` colunas de mesma largura, separadas por `columnGap`, dentro do boxe: a sequência é cortada nos limites de bloco ou de linha que melhor nivelam as colunas (um parágrafo ou item de lista cortado no meio continua no alto da coluna seguinte sem o marcador), cada coluna começa no alto do grupo e o grupo tem a altura da coluna mais alta; os filhos depois dele voltam à largura total. Um boxe que se divide (`keepTogether: false`, ou mais alto que uma coluna) também corta dentro de um grupo, entre as suas colunas: um grupo em serpentina (`snake`) preenche as colunas uma após a outra e continua no fragmento seguinte, e um paralelo (`breaks`) continua fluxo por fluxo (desde o postext 1.25; veja [Formato do documento › `:::columns`](https://postext.dev/pt/docs/document-format.md#columns)). Um `gap` no delimitador substitui `columnGap` para esse grupo, e `rule` traça um fio ao longo de cada medianiz. Use-o para um resumo de pontos-chave em duas colunas, ou para as tabelas de um boxe largo postas lado a lado.
- O sexto atributo do delimitador, `label`, é impresso na aba de rótulo do estilo (veja `label` acima): `:::callout{type="box" label="BOX 1-1" title="The octet rule"}`; sem um estilo `label`, o atributo é ignorado.
No VDT, o boxe é um bloco de quadro `type: 'callout'` cuja decoração (fundo, faixa, ícone, título) fica em `designOverlay`, seguido dos seus blocos filhos na mesma coluna; o quadro e cada filho levam o `containerId` do delimitador. Um boxe aninhado é um quadro `type: 'callout'` próprio entre os filhos, seguido dos seus blocos; eles mantêm o `containerId` do delimitador de primeiro nível (a colocação e o equilíbrio continuam vendo uma só unidade) e acrescentam `calloutPath`, os ids de contêiner dos delimitadores aninhados em volta deles, do mais externo para o mais interno (o id do próprio quadro aninhado é a última entrada). O PDF com tags dá a cada boxe aninhado um `Div` dentro daquele do pai. As imagens de ícone são resolvidas como as imagens de recursos: o registro de imagens do canvas, a opção `resourceImageUrl` do HTML e o provedor `resourceBytes` do PDF.
```ts
const resolved = resolveCalloutStylesConfig(config.calloutStyles, resolvedBodyText, resolvedHeadings, resolvedUnorderedLists, config.locale);
// => todo campo herdado é preenchido a partir das seções resolvidas; o locale
// opcional escolhe o idioma das strings de continuação
const minimal = stripCalloutStylesDefaults(config.calloutStyles);
// => undefined para o padrão `note` embutido; os padrões estáticos são removidos
```
### Enunciados numerados e demonstrações
Um estilo com `numbering` conta os seus boxes, como o `amsthm` do LaTeX conta os ambientes de teorema (desde o postext 1.19). Cada boxe imprime o seu rótulo e número (“**Theorem 2.**” abrindo o primeiro parágrafo), e o `title` do delimitador vem depois do número, entre parênteses: `:::callout{type="theorem" title="Bradley–Terry"}` começa com “**Theorem 2** (Bradley–Terry)**.**”. Um boxe aberto com um identificador (`{#thm:main}`) é alvo de referências cruzadas, que imprimem “Theorem 2” (`:ref{id="thm:main"}`), e `\ref{thm:main}` ou `style=number` imprime 2.
| Campo | Tipo | Padrão | Descrição |
| --- | --- | --- | --- |
| `label` | `string` | — | A palavra antes do número: `'Theorem'`, `'Lemma'`, `'Definición'`. |
| `counter` | `string \| false` | o `id` do estilo | O contador que os boxes incrementam. Estilos que indicam o mesmo contador o compartilham, como faz `\newtheorem{lemma}[theorem]`: Teorema 1, Lema 2, Teorema 3. `'equation'` conta junto com as equações rotuladas. `false` imprime o rótulo sem número (o “*Demonstração.*” de uma demonstração). |
| `numberingTemplate` / `resetOn` / `counterFormat` | `string` / `ResourceCounterReset` / `ResourceCounterFormat` | `'{n}'` / `'never'` / `'decimal'` | Como os de um tipo de recurso: `'{h1}.{n}'` com `resetOn: 'h1'` numera Teorema 2.1, 2.2… por capítulo; `'{h1}.{h2}.{n}'` com `'h2'`, por seção. Um contador compartilhado por vários estilos conta sobre o que os modelos deles imprimirem. |
| `placement` | `'runIn' \| 'title'` | `'runIn'` | `'runIn'` abre o primeiro parágrafo do boxe com o rótulo (um boxe que começa com uma lista, uma fórmula ou outro boxe ganha um parágrafo para ele); `'title'` faz do rótulo o título do boxe, no seu `titleStyle`: “Theorem 2 (Bradley–Terry)”. |
| `bold` / `italic` | `boolean` | `true` / `false` | O estilo do rótulo em linha e do seu sufixo, qualquer que seja o corpo do boxe: um corpo em itálico (`body.italic`) mantém redondo um rótulo redondo. O título entre parênteses é composto em redondo, no peso regular. |
| `suffix` | `string` | `'.'` | Colocado depois do rótulo em linha e do seu título. |
Uma demonstração é um estilo com um rótulo sem número e uma marca final:
```ts
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 } },
]
```
Em um livro diagramado capítulo por capítulo, os contadores continuam a partir do capítulo anterior (`LayoutContinuation.statementCounters`, que `continuationAfter` preenche), e o esboço do livro dá à âncora de cada boxe numerado o seu rótulo (`OutlineEntry.numberLabel`), para que uma referência vinda de outro capítulo o imprima.
### Tipografia dentro de um boxe
Um boxe compõe o seu conteúdo com a sua própria tipografia `body` e `lists`; todo o resto mantém os estilos do documento:
- **Parágrafos** recebem o `body` do boxe: fonte, tamanho, entrelinha, cor, cores de ênfase, pesos, `italic`, `smallCaps`, alinhamento, hifenização, recuo e espaçamento entre parágrafos. Um campo não definido herda `bodyText`. Uma cor de ênfase herdada mantém o vínculo com a paleta, de modo que o negrito, o itálico e os rótulos de `:ref` em um boxe mudam com `colorPalette` como mudam fora dele. (Até o postext 1.4, o negrito em um boxe ficava `#295AA3` qualquer que fosse a cor principal.)
- **Listas com marcadores** recebem o `lists` do boxe (caractere do marcador, cor, tamanho e peso do glifo, recuo, espaço, espaçamento entre itens) por cima de `unorderedLists`, e o texto delas é o texto do corpo do boxe. Um `lists.bulletChar` ou `lists.color` diferente do documento (`unorderedLists`) substitui o marcador ou a cor de todos os níveis; um que o repita, ou que fique sem definir, deixa a cada nível o seu (`unorderedLists.levels`), de modo que os travessões aninhados se mantêm no boxe.
- **Listas numeradas** recebem `lists.indent`, `gap` e `itemSpacing`, e `lists.color` sempre que o estilo a define, inclusive quando é a cor dos marcadores do documento; um estilo que a deixa sem definir mantém os números em `orderedLists.color`. (Até o postext 1.4, a cor só chegava aos números quando era diferente de `unorderedLists.color`, de modo que defini-la com essa mesma cor não fazia nada.) O número em si (a sua fonte, tamanho e separador) vem do `orderedLists` global, já que `lists` só tem campos de marcador: estilize ali os números de um boxe.
- **`:::paragraphs` dentro de um boxe** usam o seu estilo de parágrafo, também em boxes aninhados. Os campos que o estilo deixa sem definir herdam o `bodyText` do documento, não o `body` do boxe (nem o seu itálico ou versaletes).
- **Grupos `:::columns`** não têm estilo próprio: todas as colunas compartilham a tipografia de corpo e de listas do boxe, e `columnGap` define o espaço entre elas.
- **Citações** recebem a fonte, o tamanho e os pesos do corpo do boxe (em itálico e cinza, como no texto corrido), e os seus versaletes. **Títulos** mantêm os estilos de título; **fórmulas em destaque**, as configurações de matemática.
- **Figuras e tabelas** mantêm os estilos de legenda e de tabela do documento, na largura interna do boxe; os seus pesos regular e negrito seguem os pesos do `body` do boxe.
- **Chips** mantêm o seu estilo de chip; um tamanho em `em` é medido sobre o tamanho do corpo do boxe.
- **`:::space`** é medido em linhas do corpo do boxe (veja [`:::space`](https://postext.dev/pt/docs/document-format.md#space) para saber onde ele é descartado).
- **Um boxe aninhado** recebe o seu próprio estilo por inteiro; o seu `span`, `placement`, `floatBarrier` e `snapToGrid` são ignorados.
### Marcas em um boxe dividido
Quando um boxe se divide entre colunas ou páginas (`keepTogether: false`, ou um boxe mais alto que uma coluna), cada parte depois da primeira começa sem o título e sem o ícone e, por padrão, nada avisa o leitor de que o boxe continua. Duas opções acrescentam as marcas que um livro ou um roteiro usa:
- **`repeatTitle: true`** repete o título no alto de cada continuação, seguido de `continuedSuffix` (“Pontos-chave (cont.)” por padrão). A repetição usa o estilo do título, de modo que, com `textTransform: 'uppercase'`, ela dá o “HAMLET (CONT'D)” de um roteiro. O ícone e a aba de rótulo ficam na primeira parte.
- **`continuesMarkerEnabled: true`** põe `continuesMarker` (“Continued”, ou “Continúa” em um documento em espanhol) sob a última linha de cada parte que continua, dentro do boxe, na fonte e no tamanho do corpo do boxe: em itálico a menos que `continuesMarkerItalic` seja `false`, alinhado à direita a menos que `continuesMarkerAlign` diga `'left'` ou `'center'`. A marca ocupa espaço na parte que fecha, e o corte é escolhido de modo que ela caiba.
```ts
calloutStyles: [{
id: 'speech',
keepTogether: false,
titleStyle: { textTransform: 'uppercase' },
repeatTitle: true,
continuedSuffix: "(CONT'D)",
continuesMarkerEnabled: true,
continuesMarker: '(MORE)',
continuesMarkerAlign: 'center',
continuesMarkerItalic: false,
}],
```
```md
:::callout{type="speech" title="Hamlet"}
A speech long enough to run over the foot of the page…
:::
```
A parte que fecha a página termina com “(MORE)”, e a página seguinte começa com “HAMLET (CONT'D)”. As duas são elementos de paginação: em um PDF acessível são artefatos e no HTML ficam ocultas para as tecnologias assistivas, de modo que o título é lido uma só vez. No VDT são blocos de texto de `designOverlay` marcados com `artifact: true`.
## Partes
A propriedade `parts` configura as páginas divisórias de parte que um documento abre com um contêiner `:::part{number="…" title="…"}`: a página “Parte I — Fundamentos” que agrupa uma sequência de capítulos. Uma parte sempre ocupa uma página própria: o contêiner quebra para uma página nova da paridade configurada, transforma-a em uma página de coluna única cuja área do corpo vem de `parts.margins`, aplica o design de abertura sobre a página inteira e quebra de novo depois do delimitador de fechamento, para que o capítulo seguinte (com o seu próprio `breakBefore.parity`) comece limpo. Com as configurações padrão de H1, isso dá a clássica página de parte em página ímpar, o verso em branco e o capítulo na página ímpar seguinte.
```ts
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' } },
},
};
```
```md
:::part{number="I" title="Foundations"}
1. The lantern and its parts
2. Trimming the wick
3. Reading the weather
:::
# The lantern and its parts
```
| Propriedade | Tipo | Padrão | Descrição |
| --- | --- | --- | --- |
| `page` | `boolean` | `true` | Se um `:::part` abre uma página divisória. Com `false`, nenhuma página é aberta e o corpo do delimitador não é composto: o número, o título e a paleta da parte valem a partir do conteúdo seguinte, sem quebra própria. Uso típico: `htmlViewer.overrides.parts.page: false`, uma edição para tela sem divisórias de seção. |
| `breakBefore.parity` | `HeadingBreakParity` | `'odd'` | Paridade da página em que a parte começa. Mesmos valores e mesmas regras de posse das páginas em branco que o [breakBefore](https://postext.dev/pt/docs/configuration-text.md#quebra-antes) dos títulos: uma página em branco inserida para alcançar a paridade pertence à parte (o seu `{partTitle}` já resolve para a nova parte); o separador obrigatório de `'always-*'` pertence ao conteúdo anterior. |
| `breakAfter.enabled` | `boolean` | `true` | Leva o conteúdo depois do delimitador de fechamento para uma página nova. Com `false`, ele continua na coluna única da página da parte. |
| `breakAfter.parity` | `HeadingBreakParity` | `'any'` | Paridade dessa página nova. Deixe em `'any'` e deixe que o próprio `breakBefore.parity` do capítulo seguinte decida se vem um verso em branco. A quebra é aplicada quando o bloco seguinte é colocado, de modo que uma parte que fecha o documento não deixa uma página vazia no fim. |
| `margins` | `PageMargins` | margens da página | Área do corpo da página da parte: a coluna única em que fluem os blocos dentro do delimitador. Cada lado herda a margem da página quando não definido; `mirror` troca interna/externa nas páginas pares, exatamente como as margens da página. |
| `design` | `DesignSlot` | vazio | Design da abertura. O seu contêiner é a **caixa de refile** da página, de modo que as âncoras de contêiner e as âncoras `'page'` coincidem e `'bleed'` vai até a sangria quando as marcas de corte estão ativadas. É puramente decorativo: nunca reserva espaço no corpo; aumente `margins.top` para manter o corpo livre dele. Quando vazio, um texto padrão `{number} {titleText}` na tipografia do H1 é gerado no canto superior esquerdo da área do corpo, com o `numberSeparator` do H1 entre o número e o título. |
| `versoDesign` | `DesignSlot` | vazio | Design do verso em branco que vem depois de uma página de parte (o verso da folha divisória): mesmo contêiner e mesmos marcadores de substituição que `design`. Deixe vazio para um verso liso. Só é pintado quando a página depois da página da parte fica em branco, o que exige uma quebra com paridade: veja [O design do verso](https://postext.dev/pt/docs/configuration-styles.md#o-design-do-verso) abaixo. |
| `bodyStyle.fontFamily`, `fontSize`, `lineHeight`, `color`, `textAlign` | como em `bodyText` | herdam `bodyText` | Tipografia dos parágrafos, citações e itens de lista dentro do delimitador. Os pesos, as cores de ênfase e a hifenização vêm do texto do corpo. |
| `bodyStyle.bulletColor` | `ColorValue` | `unorderedLists.color` | Cor dos marcadores das listas não numeradas dentro da parte. |
| `bodyStyle.numberColor` | `ColorValue` | `orderedLists.color` | Cor dos números das listas numeradas dentro da parte. Os números são sempre compostos no peso negrito do corpo, para que uma lista de capítulos se leia como um sumário. |
| `bodyStyle.unorderedLists` | `UnorderedListsConfig` | — | Substituições parciais aplicadas por cima do `unorderedLists` do documento dentro da parte, depois de `bulletColor`. Os valores gerais da lista se propagam para os níveis que os herdavam; as entradas de `levels` valem só para o seu nível. |
| `bodyStyle.orderedLists` | `OrderedListsConfig` | — | Substituições parciais aplicadas por cima do `orderedLists` do documento dentro da parte, depois de `numberColor` e do peso negrito; por exemplo, um `separator` `'•'` com o seu próprio `separatorFontFamily` e `separatorColor` para a lista de capítulos de uma abertura de parte. |
### Marcadores do design de parte
O slot de design resolve o conjunto de marcadores de título com os valores da própria parte: `{titleText}` é o `title` do bloco; `{number}`, o `number` exatamente como foi escrito; `{numberDecimal}`, `{numberRoman}`, `{numberRomanLower}`, `{numberAlpha}`, `{numberAlphaLower}` o reformatam (o número é lido como decimal, como algarismo romano ou como numerais chineses, com ou sem as palavras que o envolvem: `"IV"`, `"iv"`, `"4"`, `"４"`, `"四"`, `"卷四"` e `"第四卷"` dão todos `{numberDecimal}` = `4`) e resultam em `''` para qualquer outra coisa. Também estão disponíveis `{partTitle}` / `{partNumber}`, `{chapterTitle}` / `{chapterNumber}` (o capítulo anterior à parte), `{pageNumber}`, `{totalPages}`, `{bookTotalPages}` e os marcadores de metadados. `{attr.}` lê os atributos do H1 do capítulo atual.
### O design do verso
`versoDesign` decora a página logo depois de uma página de parte quando essa página não tem conteúdo: o verso da folha divisória. A parte sozinha nunca deixa essa página em branco. `breakAfter.parity` tem `'any'` como padrão, então o conteúdo depois do bloco começa na página seguinte, a menos que algo peça uma paridade:
- **O título do capítulo seguinte.** O `breakBefore` padrão do H1 é `'always-odd'`, e `'odd'` faz o mesmo depois de uma página de parte em página ímpar: o capítulo passa para a próxima página ímpar e o verso fica em branco. O design do verso é pintado.
- **`parts.breakAfter: { enabled: true, parity: 'odd' }`.** A própria parte pede a próxima página ímpar, faça o que fizer o título seguinte. Use quando os capítulos puderem abrir em qualquer lado (`breakBefore.parity: 'any'`, ou `breakBefore.enabled: false`).
Sem nenhum dos dois, o capítulo abre no verso e nenhum design de verso é desenhado. Com `breakAfter.enabled: false`, o conteúdo continua na própria página de parte. O verso usa a paleta da parte, então um `palette="band=#…"` no bloco também muda a cor dele.
```ts
parts: {
breakBefore: { parity: 'odd' },
breakAfter: { enabled: true, parity: 'odd' }, // sempre um verso em branco para pintar
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' } },
}],
},
}
```
**Uma parte que fecha o seu capítulo.** Num livro diagramado capítulo a capítulo (o Sandbox, `buildBundle`), um bloco `:::part` pode ser um capítulo sozinho, ou o fim de um. A página de parte é então a última página do capítulo, e o capítulo seguinte assume o que a parte ainda deve: aplica `breakAfter` antes do seu primeiro bloco e pinta `versoDesign` na sua primeira página quando essa página fica em branco. As páginas saem como sairiam com o livro inteiro num só documento. Depois do bloco só podem vir diretivas que não posicionam nada (`:::numbering`, `:::space`); qualquer outra coisa é conteúdo do capítulo, que então faz a quebra por conta própria. Um capítulo vazio logo depois da parte é uma página própria: essa página é o verso. Um host que diagrama os capítulos por conta própria obtém isso de `continuationAfter()`, que informa `afterPartPage: true` para um capítulo que termina com uma parte; repasse esse valor na `continuation` do capítulo seguinte.
### O contêiner `:::part`
Uma linha `:::part{number="…" title="…"}` abre a parte e um `:::` sozinho a fecha; os dois atributos são opcionais (o padrão é `''`). Os blocos entre eles (normalmente a lista de capítulos) correm na coluna única da página de parte com `bodyStyle`, a partir de `margins.top`; um corpo mais longo que a página continua em páginas comuns. A página é classificada como `role: 'part'` (`VDTPage.partInfo` traz o número e o título), de modo que os elementos de cabeçalho e rodapé podem visá-la ou pulá-la com `pages: 'part'` / `pages: 'body'`; o renderizador de PDF acrescenta a parte aos marcadores do PDF, acima dos seus capítulos. Um corpo vazio (`:::part{…}` seguido diretamente de `:::`) é o caso comum e ainda assim produz a página; duas partes seguidas nunca dividem uma página. Um `:::part` aninhado em outra parte é incorporado à parte externa.
Um terceiro atributo, `palette="=[, =…]"`, dá à parte as suas próprias cores: na página de parte e em todas as páginas que vêm depois dela, até a parte seguinte, cada cor de design (cabeçalho, rodapé, faixa de abertura, designs de parte e de verso) vinculada a um desses ids de paleta usa o valor da parte em vez do valor da paleta do documento. É assim que as seções de um livro mudam a cor da aba do canto, do ponto do cabeço e da faixa de abertura de capítulo sem um segundo design: `:::part{number="II" title="…" palette="band=#f6c297"}`. O fluxo de texto acompanha: nessas mesmas páginas, toda cor do fluxo igual ao valor base de uma entrada de paleta substituída (títulos, cores de negrito, itálico e referências, marcadores e números de lista, rótulos e barras de legenda, texto, fios e preenchimentos de tabela (cabeçalho, corpo, linhas alternadas e o preenchimento próprio de uma célula), boxes (fundo, borda, faixa, título) e chips (preenchimento, contorno e texto)) usa o valor da parte, de modo que um `headings.levels[1].color` vinculado a `band` compõe os títulos de cada seção na sua própria cor. As amostras de cor no texto mantêm a cor escrita nelas. Os pares são separados por vírgulas, ponto e vírgula ou espaços, `=` ou `:` une id e cor, e o `#` é opcional. Uma parte continua valendo depois que o bloco fecha: `{partTitle}`, `{partNumber}` e a paleta acompanham o fluxo nos capítulos seguintes e (por meio de `continuation.part`, que `continuationAfter()` informa) nos capítulos diagramados separadamente, de modo que o segundo capítulo de uma seção mostra a seção nos cabeços exatamente como o primeiro.
Duas entradas da paleta podem ter o mesmo valor base e ainda assim receber valores diferentes numa parte, quando a parte substitui uma e não a outra ou dá a elas cores diferentes. O valor sozinho não diz de qual entrada veio uma cor do fluxo, então cada cor do fluxo é comparada com as configurações de onde ela pode vir e usa o valor a que essas configurações estão vinculadas. Distinguem-se:
- as cores do texto de um bloco: a cor do texto, as cores de negrito, itálico e referências, o marcador de lista (um marcador ou um número) e o separador depois de um número. Com `bodyText.color` vinculado a `ink` e `bodyText.boldColor` vinculado a `accent`, ambos `#1a1a1a`, uma parte com `palette="accent=#b8413d"` muda a cor dos trechos em negrito e deixa o texto como está; se for `unorderedLists.color` o vinculado a `accent`, muda a cor dos marcadores e deixa o texto dos itens;
- cada nível de título, e cada estilo de título que define uma cor;
- o texto de uma linha do sumário, o seu número, e o seu número de página e subtítulo;
- em cada estilo de boxe, os preenchimentos (fundo, faixa, aba do rótulo), a borda, os fios (do marcador e do rótulo) e o texto (título, ícone, glifo do marcador, rótulo);
- cada cor de cada estilo de tabela, de chip e de legenda. Um estilo de tabela nomeado é distinto de `tableStyle`, e o estilo de legenda de um tipo de recurso é distinto de `captionStyle`. O preenchimento próprio de uma célula segue o seu próprio vínculo.
Ainda resta um caso decidido pelo valor: configurações em lugares diferentes que definem a mesma cor de um bloco. `bodyText.color`, `bodyText.blockquote.color`, o `color` de um estilo de parágrafo e o `body.color` de um estilo de boxe definem todos a cor do texto de um bloco, por exemplo. Quando duas delas se vinculam a entradas com o mesmo valor base e a parte as separa, a cor usa a substituição (a última escrita, quando as duas são substituídas). Dê a essas entradas valores base próprios.
```ts
const resolved = resolvePartsConfig(config.parts, resolvedPage, resolvedBodyText, resolvedUnorderedLists, resolvedOrderedLists);
// => margens preenchidas a partir da página, bodyStyle a partir das configurações do corpo / das listas
const minimal = stripPartsDefaults(config.parts);
// => undefined quando só restam padrões estáticos
```
## Estilos de título
A propriedade `headingStyles` declara estilos nomeados que um documento aplica a um título com `# Title {style=""}`. Um estilo faz duas coisas. Substitui a tipografia, o design e a numeração do nível do título (qualquer campo de uma entrada de nível exceto `level`: fonte, corpo, cor, `breakBefore`, `span`, `advancedDesign`, `textTransform`, `hidden`, `numberingTemplate`…) e rege a **seção** que o título abre: as páginas dela, até o próximo título do mesmo nível ou de um nível superior, usam os cabeços, a geometria de página, a tipografia do corpo e a paleta do estilo. É assim que os elementos pré-textuais de um livro (um prefácio numa única coluna larga, com fólios em algarismos romanos e faixas azuis) convivem com um manual em duas colunas e numeração decimal sem uma segunda configuração.
```ts
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' },
},
],
};
```
```md
# Preface {style="front-matter"}
```
| Propriedade | Tipo | Padrão | Descrição |
| --- | --- | --- | --- |
| `id` | `string` | — | Identificador referenciado por `{style="…"}` numa linha de título. Um id desconhecido deixa o título como está. |
| `name` | `string` | `id` | Nome legível (só na interface do editor). |
| `numbered` | `boolean` | `true` | Se o título conta: avança o contador do seu nível (os números do `numberingTemplate`, o `{h1}` dos números de recursos), o ordinal de capítulo por trás de `{chapterNumber}` e o número impresso no sumário. `false` para um prefácio, uma lista de autores, um índice: o primeiro capítulo numerado depois deles continua sendo o capítulo 1, e `{chapterNumber}` fica vazio nas páginas deles. |
| `toc` | `boolean` | `true` | Se `:::toc` lista o título. Um título substitui isso com `{toc="false"}` / `{toc="true"}`. |
| `runningChapter` | `boolean` | `true` | Se um título de nível 1 deste estilo passa a ser o capítulo corrente: o capítulo que `{chapterTitle}`, `{chapterNumber}`, `{attr.}` e as suas formas `…AtTop` nomeiam na página dele e nas seguintes. `false` para uma prancha, um mapa ou uma capa composta como H1 dentro de um capítulo: os cabeços passam por cima dele, inclusive na sua própria página, e continuam nomeando o capítulo que ele interrompe; ele também não define nenhuma palavra-guia `h1`. O título continua contando quando `numbered` (o seu próprio design lê o seu próprio `{chapterNumber}`) e continua listado por `:::toc` quando `toc`. Com `toc: false` também, não recebe marcador no PDF: a prancha de um capítulo na página antes da abertura deixa os marcadores para os capítulos. Títulos de outros níveis ignoram esta opção. Com o padrão, as páginas depois de uma prancha imprimem o título da prancha. Um prefácio ou um prólogo com `numbered: false` continua sendo um capítulo próprio e mantém o padrão. A opção muda apenas qual capítulo os marcadores nomeiam: o estilo continua abrindo uma seção própria, como todo estilo de título, então até o próximo título de nível 1 as páginas usam os slots de cabeço, as margens, as colunas, o estilo do corpo e a paleta do estilo da prancha (os do documento quando o estilo não define nenhum), e não os de uma seção com estilo aberta pelo capítulo interrompido. Num livro diagramado capítulo a capítulo, os cabeços não passam de um arquivo de capítulo para o seguinte, então uma prancha que abre um arquivo mostra os marcadores de capítulo vazios até o primeiro título de capítulo do arquivo. |
| campos do nível | como em `headings.levels[]` | os valores do nível | `fontFamily`, `fontSize`, `lineHeight`, `fontWeight`, `italic`, `color`, `marginTop`, `marginBottom`, `snapToGrid`, `breakBefore`, `span`, `advancedDesign`, `textTransform`, `letterSpacing`, `lineSpan`, `indent`, `firstLineIndent`, `jidori`, `dropCap`, `hidden`: cada um que for definido substitui o valor do nível do título para os títulos deste estilo (`dropCap: false` tira a capitular do nível). `breakBefore` é mesclado campo a campo sobre o do nível: um estilo que só define `parity` mantém o `enabled` do nível, e um que só define `enabled: true` mantém a paridade do nível (até o postext 1.4, o campo ausente vinha do padrão sem quebra). |
| `numberingTemplate` | `string` | o do nível | Modelo com que os títulos do estilo são numerados, no lugar do modelo do nível (os mesmos tokens de [`levels[].numberingTemplate`](https://postext.dev/pt/docs/configuration-text.md#sobrescritas-por-nível)). O contador continua sendo o do nível: um estilo de apêndice com `'Appendix {1:A}'` depois de cinco capítulos imprimiria *Appendix F*, então reinicie a contagem com `{startAt=1}` no primeiro apêndice. `''` não imprime número, mas o título continua contando: nem mesmo o ordinal de capítulo que o sumário e `{chapterNumber}` mostram para um título de nível 1 sem modelo. O número aparece no fluxo, no `{number}` do design do estilo, no sumário e em `{chapterNumber}`. |
| `header`, `footer` | `DesignSlot` | os do documento | Cabeços das páginas da seção, que substituem `header` / `footer` ali (os filtros `parity` e `pages` dos elementos continuam valendo). Um slot vazio os remove. |
| `margins` | `PageMargins` | margens da página | Área do corpo das páginas da seção; cada lado herda a margem da página quando não definido, `mirror` inclusive. Vale nas páginas que a seção abre: combine com `breakBefore`. |
| `layout` | `LayoutConfig` | `layout` | Disposição de colunas das páginas da seção (`layoutType`, `gutterWidth`…): uma única coluna larga para um prefácio composto num livro de duas colunas. O seu `columnRule` é desenhado nas páginas da seção, e cada campo que ele deixa sem valor usa o valor de `layout.columnRule` do documento, então uma seção que só muda as colunas mantém o fio do documento (veja [Fio entre colunas](https://postext.dev/pt/docs/configuration-page-layout.md#fio-entre-colunas)). |
| `bodyStyle` | `PartsBodyStyleConfig` | herda `bodyText` | Tipografia dos parágrafos, citações e listas da seção: os mesmos campos de [parts.bodyStyle](https://postext.dev/pt/docs/configuration-styles.md#partes). |
| `palette` | `Record` | `{}` | Substituições de paleta (id → hex) para as páginas da seção, por cima das da parte atual: o mesmo mecanismo do atributo `palette` de uma parte, e com o mesmo alcance. Vale não só para os slots de design dessas páginas (cabeços, a faixa de abertura, toda cor vinculada a um id substituído), mas também para o fluxo de texto, pelo valor: toda cor do fluxo igual ao valor base de uma entrada substituída (títulos, cores de negrito, itálico e referências, marcadores e números de lista, rótulos e barras de legenda, texto, fios e preenchimentos de tabela, boxes (fundo, borda, faixa, título) e chips (preenchimento, contorno e texto)) usa o valor da seção, como acontece numa parte, incluindo a regra para duas entradas com o mesmo valor base (veja [O contêiner `:::part`](https://postext.dev/pt/docs/configuration-styles.md#o-contêiner-part)). As amostras de cor no texto mantêm a cor escrita nelas. A cor da página também acompanha: quando `page.backgroundColor` está vinculada a uma entrada substituída (ou, sem vínculo, tem o valor base dela), as páginas da seção são pintadas com o valor da seção, e assim as páginas de economia de um jornal saem em salmão enquanto as demais ficam brancas. Desde o postext 1.18. |
A seção fecha no próximo título do mesmo nível ou de um nível superior: um `#` sem estilo depois de um com estilo volta aos cabeços e à geometria do documento; um com estilo abre a sua própria seção. As páginas que a seção deixou em branco por paridade pertencem a ela, como acontece com os títulos de capítulo.
**Uma quebra de página não substitui a quebra do próprio título.** Um estilo herda o `breakBefore` do seu nível (o padrão do nível 1 é `{ enabled: true, parity: 'always-odd' }`), e um título o aplica onde quer que esteja, inclusive logo depois de um `:::pagebreak`. A quebra de página abre uma página nova, e o título ainda pede o seu lado da página dupla. Com `parity: 'odd'`, uma quebra que cai num verso é seguida de uma página em branco, e o título abre na próxima página ímpar. Com `'always-odd'` vem também a página em branco separadora, e a quebra de página não muda nada, já que o título abriria essa página de qualquer jeito. Um estilo que deve começar na página aberta por uma quebra manual, como uma página de sumário depois da folha de rosto, desliga a sua própria quebra:
```ts
headingStyles: [
// Começa onde o texto o põe: na página que o `:::pagebreak` anterior abriu.
{ id: 'contents', numbered: false, toc: false, breakBefore: { enabled: false } },
],
```
Para ter uma página própria sem escolher lado, use `breakBefore: { parity: 'any' }` e deixe de fora o `:::pagebreak`.
**A que seção uma página pertence.** Cabeços e paleta são escolhidos por página, não por título. Uma página fica com a seção em vigor depois da última mudança de seção nela: onde uma seção termina e outra começa na mesma página (duas letras curtas de um dicionário, por exemplo), a página leva os cabeços e a paleta da segunda; onde uma seção com estilo termina no meio da página num título sem estilo, a página volta aos do documento. `{chapterTitle}` segue a mesma regra: uma página onde dois capítulos se encontram mostra o título do segundo. As páginas em branco seguem a regra dos [títulos de capítulo](https://postext.dev/pt/docs/configuration-text.md#a-quem-pertencem-as-páginas-em-branco): uma página em branco de paridade (`blankForParity`) pertence à seção que abre depois dela, e a separadora que uma quebra `'always-odd'` / `'always-even'` acrescenta (`blankForForce`) pertence à seção anterior. Uma divisória de parte fecha a seção aberta.
```md
# A {style="letter"}
Aardvark, abacus.
# B {style="letter"}
Babble, badger… (runs on to the next page)
```
As duas letras começam na página 1, então a página 1 usa os cabeços da seção `B`: uma aba lateral definida no cabeçalho do estilo mostra “B” ali, e nenhuma página leva a aba de “A”. Dê a cada seção uma página própria (`breakBefore`) quando todas precisarem da sua aba.
Apêndices com letras depois de capítulos numerados, e uma página de dedicatória que o sumário e os marcadores do PDF listam, mas que a página não titula:
```ts
headingStyles: [
{ id: 'appendix', numberingTemplate: 'Appendix {1:A}' },
{ id: 'silent', hidden: true, numbered: false },
],
```
```md
# Dedication {style="silent"}
For M., who read every draft.
# Method
…
# Survey instrument {style="appendix" startAt=1}
# Raw data {style="appendix"}
```
Com `numberingTemplate: '{1}.'` no nível 1, os capítulos imprimem *1.*, *2.*…, e os apêndices *Appendix A* e *Appendix B*. A dedicatória abre a sua página (o `breakBefore` do seu nível), imprime só o seu parágrafo e ainda aparece como *Dedication* em `:::toc`, nos cabeços com `{chapterTitle}` e nos marcadores do PDF; acrescente `toc: false` ao estilo para tirá-la do sumário. Uma prancha ou um mapa composto como H1 no meio de um capítulo pede o contrário da dedicatória: um estilo com `runningChapter: false` (em geral com `numbered: false` e `toc: false`) mantém os cabeços no capítulo que ele interrompe.
```ts
const resolved = resolveHeadingStylesConfig(config.headingStyles, resolvedPage, resolvedBodyText, resolvedUnorderedLists, resolvedOrderedLists);
// => substituições de nível normalizadas, margens preenchidas a partir da página, bodyStyle a partir do corpo
const minimal = stripHeadingStylesDefaults(config.headingStyles);
// => undefined quando não resta nenhum estilo
```