g

.vscode/settings.json

@@ -9,6 +9,5 @@
   "tinymist.formatterMode": "typstyle",
   "[typst]": {
     "editor.inlayHints.enabled": "off"
-  },
-  "tinymist.hoverPeriscope": "enable"
+  }
 }

src/basic/reference-typebase.typ

@@ -9,7 +9,7 @@
 // 空字面量是纯粹抽象的概念，这意味着你在现实中很难找到对应的实体。就像是数学中的零与负数，空字面量自然产生于运算过程中。
 
 // #code(```typ
-// #repr((0, 1).find((_) => false)), 
+// #repr((0, 1).find((_) => false)),
 // #repr(if false [啊？])
 // ```)
 
@@ -371,14 +371,14 @@ Typst的整数是64位宽度的有符号整数。#ref-bookmark[`type:int`]
 
 *64位宽度*整数的意思是，Typst允许你使用的整数是有限大的。正数、负数与整数均分$2^64$个数字。因此：
 - 最大的正整数是$2^63-1$。
-  
+
   #code(```typ
   #int(9223372036854775807)
   ```)
-- 最小的负整数是$-2^63$。
-  
+- 最小的负整数是$-2^63$。（todo: typst v0.12.0这里有一个bug）
+
   #code(```typ
-  #int(-9223372036854775808)
+  #int(-9223372036854775807-1)
   ```)
 
 Typst还允许你使用其他#term("representation")表示整数。借鉴了其他编程语言，使用`0x`、`0o`和`0b`分别可以指定十六进制、八进制和二进制整数：
@@ -593,21 +593,21 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 
 #glue-block[
   #ref-method-signature("str.to-unicode")
-  
+
   你可以使用#typst-func("str.to-unicode")#ref-bookmark[`method:to-unicode`\ `of str`]函数获得一个字符的#term("codepoint")表示：
-  
+
   #code(```typ
   #"a".to-unicode(),
   #"我".to-unicode()
   ```)
-  
+
   #pro-tip[
     显然，不是所有的“字符”都可以应用`to-unicode`方法。
-    
+
     #```typ
     #"ã".to-unicode() /* 不能编译 */
     ```
-    
+
     这是因为视觉上为单个字符的ã是一个#term("grapheme cluster")，包含多个码位。
   ]
 ]
@@ -626,33 +626,33 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 你可以使用#typst-func("str.len")#ref-bookmark[`method:len`\ `of str`]函数获得一个字符串的*字节表示的长度*：
 
 #code(```typ
-#"abc".len(), 
-#"香風とうふ店".len(), 
+#"abc".len(),
+#"香風とうふ店".len(),
 #"ã".len()
 ```)
 
 你可能希望得到一个字符串的#term("codepoint width")，这时你可以组合以下方法：
 #code(```typ
-#"abc".codepoints().len(), 
-#"香風とうふ店".codepoints().len(), 
+#"abc".codepoints().len(),
+#"香風とうふ店".codepoints().len(),
 #"ã".codepoints().len()
 ```)
 
 你可能希望得到一个字符串的#term("grapheme cluster width")，这时你可以组合以下方法：
 #code(```typ
-#"abc".clusters().len(), 
-#"香風とうふ店".clusters().len(), 
+#"abc".clusters().len(),
+#"香風とうふ店".clusters().len(),
 #"ã".clusters().len()
 ```)
 
 #glue-block[
   #ref-method-signature("str.first")
-  
+
   你可以使用#typst-func("str.first")#ref-bookmark[`method:first`\ `of str`]函数获得一个字符串的第一个#term("grapheme cluster")：
-  
+
   #code(```typ
-  #"Wee".first(), 
-  #"我 们 俩".first(), 
+  #"Wee".first(),
+  #"我 们 俩".first(),
   #"\u{0061}\u{0303}\u{0061}".first()
   ```)
 ]
@@ -661,9 +661,9 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 你可以使用#typst-func("str.last")#ref-bookmark[`method:last`\ `of str`]函数获得一个字符串的最后一个#term("grapheme cluster")：
 
 #code(```typ
-#"Wee".last(), 
-#"我 们 俩".last(), 
-#"\u{0061}\u{0303}\u{0061}".last(), 
+#"Wee".last(),
+#"我 们 俩".last(),
+#"\u{0061}\u{0303}\u{0061}".last(),
 #"\u{0061}\u{0061}\u{0303}".last()
 ```)
 
@@ -672,9 +672,9 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 你可以使用#typst-func("str.at")#ref-bookmark[`method:at`\ `of str`]函数获得一个字符串位于*字节偏移量*为`offset`的#term("grapheme cluster")：
 
 #code(```typ
-#"我 们 俩".at(0), 
+#"我 们 俩".at(0),
 #"我 们 俩".at(3),
-#"我 们 俩".at(4), 
+#"我 们 俩".at(4),
 #"我 们 俩".at(8)
 ```)
 
@@ -685,14 +685,14 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 你可以使用#typst-func("str.slice")#ref-bookmark[`method:slice`\ `of str`]函数截取字节偏移量从`start`到`end`的子串：
 
 #code(```typ
-#repr("我 们 俩".slice(0, 11)), 
+#repr("我 们 俩".slice(0, 11)),
 #repr("我 们 俩".slice(4, 8)),
 ```)
 
 `end`参数可以省略：#ref-bookmark[`param:end`\ of `str.slice`]
 
 #code(```typ
-#repr("我 们 俩".slice(0)), 
+#repr("我 们 俩".slice(0)),
 #repr("我 们 俩".slice(4)),
 ```)
 
@@ -752,20 +752,20 @@ Typst的字符串是#term("utf-8 encoding")的字节序列。#ref-bookmark[`type
 你可以使用#typst-func("str.split")#ref-bookmark[`method:split`\ `of str`]函数将一个字符串依照空白字符拆分：
 
 #code(```typ
-#"我 们仨".split(), 
+#"我 们仨".split(),
 ```)
 
 #glue-block[
   #ref-method-signature("str.rev")
-  
+
   你可以使用#typst-func("str.rev")#ref-bookmark[`method:rev`\ `of str`]函数将一个字符串逆转：
-  
+
   #code(```typ
   #"abcdedfg".rev()
   ```)
-  
+
   逆转时Typst会为你考虑#term("grapheme cluster")。
-  
+
   #code(```typ
   #"ãb".rev()
   ```)

src/basic/scripting-length-and-layout.typ

@@ -58,9 +58,11 @@ Typst会将你提供的任意长度单位都统一成点单位，以便进行长
     columns: 5,
     "",
     ..("pt", "mm", "cm", "in").map(e => raw("=?" + e)),
-    ..units.map(((l, u)) => {
-      (raw("1" + u, lang: "typc"),) + methods.map(method => [#calc.round(method(l), digits: 2)])
-    }).flatten(),
+    ..units
+      .map(((l, u)) => {
+          (raw("1" + u, lang: "typc"),) + methods.map(method => [#calc.round(method(l), digits: 2)])
+        })
+      .flatten(),
   )
 }
 

src/basic/scripting-literal-and-variable.typ

@@ -296,11 +296,11 @@ Typst中所有字符串都是`utf-8`编码的，因此使用时不存在编码
   #int(12 / 4)
   ```)
 
-  或有可能产生「截断」。
+  或有可能产生「截断」。（todo: typst v0.12.0已经不适用）
 
-  #code(```typ
-  #int(9000000000000000000000000000000)
-  ```)
+  // #code(```typ
+  // #int(9000000000000000000000000000000)
+  // ```)
 
 这些都是编程语言中的共通问题。凡是令数字保持有效精度，都会产生如上问题。
 

src/book.typ

@@ -25,17 +25,14 @@
     - #chapter("basic/scripting-length-and-layout.typ")[度量与布局]
     - #chapter("basic/scripting-color-and-shape.typ")[色彩与图表]
     = 基础教程 — 脚本Ⅱ
-    - #chapter("basic/modulize-modules.typ")[模块化]
-      - #chapter("basic/modulize-modules.typ")[文件与模块]
-      - #chapter("basic/modulize-packages.typ")[使用外部库]
-      - #chapter("basic/modulize-multi-files-doc.typ")[多文件文档]
-    // 5. 状态化排版
-    // - 状态
-    // - 计数器
-    - #chapter("basic/modulize-modules.typ")[状态化]
-      - #chapter("intermediate/content-stateful.typ")[维护和查询文档状态]
-      - #chapter("intermediate/content-stateful-2.typ")[查询文档状态 -- 制作页眉标题法一]
-      - #chapter("intermediate/content-stateful-3.typ")[维护文档状态 -- 制作页眉标题法二]
+    - #chapter("intermediate/modulize-modules.typ")[模块化]
+    - #chapter("intermediate/modulize-packages.typ")[外部库]
+    - #chapter("intermediate/modulize-multi-files.typ")[多文件]
+    - #chapter("intermediate/content-stateful-2.typ")[计数器]
+    - #chapter("intermediate/content-stateful.typ")[状态化]
+    // - #chapter("intermediate/content-stateful.typ")[维护和查询文档状态]
+    // - #chapter("intermediate/content-stateful-2.typ")[查询文档状态 -- 制作页眉标题法一]
+    // - #chapter("intermediate/content-stateful-3.typ")[维护文档状态 -- 制作页眉标题法二]
     = 基础教程 — 附录Ⅰ
     - #chapter("basic/reference-grammar.typ")[语法示例检索表]
     - #chapter("basic/reference-utils.typ")[常用函数表]

src/graph/solid-geometry.typ

@@ -46,10 +46,16 @@
 
 #let 六面体 = {
   import draw: *
-  let neg(u) = if u == 0 { 1 } else { -1 }
+  let neg(u) = if u == 0 {
+    1
+  } else {
+    -1
+  }
   for (p, c) in (
-    ((0, 0, 0), black), ((1, 1, 0), red),
-    ((1, 0, 1), blue), ((0, 1, 1), green),
+    ((0, 0, 0), black),
+    ((1, 1, 0), red),
+    ((1, 0, 1), blue),
+    ((0, 1, 1), green),
   ) {
     line(vector.add(p, (0, 0, neg(p.at(2)))), p, stroke: c)
     line(vector.add(p, (0, neg(p.at(1)), 0)), p, stroke: c)
@@ -59,35 +65,41 @@
 
 运行以下代码你将获得：
 
-#code(```typ
-#import "@preview/cetz:0.2.0": *
-#align(center, canvas(六面体))
-```, scope: (六面体: 六面体))
+#code(
+  ```typ
+  #import "@preview/cetz:0.2.0": *
+  #align(center, canvas(六面体))
+  ```,
+  scope: (六面体: 六面体),
+)
 
 #pagebreak(weak: true)
 
 == 六面体
 
-#code(```typ
-#import "@preview/cetz:0.2.0": *
-#align(center, canvas({
-  import draw: *
-  set-viewport((0, 0, 0), (4, 4, -4), bounds: (1, 1, 1))
-  group(name: "S", translate((0, 0, 0)) + {
-    anchor("O", (0, 0, 0))
-    六面体
-  })
-  group(name: "T", translate((1.4, 0, 0)) + scale(x: 120%, y: 80%) + {
-    line((0, 0, 0.5), (0.5, 0, 0), stroke: black)
-    anchor("A", (0, 0, 0.5))
-    anchor("B", (0.5, 0, 0))
-    六面体
-  })
-  circle("S.O", fill: black, radius: 0.05 / 4)
-  content((rel: (-0.08, 0.04, 0), to: "S.O"), [O])
-  circle("T.A", fill: black, radius: 0.05 / 4)
-  content((rel: (0.02, -0.08, 0), to: "T.A"), [A])
-  circle("T.B", fill: black, radius: 0.05 / 4)
-  content((rel: (0, 0.1, 0), to: "T.B"), [B])
-}))
-```, scope: (六面体: 六面体))
+#code(
+  ```typ
+  #import "@preview/cetz:0.2.0": *
+  #align(center, canvas({
+    import draw: *
+    set-viewport((0, 0, 0), (4, 4, -4), bounds: (1, 1, 1))
+    group(name: "S", translate((0, 0, 0)) + {
+      anchor("O", (0, 0, 0))
+      六面体
+    })
+    group(name: "T", translate((1.4, 0, 0)) + scale(x: 120%, y: 80%) + {
+      line((0, 0, 0.5), (0.5, 0, 0), stroke: black)
+      anchor("A", (0, 0, 0.5))
+      anchor("B", (0.5, 0, 0))
+      六面体
+    })
+    circle("S.O", fill: black, radius: 0.05 / 4)
+    content((rel: (-0.08, 0.04, 0), to: "S.O"), [O])
+    circle("T.A", fill: black, radius: 0.05 / 4)
+    content((rel: (0.02, -0.08, 0), to: "T.A"), [A])
+    circle("T.B", fill: black, radius: 0.05 / 4)
+    content((rel: (0, 0.1, 0), to: "T.B"), [B])
+  }))
+  ```,
+  scope: (六面体: 六面体),
+)

src/intermediate/mod.typ

@@ -9,9 +9,15 @@
   eval(it.text, mode: "markup", scope: scope)
 }
 #let exec-code(it, scope: (:), res: none, ..args) = _exec-code(
-  it, res: eval-local(it, scope, res),  ..args)
+  it,
+  res: eval-local(it, scope, res),
+  ..args,
+)
 #let code(it, scope: (:), res: none, ..args) = _code(
-  it, res: eval-local(it, scope, res), ..args)
+  it,
+  res: eval-local(it, scope, res),
+  ..args,
+)
 
 #let frames(code, cjk-fonts: false, code-as: none, prelude: none) = {
 

src/basic/modulize-modules.typ → src/intermediate/modulize-modules.typ

@@ -2,31 +2,34 @@
 
 #show: book.page.with(title: "模块")
 
-正如我们在《基础文档》中所说的，Typst为我们提供了脚本的便捷性。但是事实上，不写或少写脚本便能完成排版才是最大的便捷。无论我们会不会自己用脚本解决某个问题，我们总是希望Typst能够允许我们以一种优雅的方式#strike[复制粘贴]引入这些代码。理想情况下，当某位前辈为我们准备好了模板，我们可以只用两行代码便可完成排版的配置：
+正如我们在《基础文档》中所说的，Typst提供了脚本语言方便排版。但事实上，若是能少写甚至不写脚本，便能完成排版，这才算便捷之至。我们总希望Typst能够允许我们以一种优雅的方式#strike[复制粘贴]引入已有代码。理想情况下，当某位前辈为我们准备好了模板，我们可以只用两行代码便可完成排版的配置：
 
 #```typ
 #import "@preview/senpai-no-awesome-template.typ:0.x.x": *
 #show: template.with(..)
 ```
 
-模块便是为此而诞生的。Typst的模块（module）机制非常简单：每个文件都是一个模块并可以被导入。Typst模块将允许你：
+模块便是为复制而生。Typst的模块（module）机制非常简单：每个文件都是一个独立的模块。它允许你：
 + 在本地工作区内，在多个文档之间共享你爱用的排版函数。
 + 将一份文档分作多个文件编写。
 + 通过本地注册或网络共享，使用外部模板或库。
 
-本节将告诉你有关Typst的模块机制的一切。由于Typst的模块机制过于简单，本节将不会涉及很多需要理解的地方。故而，本节主要伴随讲解一些日常使用模块机制时所遇到的问题。
+本节主要伴随讲解一些日常使用模块机制时所遇到的问题。由于Typst的模块机制过于简单，本节将不会涉及很多需要理解的地方。
 
 == 根目录
 
-根目录的概念是Typst自0.1.0开始就引入的。
-+ 当你使用`typst-cli`程序时，根目录默认为你文件的父目录。你也可以通过`--root`命令行参数手动指定一个根目录。例如你可以指定当前工作目录的父文件夹作为编译程序的根目录：
+根目录的概念是Typst自0.1.0开始就引入的。根目录是一个重要的编译参数。在早期，Typst就禁止访问*根目录以外的内容*。尽管扩大可访问的文件数量在某种程度上增进了便捷性，也意味着降低了执行Typst脚本的安全性。这是因为，根目录下所有的子文件夹和子文件都有机会被*你编写的或其他人编写（外部库）的Typst脚本访问*。
 
-  ```bash
-  typst c --root ..
-  ```
-+ 当你使用VSCode的tinymist或typst-preview程序时，为了方便多文件的编写，根目录默认为你所打开的文件夹。如果你打开一个VSCode工作区，则根目录相对于离你所编辑文件最近的工作目录。
+简单来说，文档一般可以访问文档所在目录的资源。如果需要访问文档所在目录以外其他资源，则需要配置*根目录*。有的时候，你所使用的工具会为你自动配置*根目录*。
+
+#pro-tip[
+  + 当你使用`typst-cli`程序时，根目录默认为文档所在目录。你也可以通过`--root`命令行参数手动指定一个根目录。例如你可以指定当前工作目录的父文件夹作为编译程序的根目录：
 
-在早期，Typst就禁止访问*根目录以外的内容*。尽管扩大可访问的文件数量在某种程度上增进了便捷性，也意味着降低了执行Typst脚本的安全性。这是因为，根目录下所有的子文件夹和子文件都有机会被*你编写的或其他人编写（外部库）的Typst脚本访问*。
+    ```bash
+    typst c --root ..
+    ```
+  + 当你使用VSCode的tinymist或typst-preview程序时，为了方便多文件的编写，根目录默认为你所打开的文件夹。如果你打开一个VSCode工作区，则根目录相对于离你所编辑文件最近的工作目录。
+]
 
 一个常见的错误做法是，为了共享本地代码或模板，在使用`typst-cli`的时候将根目录指定为系统的根目录。
 - 如果你是Windows用户，则以下使用方法将有可能导致个人隐私泄露：