# Un libro de cartón de cucú con agujeros en registro

> Cuatro agujeros troquelados donde la pintura siguiente guarda lo que engaña, una ventana que baja a un agujero menor, esquinas redondeadas y línea de troquel.

- Versión HTML: https://postext.dev/es/cookbook/peek-a-boo-board-book
- Receta N.º 193 · Salida e integración · Nivel 2 (Intermedio) · Salidas: Canvas, PDF, Controles en vivo
- Géneros: Hojas sueltas y efímeros
- Requiere postext ≥ 1.84.0, postext-pdf ≥ 1.84.0 · probada con 1.84.0, postext-pdf 1.84.0 el 2026-11-13
- Páginas: [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
- Abrir en el Sandbox: https://postext.dev/es/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 actualización: 2026-11-13
- Otros idiomas: [en](https://postext.dev/en/cookbook/peek-a-boo-board-book.md), [ca](https://postext.dev/ca/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 pocas palabras

Un libro de cartón para los más pequeños. Cada agujero de una página deja ver un trocito del dibujo siguiente, el texto hace una pregunta y al pasar la página se ve lo que era de verdad.

## Lo que vas a componer

*¡Cucú! ¿Quién hay en el jardín?*, un libro de cartón de catorce páginas en un cuadrado de 160 mm con las cuatro esquinas redondeadas. Cada pintura tiene un agujero, y el agujero está justo donde la pintura siguiente guarda la parte que engaña al ojo: el lomo a rayas de un gato dormido que podría ser un tigre, la lana de una oveja que podría ser una nube, un farolillo que podría ser la luna. La ventana de la cubierta es más ancha que el agujero de detrás, así que la primera mirada llega dos páginas al fondo. El texto de la izquierda pregunta; al pasar la página llega la respuesta. El PDF de imprenta lleva la línea de troquel en una plancha propia.

**Esta receta responde a:**

- ¿Cómo troquelo agujeros en las páginas de un libro para que cada uno deje ver parte del dibujo siguiente?
- ¿Cómo entrego al troquelador la línea de troquel en una plancha propia del PDF?

## La respuesta corta

```js
// script.js, líneas 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
};
```

## Ingredientes

**Enseña**

- [Agujeros troquelados](https://postext.dev/es/docs/special-inks-die-cuts.md#troqueles): dieCuts.shapes y dieCuts.pages (o un contenedor :::diecut) cortan un agujero en una página y su hoja; el texto de las dos caras lo rodea.
- [Esquinas redondeadas y libros con forma](https://postext.dev/es/docs/special-inks-die-cuts.md#esquinas-redondeadas-y-libros-con-forma): dieCuts.corners redondea las esquinas de cada hoja (las del corte delantero o las cuatro), y dieCuts.outline recorta cada hoja con una forma.
- [Línea de troquel en el PDF](https://postext.dev/es/docs/special-inks-die-cuts.md#la-línea-de-troquel-en-el-pdf): print.dieLine traza cada agujero y cada borde con forma en una plancha Separation propia, en sobreimpresión y que nunca se entinta, para el troquelador.

**También usa**

- [Agujeros a través de varias hojas](https://postext.dev/es/docs/special-inks-die-cuts.md#las-dos-caras-de-la-hoja)
- [Visor de libro en 3D (Folio)](https://postext.dev/es/docs/configuration-html-folio-epub.md#un-libro-en-3d-postext-folio)
- [Estilos de título](https://postext.dev/es/docs/configuration-styles.md#estilos-de-encabezado)
- [Imágenes en los diseños de página](https://postext.dev/es/docs/configuration-headers-footers.md#elementos-de-imagen)
- [Atributos de título](https://postext.dev/es/docs/document-format.md#atributos-de-encabezado)
- [Estilos de párrafo](https://postext.dev/es/docs/configuration-styles.md#estilos-de-párrafo)
- [Sangrado y marcas de corte](https://postext.dev/es/docs/configuration-page-layout.md#marcas-de-corte)
- [PDF en CMYK y en escala de grises](https://postext.dev/es/docs/configuration-fonts-colors-viewers.md#generación-de-pdf-configuración)
- [Exportación a PDF](https://postext.dev/es/docs/configuration-pdf-output.md#generación-de-pdf)
- [Figuras y tablas como recursos](https://postext.dev/es/docs/document-format-resources.md#recursos)
- [Paleta de color semántica](https://postext.dev/es/docs/configuration-fonts-colors-viewers.md#paleta-de-colores)
- [Páginas en un canvas](https://postext.dev/es/docs/configuration-programmatic-usage.md#renderizar-una-página-como-mapa-de-bits)
- [Papel, encuadernación, mesa y luz (Folio)](https://postext.dev/es/docs/configuration-fonts-colors-viewers.md#visor-folio-configuración)
- [Aperturas diseñadas](https://postext.dev/es/docs/configuration-headings.md#apertura-a-toda-página-y-diseño-avanzado)
- [Color del papel](https://postext.dev/es/docs/configuration-page-layout.md#página)
- [Colores por parte](https://postext.dev/es/docs/configuration-styles.md#el-contenedor-part)
- [Fuentes incrustadas en el PDF](https://postext.dev/es/docs/configuration-pdf-output.md#por-qué-un-proveedor-de-fuentes)
- [Geometría por sección](https://postext.dev/es/docs/configuration-styles.md#estilos-de-encabezado)
- [Capítulos sin número](https://postext.dev/es/docs/configuration-styles.md#estilos-de-encabezado)

**La configuración de un vistazo**

- [`bodyText`](https://postext.dev/es/docs/configuration-text.md#texto-base), [`colorPalette`](https://postext.dev/es/docs/configuration-fonts-colors-viewers.md#paleta-de-colores), [`dieCuts`](https://postext.dev/es/docs/special-inks-die-cuts.md#troqueles), [`folio`](https://postext.dev/es/docs/configuration-html-folio-epub.md#aspecto), [`footer`](https://postext.dev/es/docs/configuration-headers-footers.md#cabeceras-y-pies), [`header`](https://postext.dev/es/docs/configuration-headers-footers.md#cabeceras-y-pies), [`headingStyles`](https://postext.dev/es/docs/configuration-styles.md#estilos-de-encabezado), [`headings`](https://postext.dev/es/docs/configuration-headings.md#encabezados), [`layout`](https://postext.dev/es/docs/configuration-page-layout.md#disposición), [`locale`](https://postext.dev/es/docs/configuration-language.md#separación-silábica), [`page`](https://postext.dev/es/docs/configuration-page-layout.md#página), [`paragraphStyles`](https://postext.dev/es/docs/configuration-styles.md#estilos-de-párrafo), [`print`](https://postext.dev/es/docs/configuration-fonts-colors-viewers.md#producción-para-imprenta-configuración)

**API**

- [`buildDocumentWithFonts`](https://postext.dev/es/docs/configuration-programmatic-usage.md#cargar-las-fuentes-antes-de-componer), [`createFolioFromDocument`](https://postext.dev/es/docs/configuration-html-folio-epub.md#un-libro-en-3d-postext-folio), [`decompressWoff2`](https://postext.dev/es/docs/configuration-pdf-output.md#proveedor-de-fuentes-en-el-navegador-fontsource--woff2), [`registerResourceImage`](https://postext.dev/es/docs/architecture.md#api-pública), [`renderPageToCanvas`](https://postext.dev/es/docs/configuration-programmatic-usage.md#renderizar-una-página-como-mapa-de-bits), [`renderToPdf`](https://postext.dev/es/docs/configuration-pdf-output.md#generación-de-pdf)

**Tipografías**

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

## Elaboración

### 1 · Agujeros donde el dibujo siguiente se delata

El código es [la respuesta corta](https://postext.dev/es/cookbook/peek-a-boo-board-book.md#la-respuesta-corta) de arriba. Cada forma se coloca desde la esquina superior izquierda del corte y `dieCuts.pages` dice qué página corta, contando desde la primera del libro. Mide el agujero sobre la pintura que descubre, no sobre la página donde se corta: el seto, la valla y la puerta son texturas que admiten un agujero en cualquier sitio; el gato y el farolillo no.

### 2 · Pinturas en registro con los agujeros

```js
// script.js, líneas 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 } },
];
```

Los agujeros van en milímetros desde el corte, así que cada pintura cuelga del corte y lo rebasa el sangrado por los cuatro lados, igual en pantalla que en imprenta. El estilo de las pinturas solo quita el margen inferior: su diseño llega al pie de la página, y el texto del verso de detrás conserva sus 44 mm de margen superior, que lo bajan por debajo de los agujeros pequeños.

### 3 · La línea de troquel en su plancha

```js
// script.js, líneas 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 imprime cada página entera y traza el contorno de cada agujero, y de cada hoja redondeada, en una separación `Die` en sobreimpresión que nunca se entinta. `convertImages: false` deja las pinturas como JPEG RGB etiquetados sRGB, que PDF/X-4 admite, y el archivo sigue siendo pequeño.

### 4 · El libro en la mano

```js
// script.js, líneas 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 corta los agujeros en cada hoja y enseña las páginas de debajo con las paredes del corte, así que la ventana escalonada se lee como profundidad. El cartón se pasa rígido y las esquinas redondeadas se cortan en todas las hojas.

### 5 · Páginas planas que dejan ver

```js
// script.js, líneas 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);
};
```

En el canvas, un agujero muestra lo que haya detrás del canvas si el renderizador no recibe las páginas de debajo. `beneath` las devuelve por índice, cada una pintada con sus propios agujeros, y así la cubierta deja ver el seto y, a través del seto, el gato.

## La receta completa

Un solo archivo, compuesto a partir de la carpeta de la receta con el texto de ejemplo y el kit común del Recetario ya incluidos; construye su propia página. Para ejecutarlo, ponlo en un `<script type="module">` de una página vacía o pégalo en el panel JS de un pen nuevo de CodePen (como módulo). Importa postext desde esm.sh, así que no hay nada que instalar ni compilar.

- Carpeta de la receta: 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 ───────────────────────────────────────────────────────────────────────
```

## Variantes

### Redondea solo las esquinas del corte delantero

Un álbum ilustrado redondea las dos esquinas lejos del lomo y deja el lomo en escuadra.

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

### Corta cada hoja con una forma

Un contorno en unidades de `viewBox` corta cada hoja, en espejo en los versos; manda sobre las esquinas.

```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éditos

- Receta: Ignacio Ferro ([@drnachio](https://github.com/drnachio))
- Texto: El texto del libro de cartón: Postext Cookbook, CC-BY-4.0
- Imágenes: Pintura de cubierta: un jardín, un seto, malvarrosas y un petirrojo: Generated With Diffusion Models, original
- Imágenes: Página 3: el seto: Generated With Diffusion Models, original
- Imágenes: Página 5: el gato pelirrojo dormido: Generated With Diffusion Models, original
- Imágenes: Página 7: la valla de madera: Generated With Diffusion Models, original
- Imágenes: Página 9: la oveja: Generated With Diffusion Models, original
- Imágenes: Página 11: la puerta del granero: Generated With Diffusion Models, original
- Imágenes: Página 13: el abuelo con su farolillo al anochecer: Generated With Diffusion Models, original
- Tipografías: Andika (OFL-1.1), Fredoka (OFL-1.1), Nunito (OFL-1.1)
- Código: MIT · Contenido de ejemplo: CC-BY-4.0

## Relacionadas

- [N.º 195 · Un libro túnel de veinte hojas de hondo](https://postext.dev/es/cookbook/forest-tunnel-book.md): Diecinueve ventanas redondas troqueladas con dieCuts, cada una menor que la anterior: desde la cubierta se ve a través de veinte planos hasta un ciervo. · Nivel 3 (Avanzado) · Hojas sueltas y efímeros
- [N.º 100 · Un libro compuesto sobre la mesa, en 3D](https://postext.dev/es/cookbook/folio-book-on-a-desk.md): createFolioFromDocument, del paquete postext-folio, abre un capítulo compuesto como un libro en tela sobre una mesa de nogal, con el aspecto de config.folio. · Nivel 2 (Intermedio) · Narrativa, teatro y prosa literaria
- [N.º 191 · Una carta de panadería en tinta blanca sobre kraft](https://postext.dev/es/cookbook/white-ink-kraft-menu.md): El blanco opaco como tinta plana sobre kraft: letra blanca sobre la cartulina parda, un fondo blanco bajo letra parda y blanco calado en un panel verde. · Nivel 3 (Avanzado) · Hojas sueltas y efímeros
