# Un llibre de cartró de cucut amb forats en registre

> Quatre forats troquelats on la pintura següent guarda el que enganya, una finestra que baixa a un forat més petit, cantonades arrodonides i línia de troquel.

- Versió HTML: https://postext.dev/ca/cookbook/peek-a-boo-board-book
- Recepta Núm. 193 · Sortida i integració · Nivell 2 (Intermedi) · Sortides: Canvas, PDF, Controls en viu
- Gèneres: Fulls solts i efímers
- Requereix postext ≥ 1.84.0, postext-pdf ≥ 1.84.0 · provada amb 1.84.0, postext-pdf 1.84.0 el 2026-11-13
- Pàgines: [1](https://postext.dev/cookbook/peek-a-boo-board-book/es/p01.webp?v=3c923bfe), [2](https://postext.dev/cookbook/peek-a-boo-board-book/es/p02.webp?v=3c923bfe), [3](https://postext.dev/cookbook/peek-a-boo-board-book/es/p03.webp?v=3c923bfe), [4](https://postext.dev/cookbook/peek-a-boo-board-book/es/p04.webp?v=3c923bfe), [5](https://postext.dev/cookbook/peek-a-boo-board-book/es/p05.webp?v=3c923bfe), [6](https://postext.dev/cookbook/peek-a-boo-board-book/es/p06.webp?v=3c923bfe), [7](https://postext.dev/cookbook/peek-a-boo-board-book/es/p07.webp?v=3c923bfe), [12](https://postext.dev/cookbook/peek-a-boo-board-book/es/p12.webp?v=3c923bfe), [13](https://postext.dev/cookbook/peek-a-boo-board-book/es/p13.webp?v=3c923bfe), [14](https://postext.dev/cookbook/peek-a-boo-board-book/es/p14.webp?v=3c923bfe)
- PDF: https://postext.dev/cookbook/peek-a-boo-board-book/es/peek-a-boo-board-book.pdf?v=3c923bfe
- Obre al Sandbox: https://postext.dev/ca/sandbox#recipe=peek-a-boo-board-book&lang=es (.postext: https://postext.dev/cookbook/peek-a-boo-board-book/es/peek-a-boo-board-book.postext)
- Última actualització: 2026-11-13
- Altres idiomes: [en](https://postext.dev/en/cookbook/peek-a-boo-board-book.md), [es](https://postext.dev/es/cookbook/peek-a-boo-board-book.md), [de](https://postext.dev/de/cookbook/peek-a-boo-board-book.md), [fr](https://postext.dev/fr/cookbook/peek-a-boo-board-book.md), [it](https://postext.dev/it/cookbook/peek-a-boo-board-book.md), [pt](https://postext.dev/pt/cookbook/peek-a-boo-board-book.md), [zh](https://postext.dev/zh/cookbook/peek-a-boo-board-book.md), [ja](https://postext.dev/ja/cookbook/peek-a-boo-board-book.md), [ar](https://postext.dev/ar/cookbook/peek-a-boo-board-book.md)

## En poques paraules

Un llibre de cartró per als més petits. Cada forat d’una pàgina deixa veure un trosset del dibuix següent, el text fa una pregunta i en girar el full es veu què era de debò.

## Què compondràs

*Cucut! Qui hi ha al jardí?*, un llibre de cartró de catorze pàgines en un quadrat de 160 mm amb les quatre cantonades arrodonides. Cada pintura té un forat, i el forat és just on la pintura següent guarda la part que enganya l’ull: el llom ratllat d’un gat adormit que podria ser un tigre, la llana d’una ovella que podria ser un núvol, un fanalet que podria ser la lluna. La finestra de la coberta és més ampla que el forat de darrere, i la primera mirada arriba dues pàgines al fons. El text de l’esquerra pregunta; en girar el full arriba la resposta. El PDF d’impremta porta la línia de troquel en una planxa pròpia.

**Aquesta recepta respon a:**

- Com troquelo forats a les pàgines d’un llibre perquè cadascun deixi veure part del dibuix següent?
- Com lliuro al troquelista la línia de troquel en una planxa pròpia del PDF?

## La resposta curta

```js
// script.js, línies 43–61
// Each painting is cut where the next one's telling part lies: the cat's striped flank, the
// sheep's wool, the lantern's glow. The cover's window is wider than the hedge's hole and
// holds it, so from the cover you see the hedge, and through the hedge the cat. A hole cuts
// both sides of its leaf, mirrored on the verso, and the words there run round it.
const circle = (id, name, cx, cy, d) => ({ id, name, shape: 'circle', x: mm(cx - d / 2),
  y: mm(cy - d / 2), width: mm(d), height: mm(d), wrap: { gap: mm(4) } });
const dieCuts = {
  shapes: [
    circle('window', t({ en: 'Cover window', es: 'Ventana de la cubierta' }), 112, 68, 60),
    circle('hedge', t({ en: 'Gap in the hedge', es: 'Hueco del seto' }), 112, 60, 36),
    { id: 'knot', name: t({ en: 'Knothole', es: 'Nudo de la valla' }), shape: 'ellipse',
      x: mm(102), y: mm(48), width: mm(32), height: mm(40), wrap: { gap: mm(4) } },
    circle('peephole', t({ en: 'Barn-door peephole', es: 'Mirilla del granero' }), 91, 29, 20),
  ],
  // By position in the book: page 1 is the cover, 3 the hedge, 7 the fence, 11 the door.
  pages: [{ pages: '1', die: 'window' }, { pages: '3', die: 'hedge' },
    { pages: '7', die: 'knot' }, { pages: '11', die: 'peephole' }],
  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
};
```

## Ingredients

**Ensenya**

- [Forats troquelats](https://postext.dev/ca/docs/special-inks-die-cuts.md#troquels): dieCuts.shapes i dieCuts.pages (o un contenidor :::diecut) tallen un forat en una pàgina i el seu full; el text de les dues cares l’envolta.
- [Cantonades arrodonides i llibres amb forma](https://postext.dev/ca/docs/special-inks-die-cuts.md#cantonades-arrodonides-i-llibres-amb-forma): dieCuts.corners arrodoneix les cantonades de cada full (les del tall davanter o totes quatre), i dieCuts.outline retalla cada full amb una forma.
- [Línia de troquel al PDF](https://postext.dev/ca/docs/special-inks-die-cuts.md#la-línia-de-troquel-al-pdf): print.dieLine traça cada forat i cada vora amb forma en una planxa Separation pròpia, en sobreimpressió i que mai no s’entinta, per al troquelista.

**També fa servir**

- [Forats a través de diversos fulls](https://postext.dev/ca/docs/special-inks-die-cuts.md#fulls-i-mirall)
- [Visor de llibre en 3D (Folio)](https://postext.dev/ca/docs/configuration-html-folio-epub.md#un-llibre-en-3d-postext-folio)
- [Estils de títol](https://postext.dev/ca/docs/configuration-styles.md#estils-dencapçalament)
- [Imatges als dissenys de pàgina](https://postext.dev/ca/docs/configuration-headers-footers.md#elements-dimatge)
- [Atributs de títol](https://postext.dev/ca/docs/document-format.md#atributs-dencapçalament)
- [Estils de paràgraf](https://postext.dev/ca/docs/configuration-styles.md#estils-de-paràgraf)
- [Sang i marques de tall](https://postext.dev/ca/docs/configuration-page-layout.md#marques-de-tall)
- [PDF en CMYK i en escala de grisos](https://postext.dev/ca/docs/configuration-fonts-colors-viewers.md#generació-de-pdf-configuració)
- [Exportació a PDF](https://postext.dev/ca/docs/configuration-pdf-output.md#generació-de-pdf)
- [Figures i taules com a recursos](https://postext.dev/ca/docs/document-format-resources.md#recursos)
- [Paleta de color semàntica](https://postext.dev/ca/docs/configuration-fonts-colors-viewers.md#paleta-de-colors)
- [Pàgines en un canvas](https://postext.dev/ca/docs/configuration-programmatic-usage.md#renderitzar-una-pàgina-en-un-mapa-de-bits)
- [Paper, enquadernació, taula i llum (Folio)](https://postext.dev/ca/docs/configuration-fonts-colors-viewers.md#visor-folio-configuració)
- [Obertures dissenyades](https://postext.dev/ca/docs/configuration-headings.md#extensió-i-disseny-avançat)
- [Color del paper](https://postext.dev/ca/docs/configuration-page-layout.md#pàgina)
- [Colors per part](https://postext.dev/ca/docs/configuration-styles.md#el-contenidor-part)
- [Fonts incrustades al PDF](https://postext.dev/ca/docs/configuration-pdf-output.md#per-què-un-proveïdor-de-fonts)
- [Geometria per secció](https://postext.dev/ca/docs/configuration-styles.md#estils-dencapçalament)
- [Capítols sense número](https://postext.dev/ca/docs/configuration-styles.md#estils-dencapçalament)

**La configuració d'un cop d'ull**

- [`bodyText`](https://postext.dev/ca/docs/configuration-text.md#text-de-cos), [`colorPalette`](https://postext.dev/ca/docs/configuration-fonts-colors-viewers.md#paleta-de-colors), [`dieCuts`](https://postext.dev/ca/docs/special-inks-die-cuts.md#troquels), [`folio`](https://postext.dev/ca/docs/configuration-html-folio-epub.md#aspecte), [`footer`](https://postext.dev/ca/docs/configuration-headers-footers.md#capçaleres-i-peus), [`header`](https://postext.dev/ca/docs/configuration-headers-footers.md#capçaleres-i-peus), [`headingStyles`](https://postext.dev/ca/docs/configuration-styles.md#estils-dencapçalament), [`headings`](https://postext.dev/ca/docs/configuration-headings.md#encapçalaments), [`layout`](https://postext.dev/ca/docs/configuration-page-layout.md#disposició), [`locale`](https://postext.dev/ca/docs/configuration-language.md#partició-de-mots), [`page`](https://postext.dev/ca/docs/configuration-page-layout.md#pàgina), [`paragraphStyles`](https://postext.dev/ca/docs/configuration-styles.md#estils-de-paràgraf), [`print`](https://postext.dev/ca/docs/configuration-fonts-colors-viewers.md#producció-per-a-impremta-configuració)

**API**

- [`buildDocumentWithFonts`](https://postext.dev/ca/docs/configuration-programmatic-usage.md#carregar-les-fonts-abans-de-compondre), [`createFolioFromDocument`](https://postext.dev/ca/docs/configuration-html-folio-epub.md#un-llibre-en-3d-postext-folio), [`decompressWoff2`](https://postext.dev/ca/docs/configuration-pdf-output.md#proveïdor-de-fonts-al-navegador-fontsource--woff2), [`registerResourceImage`](https://postext.dev/ca/docs/architecture.md#superfície-dapi), [`renderPageToCanvas`](https://postext.dev/ca/docs/configuration-programmatic-usage.md#renderitzar-una-pàgina-en-un-mapa-de-bits), [`renderToPdf`](https://postext.dev/ca/docs/configuration-pdf-output.md#generació-de-pdf)

**Tipus de lletra**

- Andika (OFL-1.1), Fredoka (OFL-1.1), Nunito (OFL-1.1)

## Elaboració

### 1 · Forats on el dibuix següent es delata

El codi és [la resposta curta](https://postext.dev/ca/cookbook/peek-a-boo-board-book.md#la-resposta-curta) de dalt. Cada forma es col·loca des de la cantonada superior esquerra del tall i `dieCuts.pages` diu quina pàgina talla, comptant des de la primera del llibre. Mesura el forat sobre la pintura que descobreix, no sobre la pàgina on es talla: la bardissa, la tanca i la porta són textures que admeten un forat a qualsevol lloc; el gat i el fanalet, no.

### 2 · Pintures en registre amb els forats

```js
// script.js, línies 65–84
// Each painting hangs from the trim and runs BLEED past it on every side, so the holes hit it
// in the same place on screen and in print. A picture's section drops the foot margin, so its
// design reaches the foot of the page; the words on the verso behind it, in the same section,
// start TOP down.
const SHEET = { width: mm(TRIM + 2 * BLEED), height: mm(TRIM + 2 * BLEED) }; // trim + bleed
const painting = { kind: 'image', id: 'painting', resourceId: '{attr.picture}', fit: 'cover',
  placement: at('page', 'top-left', -BLEED, -BLEED, SHEET) };
const full = (elements) => ({ enabled: true, minHeight: mm(TRIM - TOP), slot: { elements } });
const flush = { margins: { top: mm(TOP), bottom: mm(0), left: mm(INNER), right: mm(OUTER) } };
const title = { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY,
  fontWeight: 600, fontSize: pt(40), lineHeight: 1, color: col('accent'), align: 'left',
  placement: at('page', 'top-left', 62, 8, { width: mm(88) }) };
const headingStyles = [
  { id: 'cover', numbered: false, toc: false, ...flush, advancedDesign: full([painting, title]) },
  { id: 'picture', numbered: false, ...flush, breakBefore: { enabled: true, parity: 'odd' },
    advancedDesign: full([painting]) },
  // The back cover: the board printed dusk blue (the section's palette), the type in cream.
  { id: 'back', numbered: false, toc: false, breakBefore: { enabled: true, parity: 'even' },
    color: col('cream'), palette: { paper: palette.dusk } },
];
```

Els forats van en mil·límetres des del tall, de manera que cada pintura penja del tall i el sobrepassa el sagnat pels quatre costats, igual en pantalla que a la impremta. L’estil de les pintures només treu el marge inferior: el disseny arriba al peu de la pàgina, i el text del vers de darrere conserva els 44 mm de marge superior, que el baixen per sota dels forats petits.

### 3 · La línia de troquel en la seva planxa

```js
// script.js, línies 96–99
  // The die line is stroked on a Separation plate of its own ('Die'), overprinting, that the
  // press never inks. PDF/X-4 on coated stock: the board is printed on coated paper.
  print: { standard: 'pdfx4', outputProfile: 'fogra51', convertImages: false,
    dieLine: { output: 'page', ink: 'Die', width: pt(0.5) } },
```

El PDF imprimeix cada pàgina sencera i traça el contorn de cada forat, i de cada full arrodonit, en una separació `Die` en sobreimpressió que mai no s’entinta. `convertImages: false` deixa les pintures com a JPEG RGB etiquetats sRGB, que PDF/X-4 admet, i el fitxer continua sent petit.

### 4 · El llibre a la mà

```js
// script.js, línies 122–128
  folio: {
    tilt: 50, yaw: -32,
    paper: { type: 'board', shade: '#fbf5e8' },
    binding: { type: 'hardcover', cover: 'pages', coverMaterial: 'paper' },
    surface: { type: 'oak' },
    lighting: { environment: 'daylight', intensity: 1.05 },
  },
```

Folio talla els forats a cada full i ensenya les pàgines de sota amb les parets del tall, i la finestra escalonada es llegeix com a profunditat. El cartró passa rígid i les cantonades arrodonides es tallen a tots els fulls.

### 5 · Pàgines planes que deixen veure

```js
// script.js, línies 242–252
// renderPageToCanvas cuts the holes; `beneath` hands it the pages under them, painted here
// at a lower scale (the composite stretches them to the page), each with its own holes.
const under = new Map();
const beneath = (i) => {
  if (!under.has(i) && doc.pages[i]) {
    const canvas = document.createElement('canvas');
    under.set(i, canvas);
    renderPageToCanvas(doc.pages[i], doc, canvas, { scale: 1, beneath });
  }
  return under.get(i);
};
```

Al canvas, un forat mostra el que hi hagi darrere del canvas si el renderitzador no rep les pàgines de sota. `beneath` les retorna per índex, cadascuna pintada amb els seus forats, i així la coberta deixa veure la bardissa i, a través de la bardissa, el gat.

## La recepta completa

Un sol fitxer, compost a partir de la carpeta de la recepta amb el text d'exemple i el kit comú del Receptari ja inclosos; construeix la seva pròpia pàgina. Per executar-lo, posa'l en un `<script type="module">` d'una pàgina buida o enganxa'l al tauler JS d'un pen nou de CodePen (com a mòdul). Importa postext des d'esm.sh, així que no cal instal·lar ni compilar res.

- Carpeta de la recepta: https://github.com/drnachio/postext/tree/main/cookbook/peek-a-boo-board-book

### script.js

```js
// ═══ Postext Cookbook · Nº 193 · A peek-a-boo board book with holes in register ════════
// https://postext.dev/en/cookbook/peek-a-boo-board-book
// Code: MIT · Text: original (CC BY 4.0) · Paintings: generated with diffusion models
// Fonts: Andika, Fredoka, Nunito (SIL OFL 1.1) · Needs postext ≥ 1.84.0
//
// A fourteen-page board book for toddlers: on every other recto a hole is cut through the
// painting, and what shows through it is a scrap of the next picture. The words on the left
// make a guess from the scrap; the turned page shows what it really is. The leaves have
// rounded corners, the holes step down from the cover, and the PDF carries the die line.
import {
  buildDocumentWithFonts, renderPageToCanvas, registerResourceImage,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';
import { createFolioFromDocument } from 'https://esm.sh/postext-folio';

const LANG = 'es'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'peek-a-boo-board-book';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
// #region palette: a cream board, a robin red for the title and the guesses, a dusk blue
const palette = {
  ink: '#2a2420', // text: a warm near-black
  accent: '#b8432c', // the cover title and the guesses: the robin's breast
  paper: '#fbf5e8', // the board the words are printed on
  dusk: '#253a63', // the back cover, the blue of the last painting's sky
  cream: '#fff9ec', // type on the cover and the back
  muted: '#7a6f64', // the colophon
};
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
  ...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
  { id: 'main-color', name: 'accent (defaults)', value: { hex: palette.accent, model: 'hex' } },
];
// #endregion
const [TRIM, BLEED] = [160, 3]; // mm: a square board book, and its bleed
const [TOP, FOOT, INNER, OUTER] = [44, 16, 18, 16]; // the words sit low, under the holes' tops
const [TEXT, DISPLAY, LABEL] = ['Andika', 'Fredoka', 'Nunito'];
const LEAD = 31; // pt: 24 pt type on a generous leading, for reading aloud
const at = (to, edge, x = 0, y = 0, size) => ({ anchor: { to, edge },
  offset: { x: mm(x), y: mm(y) }, ...(size && { size }) });

// #region answer: the dies, and the pages they cut
// Each painting is cut where the next one's telling part lies: the cat's striped flank, the
// sheep's wool, the lantern's glow. The cover's window is wider than the hedge's hole and
// holds it, so from the cover you see the hedge, and through the hedge the cat. A hole cuts
// both sides of its leaf, mirrored on the verso, and the words there run round it.
const circle = (id, name, cx, cy, d) => ({ id, name, shape: 'circle', x: mm(cx - d / 2),
  y: mm(cy - d / 2), width: mm(d), height: mm(d), wrap: { gap: mm(4) } });
const dieCuts = {
  shapes: [
    circle('window', t({ en: 'Cover window', es: 'Ventana de la cubierta' }), 112, 68, 60),
    circle('hedge', t({ en: 'Gap in the hedge', es: 'Hueco del seto' }), 112, 60, 36),
    { id: 'knot', name: t({ en: 'Knothole', es: 'Nudo de la valla' }), shape: 'ellipse',
      x: mm(102), y: mm(48), width: mm(32), height: mm(40), wrap: { gap: mm(4) } },
    circle('peephole', t({ en: 'Barn-door peephole', es: 'Mirilla del granero' }), 91, 29, 20),
  ],
  // By position in the book: page 1 is the cover, 3 the hedge, 7 the fence, 11 the door.
  pages: [{ pages: '1', die: 'window' }, { pages: '3', die: 'hedge' },
    { pages: '7', die: 'knot' }, { pages: '11', die: 'peephole' }],
  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
};
// #endregion

// #region pictures: a painting to the bleed, the page's heading naming it
// Each painting hangs from the trim and runs BLEED past it on every side, so the holes hit it
// in the same place on screen and in print. A picture's section drops the foot margin, so its
// design reaches the foot of the page; the words on the verso behind it, in the same section,
// start TOP down.
const SHEET = { width: mm(TRIM + 2 * BLEED), height: mm(TRIM + 2 * BLEED) }; // trim + bleed
const painting = { kind: 'image', id: 'painting', resourceId: '{attr.picture}', fit: 'cover',
  placement: at('page', 'top-left', -BLEED, -BLEED, SHEET) };
const full = (elements) => ({ enabled: true, minHeight: mm(TRIM - TOP), slot: { elements } });
const flush = { margins: { top: mm(TOP), bottom: mm(0), left: mm(INNER), right: mm(OUTER) } };
const title = { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY,
  fontWeight: 600, fontSize: pt(40), lineHeight: 1, color: col('accent'), align: 'left',
  placement: at('page', 'top-left', 62, 8, { width: mm(88) }) };
const headingStyles = [
  { id: 'cover', numbered: false, toc: false, ...flush, advancedDesign: full([painting, title]) },
  { id: 'picture', numbered: false, ...flush, breakBefore: { enabled: true, parity: 'odd' },
    advancedDesign: full([painting]) },
  // The back cover: the board printed dusk blue (the section's palette), the type in cream.
  { id: 'back', numbered: false, toc: false, breakBefore: { enabled: true, parity: 'even' },
    color: col('cream'), palette: { paper: palette.dusk } },
];
// #endregion

const config = {
  locale: t({ en: 'en-gb', es: 'es' }),
  colorPalette,
  page: { sizePreset: 'custom', width: mm(TRIM), height: mm(TRIM), dpi: 150,
    backgroundColor: col('paper'), cutLines: { enabled: false, bleed: mm(BLEED) },
    margins: { top: mm(TOP), bottom: mm(FOOT), left: mm(INNER), right: mm(OUTER), mirror: true } },
  layout: { layoutType: 'single' },
  dieCuts,
  // #region die-line: the die-maker's plate, and the press file around it
  // The die line is stroked on a Separation plate of its own ('Die'), overprinting, that the
  // press never inks. PDF/X-4 on coated stock: the board is printed on coated paper.
  print: { standard: 'pdfx4', outputProfile: 'fogra51', convertImages: false,
    dieLine: { output: 'page', ink: 'Die', width: pt(0.5) } },
  // #endregion
  bodyText: { fontFamily: TEXT, fontSize: pt(24), lineHeight: pt(LEAD), color: col('ink'),
    boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
    textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: pt(8),
    hyphenation: { enabled: false }, // a word read aloud is never broken
    optimalLineBreaking: true, avoidWidows: true, avoidOrphans: true, avoidRunts: true },
  headings: { fontFamily: DISPLAY, color: col('ink'), fontWeight: 600, levels: [
    { level: 1, fontSize: pt(30), lineHeight: pt(34), breakBefore: { enabled: true,
      parity: 'odd' }, marginTop: pt(0), marginBottom: pt(12) },
  ] },
  headingStyles,
  paragraphStyles: [
    // The guess, and the answer to it: the line a child shouts.
    { id: 'shout', fontFamily: DISPLAY, fontWeight: 600, fontSize: pt(32), lineHeight: pt(36),
      color: col('accent'), textAlign: 'left', firstLineIndent: pt(0), marginTop: pt(6),
      marginBottom: pt(6) },
    { id: 'colophon', fontFamily: LABEL, fontSize: pt(9), lineHeight: pt(12.5),
      color: col('cream'), textAlign: 'left', firstLineIndent: pt(0), marginTop: pt(8) },
  ],
  header: { elements: [] }, // a board book prints no running heads
  footer: { elements: [] }, // and no folios
  // #region folio: grey board, rounded leaves, seen low so the holes show their depth
  folio: {
    tilt: 50, yaw: -32,
    paper: { type: 'board', shade: '#fbf5e8' },
    binding: { type: 'hardcover', cover: 'pages', coverMaterial: 'paper' },
    surface: { type: 'oak' },
    lighting: { environment: 'daylight', intensity: 1.05 },
  },
  // #endregion
};

// ─── 2 · Content ────────────────────────────────────────────────────────────
// # The hedge {style="picture" picture="hedge"} names a painting; the words after it fill the
// verso behind that picture, the guess on the left of the hole that answers it.
const markdown = String.raw`---
title: "¡Cucú! ¿Quién hay en el jardín?"
---

# ¡Cucú! {style="cover" picture="cover"}

¿Qué hay detrás del seto? Mira por el agujero. Ahí dentro duerme algo naranja y a rayas.

:::paragraphs{style="shout"}
¿Será un tigre?
:::

# El seto {style="picture" picture="hedge"}

:::paragraphs{style="shout"}
¡No, no es un tigre!
:::

Es Mermelada, el gato, que se echa la siesta al sol.

# Mermelada, el gato {style="picture" picture="cat"}

¿Qué hay detrás de la valla? Ahí detrás hay algo blanco y lanudo.

:::paragraphs{style="shout"}
¿Será una nube?
:::

# La valla {style="picture" picture="fence"}

:::paragraphs{style="shout"}
¡No, no es una nube!
:::

Es Dolly, la oveja, que mordisquea la hierba alta.

# Dolly, la oveja {style="picture" picture="sheep"}

¿Qué hay detrás de la puerta? Ya se ha puesto el sol. Ahí dentro brilla algo redondo y amarillo.

:::paragraphs{style="shout"}
¿Será la luna?
:::

# La puerta del granero {style="picture" picture="door"}

:::paragraphs{style="shout"}
¡No, no es la luna!
:::

Es el farolillo del abuelo. A la cama. ¡Buenas noches, jardín!

# El farolillo del abuelo {style="picture" picture="lantern"}

# Buenas noches {style="back"}

:::paragraphs{style="colophon"}
Un libro de cartón con cuatro agujeros troquelados y las esquinas redondeadas. Compuesto en Andika, Fredoka y Nunito (SIL Open Font License). Texto escrito para el Recetario de Postext, CC BY 4.0. Pinturas generadas con modelos de difusión.
:::
`; // content.<lang>.md, inlined by the Cookbook

const PICTURES = {
  cover: t({ en: 'A cottage garden: a tall hedge under a blue sky, hollyhocks and a robin.',
    es: 'Un jardín: un seto alto bajo el cielo azul, malvarrosas y un petirrojo.' }),
  hedge: t({ en: 'A green hedge of small leaves with white flowers and a ladybird.',
    es: 'Un seto verde de hojas pequeñas con flores blancas y una mariquita.' }),
  cat: t({ en: 'A ginger tabby cat asleep, curled up on the lawn among daisies.',
    es: 'Un gato atigrado pelirrojo dormido, hecho un ovillo en el césped entre margaritas.' }),
  fence: t({ en: 'A weathered wooden fence, buttercups growing at its foot.',
    es: 'Una valla de madera vieja, con botones de oro al pie.' }),
  sheep: t({ en: 'A woolly white sheep with a black face, standing in the meadow.',
    es: 'Una oveja blanca y lanuda de cara negra, de pie en el prado.' }),
  door: t({ en: 'The red plank door of a barn, with black iron hinges.',
    es: 'La puerta roja de tablas de un granero, con bisagras de hierro negro.' }),
  lantern: t({ en: 'Grandpa walks down the garden path at dusk, holding up a glowing lantern.',
    es: 'El abuelo baja por el jardín al anochecer con un farolillo encendido en alto.' }),
};
const resources = Object.entries(PICTURES).map(([id, alt]) => ({ id, typeId: 'figure', kind: 'bitmap',
  createdAt: 0, updatedAt: 0, altText: alt,
  bitmap: { fileId: `${id}.jpg`, format: 'jpeg', width: 900, height: 900 } }));
const FILES = { cover: asset('cover.jpg'), hedge: asset('hedge.jpg'), cat: asset('cat.jpg'),
  fence: asset('fence.jpg'), sheep: asset('sheep.jpg'), door: asset('door.jpg'),
  lantern: asset('lantern.jpg') };

// ─── 3 · Fonts ──────────────────────────────────────────────────────────────
const FONTS = { Andika: ['400', '700'], Fredoka: ['600'], Nunito: ['400', '700'] };

// ─── 4 · Build & show ───────────────────────────────────────────────────────
await Promise.all(Object.entries(FILES).map(([id, url]) => loadImage(`${id}.jpg`, url)));
// The press file is built first, with bleed and crop marks; the screen shows the trimmed
// pages, built last, with the corners and holes cut out against the desk.
const cut = { ...config.page.cutLines, enabled: true };
const pressConfig = { ...config, page: { ...config.page, cutLines: cut } };
const press = await buildDocumentWithFonts({ markdown, resources }, pressConfig, kitFonts(FONTS));
const doc = await buildDocumentWithFonts({ markdown, resources }, config, kitFonts(FONTS));

// #region folio-stage: the book closed on the desk, the cover's window first
const stage = document.createElement('section');
stage.id = 'folio';
stage.ariaLabel = t({ en: 'The board book in 3D', es: 'El libro de cartón en 3D' });
stage.style.cssText = 'height: min(78vh, 720px); margin: 0 auto; max-width: 1280px';
document.body.append(stage);
createFolioFromDocument(stage, doc, { at: 0,
  appearance: { textureBaseUrl: 'https://postext.dev/folio/textures' } });
// #endregion

// #region see-through: the flat pages show what lies beneath their holes
// renderPageToCanvas cuts the holes; `beneath` hands it the pages under them, painted here
// at a lower scale (the composite stretches them to the page), each with its own holes.
const under = new Map();
const beneath = (i) => {
  if (!under.has(i) && doc.pages[i]) {
    const canvas = document.createElement('canvas');
    under.set(i, canvas);
    renderPageToCanvas(doc.pages[i], doc, canvas, { scale: 1, beneath });
  }
  return under.get(i);
};
// #endregion
showPages(doc, { title: t({ en: 'Peek-a-boo! · a board book with holes',
  es: '¡Cucú! · un libro de cartón con agujeros' }), beneath });
document.getElementById('pages').before(stage);
offerPdf(() => renderToPdf(press, { fontProvider: fontsourceProvider, resourceBytes: imageBytes,
  profileBaseUrl: 'https://postext.dev/icc/' }), `${RECIPE}.pdf`);

// ─── Kit ── helpers shared by every Cookbook recipe · postext.dev/cookbook ─────

// ─── Kit · core v1 ── the same in every recipe · postext.dev/cookbook
function mm(value) { return { value, unit: 'mm' }; }
function pt(value) { return { value, unit: 'pt' }; }
function em(value) { return { value, unit: 'em' }; }
/** The sample language's string: t({ en: 'Figure', es: 'Figura' }). */
function t(strings) { return strings[LANG] ?? Object.values(strings)[0]; }
/** A file in this recipe's assets folder, served from the Postext repo by jsDelivr. */
function asset(file) { return `https://cdn.jsdelivr.net/gh/drnachio/postext@main/cookbook/${RECIPE}/assets/${file}`; }

// ─── Kit · fonts v3 ── the same in every recipe · postext.dev/cookbook
// Postext loads the faces a config asks for before layout and asks the kit
// for Fontsource's files, the ones the PDF embeds too.

/** buildDocumentWithFonts' options: the resolver, and FONTS' faces loaded
 *  with the config's. FONTS = { 'Family Name': ['400', '400i', '700'] }. */
function kitFonts(FONTS = {}) {
  const faces = Object.entries(FONTS).flatMap(([family, specs]) => specs.map((spec) =>
    ({ family, weight: parseInt(spec, 10), style: spec.endsWith('i') ? 'italic' : 'normal' })));
  return { resolve: fontsourceResolver, faces };
}

/** A face's files with their ranges: latin, then latin-ext and greek when
 *  `text` needs them (kitSubsetsFor). Null for a face Fontsource lacks. */
async function fontsourceResolver(family, weight, style, { text = '' } = {}) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  if (meta && !(await fontsourceWeights(family, style)).includes(weight)) return null;
  kitStatus('Loading fonts…');
  const at = await fontsourceAt(id);
  return ['latin', ...kitSubsetsFor(text, meta)].map((subset) => ({
    source: `${at}files/${id}-${subset}-${weight}-${style}.woff2`,
    unicodeRange: kitRanges()[subset],
  }));
}

/** Each file's unicode-range (a function: the kit runs after the pen's code). */
function kitRanges() {
  return {
    latin: 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,'
      + 'U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD',
    'latin-ext': 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,'
      + 'U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF',
    greek: 'U+0370-03FF',
  };
}

/** For the cjk, arabic and comics blocks: loads `faces` (as FONTS) for the
 *  sample `text`; `optional` skips a face Fontsource lacks. Files are added in
 *  the order asked, the last winning a shared character. Resolves to the count. */
async function loadFonts(faces, text = '', { optional = false } = {}) {
  kitStatus('Loading fonts…');
  const ranges = kitRanges();
  const jobs = [];
  for (const [family, specs] of Object.entries(faces)) {
    const id = fontsourceId(family);
    const todo = [...new Set(specs)].map((spec) => [parseInt(spec, 10), spec.endsWith('i') ? 'italic' : 'normal'])
      .filter(([weight, style]) => !hasFace(family, weight, style)); // before any await
    const at = fontsourceAt(id);
    const meta = optional || /[^\0-ÿ]/u.test(text) ? await fontsourceMeta(family) : null;
    const subsets = ['latin', ...kitSubsetsFor(text, meta)];
    for (const [weight, style] of todo) {
      if (optional && !(meta && (await fontsourceWeights(family, style)).includes(weight))) continue;
      for (const subset of subsets) {
        const url = `${await at}files/${id}-${subset}-${weight}-${style}.woff2`;
        const face = new FontFace(family, `url(${url}) format('woff2')`,
          { weight: String(weight), style, unicodeRange: ranges[subset] });
        jobs.push(face.load().catch(() => {
          if (subset === 'latin' && !optional) throw new Error(`Fontsource has no ${family} ${weight} ${style}`);
        }));
      }
    }
  }
  const ready = await Promise.all(jobs).catch((error) => { kitFail(error); throw error; });
  return ready.filter((face) => face && document.fonts.add(face)).length;
}

/** A loaded FontFace covers this face (fonts.check() says yes to any family). */
function hasFace(family, weight, style) {
  for (const face of document.fonts) {
    if (face.status !== 'loaded' || face.style !== style) continue;
    if (face.family.replace(/^["']|["']$/g, '') !== family) continue;
    const [low, high = low] = face.weight.split(' ').map(Number);
    if (weight >= low && weight <= high) return true;
  }
  return false;
}

/** The files beyond latin `text` needs that `meta`'s family ships. */
function kitSubsetsFor(text, meta) {
  return [[/[Ā-˿ᴀ-ᶿḀ-ỿ†ℓⱠ-Ɀ꜠-ꟿ]/u, 'latin-ext'], [/[Ͱ-Ͽ]/u, 'greek']]
    .filter(([re, x]) => re.test(text) && meta?.subsets?.includes(x)).map(([, x]) => x);
}

/** Fontsource's id for a family: 'Source Serif 4' → 'source-serif-4'. */
function fontsourceId(family) { return family.toLowerCase().replace(/\s+/g, '-'); }

/** A package's folder at the one version @5 names now (#766). */
function fontsourceAt(id, u = `https://cdn.jsdelivr.net/npm/@fontsource/${id}@`) {
  return (fontsourceAt.c ??= {})[id] ??= fetch(u + '5/package.json').then((r) => r.json())
    .then((p) => p.version || 5, () => 5).then((v) => `${u}${v}/`);
}

/** The family's Fontsource metadata (weights, styles, subsets), or null. */
function fontsourceMeta(family, id = fontsourceId(family)) {
  return (fontsourceMeta.c ??= {})[id] ??= fetch(`https://api.fontsource.org/v1/fonts/${id}`)
    .then((res) => (res.ok ? res.json() : null), () => null);
}

/** The weights the package ships in `style`: the API pairs none (no Libre
 *  Caslon 700 italic file), so italics are read from latin-italic.css. */
function fontsourceWeights(family, style, id = fontsourceId(family)) {
  return (fontsourceWeights.c ??= {})[id + style] ??= fontsourceMeta(family).then(async (m) => {
    if (!m?.styles.includes(style)) return m ? [] : [400, 700];
    const css = style === 'italic' ? await fetch(`${await fontsourceAt(id)}latin-italic.css`).then((r) => (r.ok ? r.text() : ''), () => '') : '';
    const w = [...css.matchAll(/weight: (\d+)/g)].map((x) => +x[1]);
    return w.length ? w : m.weights;
  });
}

// ─── Kit · viewer v2 ── the same in every recipe · postext.dev/cookbook
/** The pages as spreads on a dark desk, page 1 alone, then verso | recto,
 *  each painted when it scrolls near. Other options go to renderPageToCanvas. */
function showPages(docs, { title, width = 460, ...render } = {}) {
  const root = viewer(title);
  const pages = [docs].flat().flatMap((doc) =>
    doc.pages.map((page) => ({ doc, page, n: (doc.pageIndexOffset ?? 0) + page.index })));
  const spreads = [];
  let verso = null;
  for (const p of pages) {
    if (p.n % 2 === 1) { if (verso) spreads.push([verso, null]); verso = p; }
    else { spreads.push([verso, p]); verso = null; }
  }
  if (verso) spreads.push([verso, null]);
  const density = Math.min(window.devicePixelRatio || 1, 2);
  showPages.painter?.disconnect();
  const painter = new IntersectionObserver((entries) => {
    for (const { isIntersecting, target } of entries) {
      if (!isIntersecting) continue;
      painter.unobserve(target);
      const { doc, page } = target.postext;
      renderPageToCanvas(page, doc, target, { ...render, scale: (width * density) / page.width });
    }
  }, { rootMargin: '800px' });
  showPages.painter = painter;
  root.replaceChildren(...spreads.map((pair) => {
    const spread = document.createElement('div');
    spread.className = 'pt-spread';
    for (const p of pair) {
      const figure = document.createElement('figure');
      if (p) {
        const label = p.page.pageLabel || String(p.n + 1);
        const canvas = document.createElement('canvas');
        canvas.postext = p;
        canvas.style.aspectRatio = `${p.page.width} / ${p.page.height}`;
        canvas.setAttribute('role', 'img');
        canvas.setAttribute('aria-label', `Page ${label}`);
        const folio = document.createElement('figcaption');
        folio.textContent = label;
        figure.append(canvas, folio);
        painter.observe(canvas);
      } else figure.className = 'pt-blank';
      spread.append(figure);
    }
    return spread;
  }));
  kitStatus(`${pages.length} ${pages.length === 1 ? 'page' : 'pages'}`);
  document.documentElement.dataset.postext = 'ready';
  return pages.length;
}

/** The desk, the bar and the error reporting, created once. */
function viewer(title) {
  if (!document.getElementById('pt-kit')) {
    document.head.insertAdjacentHTML('beforeend', `<style id="pt-kit">
      :root { color-scheme: dark; }
      body { margin: 0; background: #0e1014; color: #b9bcc4; font: 13px/1.45 system-ui, sans-serif; }
      #pt-bar { position: sticky; top: 0; z-index: 1; display: flex; flex-wrap: wrap; align-items: center;
        gap: 6px 16px; padding: 10px 16px; background: rgb(14 16 20 / .92); backdrop-filter: blur(6px);
        border-bottom: 1px solid #23262d; }
      #pt-bar strong { color: #f4f1ea; font-weight: 600; }
      #pt-actions { display: flex; gap: 12px; margin-left: auto; }
      #pt-actions a, #pt-actions button { color: #d8a21a; font: inherit; background: none; border: 0; padding: 0; cursor: pointer; }
      #pages { display: grid; justify-items: center; gap: 48px; padding: 32px 16px 72px; }
      .pt-spread { display: flex; }
      .pt-spread figure { margin: 0; width: min(460px, 44vw); }
      .pt-spread canvas { display: block; width: 100%; background: #fff;
        box-shadow: 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figure:first-child canvas { box-shadow: inset -14px 0 14px -14px rgb(0 0 0 / .18), 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figcaption { margin-top: 10px; text-align: center; font: 600 10px/1 system-ui, sans-serif;
        letter-spacing: .18em; text-transform: uppercase; color: #6c7079; }
      .pt-blank { visibility: hidden; }
      @media (max-width: 760px) {
        .pt-spread { flex-direction: column; gap: 32px; }
        .pt-spread figure { width: min(460px, 92vw); }
        .pt-blank { display: none; }
      }
    </style>`);
    document.body.insertAdjacentHTML('afterbegin',
      '<header id="pt-bar"><strong id="pt-title"></strong><span id="pt-status" role="status"></span><span id="pt-actions"></span></header>');
    document.getElementById('pt-title').textContent = document.title || 'Postext';
    addEventListener('error', (event) => kitFail(event.error ?? event.message));
    addEventListener('unhandledrejection', (event) => kitFail(event.reason));
  }
  if (title) document.getElementById('pt-title').textContent = title;
  return document.getElementById('pages')
    ?? document.body.appendChild(Object.assign(document.createElement('main'), { id: 'pages' }));
}

function kitStatus(text) {
  viewer();
  document.getElementById('pt-status').textContent = text;
}

function kitFail(error) {
  document.documentElement.dataset.postext = 'error';
  kitStatus(`Error: ${error?.message ?? error}`);
}

// ─── Kit · pdf v3 ── the same in every recipe that exports a PDF
/** The Fontsource files the screen used, as TrueType, with their range and
 *  place: the nearest weight the family ships in that style, upright with no italic;
 *  latin, then what its letters need (kitSubsetsFor). */
async function fontsourceProvider(family, weight, style, request) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  const s = style === 'italic' && meta && !meta.styles.includes('italic') ? 'normal' : style;
  const shipped = meta ? await fontsourceWeights(family, s) : [];
  const weights = shipped.length ? shipped : [400, 700];
  const w = weights.reduce((a, b) => (Math.abs(b - weight) < Math.abs(a - weight) ? b : a));
  const text = String.fromCodePoint(...(request?.codePoints ?? []));
  const files = await Promise.all(['latin', ...kitSubsetsFor(text, meta)].map(async (subset, order) => {
    const res = await fetch(`${await fontsourceAt(id)}files/${id}-${subset}-${w}-${s}.woff2`);
    if (!res.ok) throw new Error(`Fontsource has no ${family} ${w} ${s} ${subset}`);
    return Object.assign(await decompressWoff2(new Uint8Array(await res.arrayBuffer())),
      { unicodeRange: kitRanges()[subset], order });
  }));
  return files.length === 1 ? files[0] : files;
}

/** A "Build the PDF" button; then "Open the PDF" (a new tab: CodePen's frame
 *  shows no PDFs) and a download link. */
function offerPdf(makePdf, filename) {
  viewer();
  const button = Object.assign(document.createElement('button'), { type: 'button', textContent: 'Build the PDF' });
  button.dataset.postextPdf = filename;
  button.addEventListener('click', async () => {
    button.disabled = true;
    button.textContent = 'Building the PDF…';
    try {
      const bytes = await makePdf();
      const url = URL.createObjectURL(new Blob([bytes], { type: 'application/pdf' }));
      const size = `${Math.max(1, Math.round(bytes.length / 1024))} KB`;
      button.replaceWith(
        Object.assign(document.createElement('a'), { href: url, target: '_blank', rel: 'noopener', textContent: 'Open the PDF ↗' }),
        Object.assign(document.createElement('a'), { href: url, download: filename, textContent: `Download ${filename} · ${size}` }));
    } catch (error) {
      button.disabled = false;
      button.textContent = 'Build the PDF';
      kitFail(error);
    }
  });
  document.getElementById('pt-actions').append(button);
}

// ─── Kit · images v3 ── recipes with pictures · postext.dev/cookbook
/** Registers a photo or PNG for the canvas and keeps its bytes for the PDF.
 *  fetch → ImageBitmap never taints the canvas (a plain cross-origin <img> would). */
async function loadImage(fileId, url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`Image not found (${res.status}): ${url}`);
  const bytes = new Uint8Array(await res.arrayBuffer());
  registerResourceImage(fileId, await createImageBitmap(new Blob([bytes])));
  (loadImage.bytes ??= new Map()).set(fileId, bytes);
}

/** Registers SVG markup as a vector image, its fonts inside (inlineSvgFonts, ≥ 1.25).
 *  `options` go to registerResourceImage: { singleInk: true } tints it on the canvas. */
async function loadSvg(fileId, svg, options) {
  if (typeof inlineSvgFonts === 'function') svg = await inlineSvgFonts(svg, svgFaces);
  const img = new Image();
  img.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
  await img.decode();
  registerResourceImage(fileId, img, options);
  (loadImage.bytes ??= new Map()).set(fileId, new TextEncoder().encode(svg));
}

/** A face's Fontsource files: nearest weight; latin + what the SVG sets. */
async function svgFaces(family, weight, style, { codePoints = [] } = {}) {
  const [id, m] = [fontsourceId(family), await fontsourceMeta(family)];
  const w = m?.weights.reduce((a, b) => (Math.abs(b - weight) < Math.abs(a - weight) ? b : a)) ?? weight;
  const s = m?.styles.includes(style) === false ? 'normal' : style;
  return Promise.all(['latin', ...kitSubsetsFor(String.fromCodePoint(...codePoints), m)].map(async (x) => new Uint8Array(
    await (await fetch(`${await fontsourceAt(id)}files/${id}-${x}-${w}-${s}.woff2`)).arrayBuffer())));
}

/** renderToPdf({ resourceBytes: imageBytes }) */
function imageBytes(fileId) { return loadImage.bytes?.get(fileId); }

/** renderToHtml({ resourceImageUrl: imageUrl }) */
function imageUrl(fileId) {
  const bytes = imageBytes(fileId);
  if (!bytes) return undefined;
  imageUrl.urls ??= new Map();
  if (!imageUrl.urls.has(fileId)) {
    const type = /\.svg$/i.test(fileId) ? 'image/svg+xml' : /\.png$/i.test(fileId) ? 'image/png' : 'image/jpeg';
    imageUrl.urls.set(fileId, URL.createObjectURL(new Blob([bytes], { type })));
  }
  return imageUrl.urls.get(fileId);
}

// ─── /Kit ───────────────────────────────────────────────────────────────────────
```

## Variants

### Arrodoneix només les cantonades del tall davanter

Un àlbum il·lustrat arrodoneix les dues cantonades lluny del llom i deixa el llom en escaire.

```diff
-  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
+  corners: { radius: mm(6), edges: 'fore' },
```

### Talla cada full amb una forma

Un contorn en unitats de `viewBox` talla cada full, en mirall als versos; mana sobre les cantonades.

```diff
   corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
+  outline: { d: 'M0 0.35 L0.5 0 L1 0.35 L1 1 L0 1 Z', viewBox: [1, 1] }, // a house
```

## Crèdits

- Recepta: Ignacio Ferro ([@drnachio](https://github.com/drnachio))
- Text: The words of the board book: Postext Cookbook, CC-BY-4.0
- Imatges: Cover painting: a cottage garden, a hedge, hollyhocks and a robin: Generated With Diffusion Models, original
- Imatges: Page 3: the hedge: Generated With Diffusion Models, original
- Imatges: Page 5: the ginger cat asleep: Generated With Diffusion Models, original
- Imatges: Page 7: the wooden fence: Generated With Diffusion Models, original
- Imatges: Page 9: the sheep: Generated With Diffusion Models, original
- Imatges: Page 11: the barn door: Generated With Diffusion Models, original
- Imatges: Page 13: Grandpa and his lantern at dusk: Generated With Diffusion Models, original
- Tipus de lletra: Andika (OFL-1.1), Fredoka (OFL-1.1), Nunito (OFL-1.1)
- Codi: MIT · Contingut d'exemple: CC-BY-4.0

## Relacionades

- [Núm. 195 · Un llibre túnel de vint fulls de fondària](https://postext.dev/ca/cookbook/forest-tunnel-book.md): Dinou finestres rodones troquelades amb dieCuts, cadascuna més petita que l’anterior: des de la coberta es veu a través de vint plans fins a un cérvol. · Nivell 3 (Avançat) · Fulls solts i efímers
- [Núm. 100 · Un llibre compost sobre la taula, en 3D](https://postext.dev/ca/cookbook/folio-book-on-a-desk.md): createFolioFromDocument, del paquet postext-folio, obre un capítol compost com un llibre en tela sobre una taula de noguera, amb l'aspecte de config.folio. · Nivell 2 (Intermedi) · Narrativa, teatre i prosa literària
- [Núm. 191 · Una carta de forn en tinta blanca sobre kraft](https://postext.dev/ca/cookbook/white-ink-kraft-menu.md): El blanc opac com a tinta plana sobre kraft: lletra blanca sobre la cartolina bruna, un fons blanc sota lletra bruna i blanc calat en un plafó verd. · Nivell 3 (Avançat) · Fulls solts i efímers
