幻灯片与绘图

模板函数 slides：页面、字体和两种特殊页#

slides 的签名和第 4 篇的 note 是一个路数：命名参数加最后一个位置参数 body，在 #show: slides.with(...) 里被当作模板调用。它做了四件事。

第一，set page。 paper: "presentation-16-9" 是 "presentation-" + aspect 拼出来的，aspect 默认 "16-9"，传 "4-3" 就得到 4<3> 的页面。边距写成 (x: 2em, top: 2.5em, bottom: 2em)，用 em 而不是 cm，大概是想让页边距跟着字号走。我在 72 ppi 的渲染图里看左边距：幻灯片标题的左缘大约在 40 px 处，也就是 40 pt，等于 20pt 字号的 2em，和预期一致。footer: slide-footer() 把页脚挂到每一页上。

第二，字体。 set text(font: fonts.sans, size: 20pt, lang: lang) 用第 5 篇 fonts.typ 里的无衬线栈；幻灯片投影时无衬线更清晰，这是选择它而不是衬线栈的原因。raw 单独用等宽字体并缩到 0.85em（我觉得 20pt 的页面上代码块按默认大小会偏大），公式用 fonts.math。

第三，章节页。 show heading.where(level: 1) 把一级标题整个重写成一张分隔页：先 pagebreak(weak: true)，再 counter("xuan-slide").step()，然后 v(1fr)、居中的标题、v(1fr)。两个 1fr 平分页面剩余的高度，标题就落在垂直正中。它输出的是 it.body 而不是 it，标题完全由这条规则自己排版。章节页也算一个“幻灯片”，要占一个编号（总览图里的 1 / 13 就是第一张章节页）。

第四，标题页。 最后一段 page(footer: none, align(horizon, title-block(...)))：page 作为函数调用，自成一页，并在这一页上覆盖了 footer，所以标题页没有页脚（这也是为什么上面 17 页只有 16 行 n / N）。里面直接复用第 6 篇写好的 title-block，align(horizon, ...) 让它垂直居中。

这四件事做完，用户在 body 里写的 = 和 #slide 就是全部输入。

slide：一页，或者 N 页#

1
#let slide(title: none, steps: 1, body) = {
2
  let steps = if type(body) == function { steps } else { 1 }
3
  for k in range(1, steps + 1) {
4
    pagebreak(weak: true)
5
    if k == 1 { counter("xuan-slide").step() }
6
    if title != none {
7
      block(text(size: 1.4em, weight: "bold", title), below: 0.9em)
8
    }
9
    if type(body) == function { body(k) } else { body }
10
  }
11
}

这段是这份文件的核心，值得逐行读。

• body 有两种形态：普通 content，或者一个 k => content 的函数。type(body) == function 判断是哪一种。
• 第一行 let steps = ... 把参数 steps 遮蔽（第 2 篇讲过的 shadowing）成一个新值：body 是 content 时一律是 1，steps: 3 配一个静态 body 不会生成三页一模一样的页面。
• 循环里每个 k 生成一页。pagebreak(weak: true) 放在每页的开头，而不是结尾：函数调用没有“结束时”的钩子，把分页写在开头，最后一页后面就不会拖一个空页。weak 的意思是：如果当前页本来就是空的（刚刚被 page(...) 或者前一次分页开出来），这次分页不生效。17 页的结果印证了这一点：1 + 4 + 12 = 17，没有任何空页。
• if k == 1 { counter("xuan-slide").step() }：只有第一步让编号加一。后面的步骤与它共享编号，页脚读到的就是同一个数，这就是上面 3 / 13 重复三次的来源。
• 标题是 1.4em 粗体的一个 block，below: 0.9em 拉开和正文的距离。
• 最后一行把 k 传给函数形态的 body。

分步显示在这里不是“在同一页上改动”，而是每一步重画一整页，像手绘动画的逐帧：每一帧都是完整的画。一张幻灯片因此就是 steps 次完整排版，代价是 body 要写成函数，好处是没有任何隐藏状态，任何一页单独拿出来都是自洽的。

用法就是前面摘录里的“编译很快”：把 body 写成 k => [...]，steps: 3 说明要三页。这个函数是最后一个位置参数，所以写在括号里面，前面的 title: 和 steps: 是命名参数。

uncover 与 only：占位与不占位#

1
#let uncover(k, from: 1, body) = {
2
  if k >= from { body } else {
3
    hide({
4
      set list(marker: [])
5
      set enum(numbering: _ => [])
6
      body
7
    })
8
  }
9
}
10

11
#let only(k, at: (1,), body) = {
12
  let steps = if type(at) == array { at } else { (at,) }
13
  if k in steps { body }
14
}

两个函数回答同一个问题的两个答案：“这一步还没到的时候，这块内容的位置要不要留着？”

• uncover 用 hide：内容被隐藏，但仍然占着位置。后面的内容不会因为它出现而被挤下去，页面布局在每一步之间保持不动。
• only 用“不输出”：内容只在列出的步骤里存在，其他步骤里完全不存在，不占位。at 可以是单个整数或者整数数组，函数开头用 type(at) == array 把单个数包成一元数组，再用 k in steps 判断。默认 (1,) 表示只在第一步出现，用来写“第一步的占位提示，下一步换掉”之类的内容。

uncover 里多出来的那两行 set 有一段来历。最朴素的写法是 if k >= from { body } else { hide(body) }，xuan 的 uncover 一开始就是这样写的，渲染出来第 4 页是这样（这张图来自 uncover 修复之前的仓库状态）：

被隐藏的条目只有文字消失了，圆点还在。我在 /tmp 里把它缩成最小复现（k = 1，只有 /tmp，不在仓库中）：

1
#set page(width: 8cm, height: auto, margin: 8pt)
2
#let uncover(k, from: 1, body) = if k >= from { body } else { hide(body) }
3
#let k = 1
4
#uncover(k, from: 2)[- 乙]
5
#uncover(k, from: 3)[- 丙]
6
#line(length: 100%)
7
#uncover(k, from: 1)[- 甲]
8
#uncover(k, from: 2)[- 乙]

pdftotext -layout 的输出：

1
•
2
•
3

4

5
• 甲
6
•

上半部分两个条目都被 hide 了，输出里却有两个 •；下半部分只有“甲”可见，“乙”也留下了圆点。（我另外试过单独一个 #hide[- 隐藏的列表项] 后面跟一段正文，它连圆点一起隐藏了，所以这个现象和列表相邻的情形有关，具体原因我没有深挖。）把圆点放在 uncover 外面的写法 - #uncover(k, from: 2)[乙] 我也试了，圆点同样会显示。

结论是：hide 在这里只保证文字不可见，列表的标记（和枚举的数字）仍会被画出来。xuan 的做法是在隐藏的那一份里，把标记本身换成空内容：set list(marker: []) 和 set enum(numbering: _ => [])。两条 set 写在 hide({ ... }) 的代码块里，作用范围只到这个块，可见的那一份不受影响；hide 之后条目的行高和位置没变，所以布局仍然不跳。我用 xuan 里现在的 uncover 重跑同样的三项（k = 1，同样只在 /tmp）：

1
#import "@local/xuan:0.1.0": uncover
2
#set page(width: 8cm, height: auto, margin: 8pt)
3
#let k = 1
4
#uncover(k, from: 1)[- 甲]
5
#uncover(k, from: 2)[- 乙]
6
#uncover(k, from: 3)[- 丙]

1
• 甲

现在只有“甲”那一行。真实的第 4 页（pdftotext 的输出里只有一行条目）：

第 6 页（k = 3）三条全部可见，第一条在两张图里的位置没有动：

only 在不涉及占位的场景里没有这个问题，例如“内置图形”那一页：

1
#slide(title: "内置图形", steps: 2, k => [
2
  #align(center, box(width: 12em, height: 6em, {
3
    place(rect(width: 5em, height: 4em, fill: rgb("#cfe0f5"), radius: 4pt))
4
    place(dx: 6.5em, circle(radius: 2em, fill: rgb("#f5d9cf")))
5
    only(k, at: 2, place(dx: 4.8em, dy: 2em, line(
6
      length: 2em,
7
      stroke: 2pt + rgb("#1f4e9c"),
8
    )))
9
  }))
10
  #uncover(k, from: 2)[矩形与圆之间多了一条线。]
11
])

box(width: 12em, height: 6em, { ... }) 先给出一块固定大小的画布，里面的矩形和圆都用 place 摆放，place 不占流内空间，所以 only(k, at: 2, place(...)) 在第 2 步才出现的那条线，既不需要预留位置，也不会推动任何东西。第 12、13 页如下：

第二步下方多出来的“矩形与圆之间多了一条线。”是 uncover(k, from: 2) 控制的：第一步里它是隐藏的，位置留着，所以图在两步之间没有跳动。

页脚：进度条是怎么算出来的#

1
#let slide-footer() = context {
2
  let n = counter("xuan-slide").get().first()
3
  let total = counter("xuan-slide").final().first()
4
  let accent = rgb("#1f4e9c")
5
  stack(
6
    spacing: 4pt,
7
    block(width: 100%, height: 2pt, fill: luma(225), rect(
8
      width: 100% * n / calc.max(total, 1),
9
      height: 2pt,
10
      fill: accent,
11
      stroke: none,
12
    )),
13
    align(right, text(size: 0.6em, fill: luma(110))[#n / #total]),
14
  )
15
}

它用到了上一篇的全部家当：

• 整个函数体包在 context 里，因为 counter(...).get() 和 .final() 都需要知道“当前在哪”。页脚在每一页上各被求值一次，每次的 get() 都是该页的编号。
• counter("xuan-slide") 是一个按字符串命名的自定义计数器，不绑定任何元素。slide 和章节页在各自开头 step() 它，页脚只读。
• .get().first() 是当前页的编号 n，.final().first() 是整份文档最后的值 total（这里是 13，不是页数 17：编号按“幻灯片”算，不按“页”算）。读 .final() 的代价是文档至少要排两遍，这也是 135.5 ms 里包含的东西。
• 进度条是两层：灰色轨道 block(width: 100%, height: 2pt, fill: luma(225), ...)，里面一条 n / total 比例的蓝色 rect。rect 的宽度写成 100% * n / calc.max(total, 1)，这是一个相对长度，相对于外层轨道 block 的宽度，所以不需要知道页面有多宽。calc.max(total, 1) 防止没有任何幻灯片编号时除以零。右下角是 n / total 的数字，0.6em 灰色。
• 我在 /tmp 里核对了这个比例（只在 /tmp，不在仓库里）：200pt 宽的页面，n = 3、total = 13，渲染到 72 ppi 后蓝色条的宽度是 46 px，与 200 × 3 / 13 = 46.15 相符。

进度条的几何关系，我用一张手绘的假幻灯片（lab/ch13/fig-slide.typ）单独画了出来（源文件）：rect 当页面边框，place(bottom + left, ...) 把一条 33% 宽的蓝条放在左下角：

1
// One slide of examples/slides, rendered as a PNG figure.
2
#import "@local/xuan:0.1.0": *
3

4
#set page(width: auto, height: auto, margin: 12pt)
5
#set text(font: fonts.sans, size: 14pt, lang: "zh")
6

7
#rect(
8
  width: 20em,
9
  height: 11.25em,
10
  stroke: 0.6pt + luma(160),
11
  inset: 1.2em,
12
)[
13
  #text(size: 1.4em, weight: "bold")[三种模式]
14
  #v(0.6em)
15
  - 标记模式：默认，写正文
16
  - 代码模式：`#` 进入，写逻辑
17
  - 数学模式：`$ ... $`，写公式
18
  #place(bottom + left, dy: 0.6em, rect(
19
    width: 33%,
20
    height: 2pt,
21
    fill: rgb("#1f4e9c"),
22
    stroke: none,
23
  ))
24
]

日期：datetime.today() 与 SOURCE_DATE_EPOCH#

slides 把 date 原样交给第 6 篇的 title-block。title-block 对 date 有三种处理：auto 取 datetime.today() 并按中文格式显示，datetime 值显示成 2026-10-19 的样式，字符串原样输出。examples/slides 传的是第三种。

原因在 dev shell。nix develop 的 stdenv 习惯把 SOURCE_DATE_EPOCH 设成 1980-01-01，这会让 datetime.today() 永远是 1980 年；typst-lab 的 flake.nix 在 shellHook 里把它 unset 了（源文件里就是一行 unset SOURCE_DATE_EPOCH，为的是让 datetime.today() 回到真实的日期）。我在 /tmp 里写了两个文件验证（只在 /tmp，不在仓库里）：

1
#import "@local/xuan:0.1.0": *
2
#show: slides.with(title: "日期", date: auto)

1
#import "@local/xuan:0.1.0": *
2
#show: slides.with(title: "日期", date: datetime(
3
  year: 2026,
4
  month: 10,
5
  day: 19,
6
))

1
typst compile --root /tmp --ignore-system-fonts today.typ a.pdf
2
pdftotext a.pdf - | grep 年
3
SOURCE_DATE_EPOCH=315532800 typst compile --root /tmp --ignore-system-fonts today.typ b.pdf
4
pdftotext b.pdf - | grep 年
5
SOURCE_DATE_EPOCH=315532800 typst compile --root /tmp --ignore-system-fonts today-fixed.typ c.pdf
6
pdftotext c.pdf - | grep -E '[0-9]{4}'

1
2026 年 10 月 19 日
2
1980 年 1 月 1 日
3
2026-10-19

第一行是 dev shell 里 date: auto 的结果（SOURCE_DATE_EPOCH 未设置）。第二行我手动设 SOURCE_DATE_EPOCH=315532800（1980-01-01 00<00> UTC，也就是上面说的 nix 默认值）后，date: auto 变成了 1980 年；第三行里同样设置，但源码里传的是显式的 datetime(...)，仍然是 2026-10-19，不受环境变量影响。

所以结论是：date: auto 的幻灯片，其日期取决于编译时的环境，不是源文件的函数。想要可复现的输出（CI 里、别人机器上），就像 examples/slides 那样写死日期。

形状：rect、square、circle、ellipse、line、polygon#

lab/ch13/shapes.typ（源文件）：

1
// Built-in shapes: rect, square, circle, ellipse, line, polygon.
2
#import "@local/xuan:0.1.0": *
3
#set text(font: fonts.sans, size: 10pt)
4
#let blue = rgb("#1f4e9c")
5
#let tint = rgb("#cfe0f5")
6

7
#grid(
8
  columns: 3,
9
  gutter: 1.2em,
10
  rect(width: 4em, height: 2.5em, fill: tint, stroke: blue),
11
  // `radius` rounds corners; a dictionary sets each corner.
12
  rect(
13
    width: 4em,
14
    height: 2.5em,
15
    fill: tint,
16
    radius: (top-left: 8pt, bottom-right: 8pt),
17
  ),
18
  // `square` is a rect whose `size` fixes both sides.
19
  square(size: 2.5em, fill: tint, stroke: blue),
20
  circle(radius: 1.2em, fill: tint, stroke: blue),
21
  ellipse(width: 4em, height: 2.5em, fill: tint, stroke: blue),
22
  // A shape can hold content; `inset` pads it.
23
  rect(fill: tint, inset: 8pt)[文字],
24
  line(length: 4em, stroke: 2pt + blue),
25
  line(start: (0pt, 0pt), end: (4em, 2em), stroke: 1pt),
26

27
  polygon(
28
    fill: tint,
29
    stroke: blue,
30
    (0pt, 2.5em),
31
    (1.5em, 0pt),
32
    (3em, 2.5em),
33
  ),
34
)
35
// Shapes are ordinary content: they have a type and can be inspected.
36
#assert.eq(repr(rect().func()), "rect")

几点值得记：

• 所有形状都有 fill 和 stroke。stroke: blue 只指定颜色，粗细用默认值。
• rect 的 radius 可以是一个长度，也可以是一个字典（top-left、bottom-right 等四个角分别设置）。图里第二个矩形的左上和右下是圆角。
• square(size: ...) 就是 width 和 height 相等的 rect；circle(radius: ...) 用半径，ellipse 给 width 和 height。
• 形状可以带内容：rect(fill: tint, inset: 8pt)[文字]，inset 是内容到边框的距离。不给尺寸时它收缩到内容的大小，这就是图里“文字”那个浅蓝色块。
• line 有两种写法：line(length: 4em) 画一条水平线，line(start: ..., end: ...) 给出两个端点。三角形用 polygon 给顶点列表。
• 形状是普通 content：文件最后一行 #assert.eq(repr(rect().func()), "rect") 说明 rect() 的 func 就是 rect，可以用第 3 篇的内省办法检查。

curve：由分段组成的路径#

curve 与 polygon 的区别在于它的参数是一串路径分段，包括直线、二次与三次贝塞尔曲线，可以画出光滑的形状。lab/ch13/curve.typ（源文件）：

1
// `curve` draws paths from components: move, line, quad, cubic, close.
2
#let blue = rgb("#1f4e9c")
3

4
// A closed triangle.
5
#curve(
6
  fill: rgb("#cfe0f5"),
7
  stroke: blue,
8
  curve.move((0pt, 40pt)),
9
  curve.line((30pt, 0pt)),
10
  curve.line((60pt, 40pt)),
11
  curve.close(),
12
)
13

14
#v(1em)
15
// A cubic Bezier: start, two control points, end.
16
#curve(
17
  stroke: 2pt + blue,
18
  curve.move((0pt, 40pt)),
19
  curve.cubic((20pt, -10pt), (60pt, 90pt), (80pt, 40pt)),
20
)
21

22
#v(1em)
23
// A quadratic Bezier; `relative: false` makes the control point absolute.
24
#curve(
25
  stroke: 2pt + blue,
26
  curve.move((0pt, 30pt)),
27
  curve.quad((30pt, -20pt), (60pt, 30pt), relative: false),
28
)

分段都是 curve 下的子函数：curve.move 把笔移到起点，curve.line 画直线，curve.quad 给一个控制点和终点，curve.cubic 给两个控制点和终点，curve.close 把路径封闭回起点，图里的三角形用它。

最后一个例子传的是 relative: false，也就是控制点和终点都是绝对坐标（这是默认值）。我在 /tmp 里把 relative 分别设成 false 和 true 画在一起（左 false，右 true）：

1
#set page(width: auto, height: auto, margin: 8pt)
2
#let blue = rgb("#1f4e9c")
3
#grid(
4
  columns: 2,
5
  gutter: 2em,
6
  curve(
7
    stroke: 2pt + blue,
8
    curve.move((0pt, 30pt)),
9
    curve.quad((30pt, -20pt), (60pt, 30pt), relative: false),
10
  ),
11
  curve(
12
    stroke: 2pt + blue,
13
    curve.move((0pt, 30pt)),
14
    curve.quad((30pt, -20pt), (60pt, 30pt), relative: true),
15
  ),
16
)

relative: true 时点是相对于上一个点的偏移，所以同样的数字画出来完全是另一条线。所以 lab 文件里的注释写成“relative: false makes the control point absolute”，false 是默认值，写出来是为了让读的人看见这一点。

颜色：色彩空间与方法#

lab/ch13/color.typ（源文件）：

1
// Color spaces, color methods and built-in maps.
2
#let swatch(c) = box(width: 2.2em, height: 1.2em, fill: c)
3
#let row(name, ..cs) = [#name: #cs.pos().map(swatch).join(h(2pt)) \ ]
4

5
#row("rgb", rgb("#1f4e9c"), rgb(31, 78, 156), rgb(12%, 30%, 61%))
6
#row("luma", luma(0), luma(128), luma(230))
7
#row("oklab", oklab(70%, 0.1, 0.1), oklab(70%, -0.1, 0.1))
8
#row("oklch", oklch(70%, 0.15, 30deg), oklch(70%, 0.15, 200deg))
9
#row("cmyk", cmyk(100%, 50%, 0%, 20%))
10
#row("hsl", color.hsl(210deg, 70%, 40%))
11

12
// Methods return new colors; the original is unchanged.
13
#let base = rgb("#1f4e9c")
14
#row(
15
  "methods",
16
  base.lighten(40%),
17
  base.darken(30%),
18
  base.rotate(120deg),
19
  base.transparentize(60%),
20
  base.negate(),
21
)
22
// `mix` blends in a chosen space; `components` reads the numbers back.
23
#row("mix", color.mix(red, blue), color.mix(red, blue, space: oklab))
24
#assert.eq(luma(50%).components(alpha: false).len(), 1)
25
// `color.map` holds ready-made color arrays (here 9 stops), also usable in gradients.
26
#row("map", ..color.map.viridis)

Typst 的颜色是带“色彩空间”的值：rgb、luma（灰度）、oklab、oklch、cmyk 都是顶层构造函数，lab 文件里的 hsl 写成了 color.hsl。同一个蓝色可以用不同方式表达，我用 typst eval 核对了第一行的三块：

1
typst eval 'rgb("#1f4e9c").to-hex()'
2
typst eval 'repr(rgb(31, 78, 156) == rgb("#1f4e9c"))'
3
typst eval 'repr(rgb(12%, 30%, 61%).to-hex())'

1
"#1f4e9c"
2
"true"
3
"\"#1f4c9c\""

十六进制和 rgb(31, 78, 156) 是同一个颜色；百分比那一块是我凑的数，其实是 #1f4c9c，红绿蓝各差一两个单位，肉眼分不出来，所以图里三块“几乎相同”。

颜色的方法都返回新颜色，原来的不变。同一个基色 #1f4e9c，我用 typst eval 读出每个方法的结果：

这正好对上图里 methods 那一行的五块色。rotate(120deg) 是在色相环上转 120 度，所以蓝变成了暗红；transparentize(60%) 把透明度加到 60%，alpha 变成 40%，十六进制里就是 66。

color.mix 的混合空间是个坑：

1
typst eval 'color.mix(red, blue).to-hex()'
2
typst eval 'color.mix(red, blue, space: oklab).to-hex()'
3
typst eval 'color.mix(red, blue, space: rgb).to-hex()'

1
"#a37095"
2
"#a37095"
3
"#805b87"

默认空间是 oklab（前两行相同），所以 lab 里 mix 那一行的两块是同一个紫色（图里确实一样）；在 rgb 里混合是 #805b87，更暗更灰，因为 sRGB 的数值空间对人眼来说不均匀。

最后一行 color.map.viridis 是一个内置的颜色数组，.len() 是 9；color.map.turbo 的长度是 256（我同样用 typst eval 核对了）。lab 里用 ..cs.pos() 之类把它展开，在渐变里则直接 ..color.map.turbo 展开成色标。

渐变：linear、radial、conic#

lab/ch13/gradient.typ（源文件）：

1
// Three gradient kinds, all usable wherever a fill or stroke is.
2
#let stops = (rgb("#1f4e9c"), rgb("#e7a33e"))
3
#let box(g) = rect(width: 8em, height: 4em, fill: g)
4

5
#grid(
6
  columns: 3,
7
  gutter: 1em,
8
  box(gradient.linear(..stops)), box(gradient.linear(..stops, angle: 45deg)),
9
  // Explicit stops: (color, position).
10
  box(gradient.linear((red, 0%), (white, 30%), (blue, 100%))),
11
  box(gradient.radial(..stops)),
12
  box(gradient.radial(..stops, center: (20%, 30%), radius: 80%)),
13

14
  box(gradient.conic(..stops)),
15
  // Interpolation space changes the midpoint: try oklab vs srgb.
16
  box(gradient.linear(red, blue, space: oklab)),
17
  box(gradient.linear(red, blue, space: rgb)),
18
  // A built-in map plus `.sharp` for banding.
19
  box(gradient.linear(..color.map.turbo)),
20
  box(gradient.linear(..stops).sharp(5)),
21
)
22

23
#let g = gradient.linear(..stops)
24
// `sample` reads a color back at a ratio (in the gradient space, oklab).
25
#assert.eq(rgb(g.sample(0%)).to-hex(), "#1f4e9c")
26
#assert.eq(g.stops().len(), 2)

渐变是一个值，可以出现在任何要颜色的地方（fill、stroke、文字的 fill）。三种：

• gradient.linear(..)：沿一个方向变化，angle: 改方向。色标可以直接给颜色（均分），也可以给 (颜色, 位置) 对，如图里第三个红、白、蓝，白色被拉到 30% 处。
• gradient.radial(..)：从中心向外，center 和 radius 控制圆心与半径。图里第二行的第二块把圆心移到 (20%, 30%)。
• gradient.conic(..)：绕中心旋转的角度渐变，图里第二行第三块，两种颜色在分界线上有一条硬边。

插值空间决定渐变的中间色。默认是 oklab，我核对了一下：

1
typst eval 'gradient.linear(red, blue).space() == oklab'
2
typst eval 'gradient.linear(red, blue, space: oklab).sample(50%).to-hex()'
3
typst eval 'gradient.linear(red, blue, space: rgb).sample(50%).to-hex()'

1
true
2
"#a37095"
3
"#805b87"

和上面 mix 的两个结果一致：在 oklab 里红到蓝的中点是 #a37095，在 sRGB 里是 #805b87。图里第三行前两块就是这一对，左边（oklab）中间明显更亮。

另外两个值得一记的：.sharp(5) 把平滑渐变切成 5 段硬边色带，图里最后一块；..color.map.turbo 把 256 个色标一次展开成渐变，得到彩虹条。文件最后两条 assert 用 sample 和 stops 读回渐变：rgb(g.sample(0%)).to-hex() 等于起点色 #1f4e9c，g.stops().len() 是 2。sample 返回的颜色在渐变自己的空间（这里是 oklab）里，所以断言前先用 rgb(...) 转了一下。

tiling：用一小块图案铺满#

tiling 把一块小内容重复，当作 fill 用。lab/ch13/tiling.typ（源文件）：

1
// `tiling` repeats a cell to fill a shape (patterns).
2
#let blue = rgb("#1f4e9c")
3

4
// Diagonal hatching.
5
#let hatch = tiling(size: (8pt, 8pt))[
6
  #place(line(start: (0%, 100%), end: (100%, 0%), stroke: 0.8pt + blue))
7
]
8
// Dots, with `spacing` between cells.
9
#let dots = tiling(size: (10pt, 10pt), spacing: (4pt, 4pt))[
10
  #align(center + horizon, circle(radius: 2pt, fill: blue))
11
]
12
// Tilings take a relative frame: `parent` makes them align across shapes.
13
#let grid-cell = tiling(size: (12pt, 12pt), relative: "parent")[
14
  #rect(width: 100%, height: 100%, stroke: 0.4pt + luma(150))
15
]
16

17
#grid(
18
  columns: 3,
19
  gutter: 1em,
20
  rect(width: 6em, height: 4em, fill: hatch, stroke: blue),
21
  rect(width: 6em, height: 4em, fill: dots),
22
  rect(width: 6em, height: 4em, fill: grid-cell),
23
)

左边是斜线填充，中间是圆点，右边的方格网用 relative: "parent" 让方格相对于父容器对齐。

圆点那一格用的是 align(center + horizon, ...)，而不是上面斜线用的 place。这不是风格问题：我在 /tmp 里把三种写法并排比较了（只在 /tmp，不在仓库里）：

1
#set page(width: auto, height: auto, margin: 8pt)
2
#let blue = rgb("#1f4e9c")
3
#let a = tiling(size: (10pt, 10pt), spacing: (4pt, 4pt))[
4
  #place(center + horizon, circle(radius: 2pt, fill: blue))
5
]
6
#let b = tiling(size: (10pt, 10pt), spacing: (4pt, 4pt))[
7
  #align(center + horizon, circle(radius: 2pt, fill: blue))
8
]
9
#let c = tiling(size: (10pt, 10pt), spacing: (4pt, 4pt))[
10
  #place(dx: 3pt, dy: 3pt, circle(radius: 2pt, fill: blue))
11
]
12
#grid(
13
  columns: 3,
14
  gutter: 1em,
15
  rect(width: 6em, height: 4em, fill: a),
16
  rect(width: 6em, height: 4em, fill: b),
17
  rect(width: 6em, height: 4em, fill: c),
18
)

a 用 place(center + horizon, ...)，每个点只剩左上角；b 用 align，c 用 place 加显式偏移，都是完整的圆点。我的猜测是：tiling 的 body 不是在一个固定 size 的容器里排版的，place 的对齐目标是一个没有尺寸的区域，center + horizon 因此对准了左上角这个原点；而 align 参与了内容自身的排版，用的是 size 给出的单元。我没有去翻 Typst 的源码确认，只能说这是三种写法的实测差异。

tiling(size: ..., spacing: ..., relative: ...) 的三个参数：size 是一个单元的大小，spacing 是单元之间的间距（中间那种圆点图案里的空白就来自它），relative 说明图案相对谁对齐，lab 里的方格网用了 "parent"，让图案相对于父容器对齐，多个形状上的图案就能连成一整块。

描边：字典的写法#

lab/ch13/stroke.typ（源文件）：

1
// A stroke is paint + thickness + dash + cap + join, or a dictionary.
2
#let blue = rgb("#1f4e9c")
3
#let ln(s) = line(length: 8em, stroke: s)
4

5
#ln(1pt + blue) // shorthand: length + color
6
#ln((paint: blue, thickness: 3pt, cap: "round"))
7
#ln((paint: blue, thickness: 2pt, dash: "dashed"))
8
#ln((paint: blue, thickness: 2pt, dash: "dotted"))
9
#ln((paint: blue, thickness: 2pt, dash: (array: (6pt, 3pt, 1pt, 3pt))))
10
#ln((paint: gradient.linear(red, blue), thickness: 4pt))
11

12
// Per-side strokes on a rect; `none` hides a side.
13
#rect(
14
  width: 8em,
15
  height: 3em,
16
  stroke: (top: 2pt + blue, bottom: 2pt + blue, rest: 0.5pt + luma(150)),
17
)
18
// `join` matters on sharp corners.
19
#polygon(
20
  stroke: (paint: blue, thickness: 6pt, join: "round"),
21
  (0pt, 30pt),
22
  (30pt, 0pt),
23
  (60pt, 30pt),
24
)
25
// A stroke value is inspectable.
26
#assert.eq((1pt + blue).thickness, 1pt)

描边是 paint（颜色或渐变）、thickness、dash、cap、join 的组合。有两种写法：

• 简写：1pt + blue，长度加颜色。repr(1pt + rgb("#1f4e9c")) 的输出是 1pt + rgb("#1f4e9c")。
• 字典：(paint: blue, thickness: 3pt, cap: "round")，可以写全部五个键。

dash 接受预设字符串或者自定义数组。我用 typst eval 把预设展开成了数组：

1
typst eval 'repr(stroke((paint: red, thickness: 2pt, dash: "dashed")).dash)'
2
typst eval 'repr(stroke((paint: red, thickness: 2pt, dash: "dotted")).dash)'

1
"(array: (3pt, 3pt), phase: 0pt)"
2
"(array: (\"dot\", 2pt), phase: 0pt)"

"dashed" 是“线 3pt、空 3pt”；"dotted" 是一个 "dot" 加 2pt 空。自定义的 (array: (6pt, 3pt, 1pt, 3pt)) 是“线 6pt、空 3pt、线 1pt、空 3pt”循环，就是图里的点划线。paint 也可以是渐变（图里第六条红到蓝的粗线）。

图里倒数第二个矩形展示了逐边描边：stroke: (top: 2pt + blue, bottom: 2pt + blue, rest: 0.5pt + luma(150))，上下两条蓝色粗边，剩下的边（rest）是灰色细边。最后一个三角形用 join: "round" 让尖角变圆；文件末尾的 assert.eq((1pt + blue).thickness, 1pt) 说明描边值可以读回属性。

一张小拼图#

lab/ch13/fig-drawing.typ（源文件）把以上的东西拼在一起，是 make ch13 直接输出的图（out/figures/ch13-drawing.png）：

1
// A small gallery: shapes, a gradient, a tiling and a dashed stroke.
2
#set page(width: auto, height: auto, margin: 12pt)
3
#let blue = rgb("#1f4e9c")
4
#let hatch = tiling(size: (8pt, 8pt))[
5
  #place(line(start: (0%, 100%), end: (100%, 0%), stroke: 0.8pt + blue))
6
]
7

8
#grid(
9
  columns: 4,
10
  gutter: 14pt,
11
  rect(width: 60pt, height: 40pt, fill: rgb("#cfe0f5"), stroke: blue),
12
  circle(radius: 20pt, fill: gradient.radial(white, blue)),
13
  rect(width: 60pt, height: 40pt, fill: hatch, stroke: blue),
14
  polygon(
15
    fill: rgb("#f5d9cf"),
16
    stroke: (paint: blue, thickness: 2pt, dash: "dashed"),
17
    (0pt, 40pt),
18
    (30pt, 0pt),
19
    (60pt, 40pt),
20
  ),
21
)