Import documentation

Co-Authored-By: Martin Haug <mhaug@live.de>

7 files changed, 1618 insertions, 0 deletions

diff --git a/docs/src/reference/details.yml b/docs/src/reference/details.yml
new file mode 100644
index 00000000..24389a24
--- /dev/null
+++ b/docs/src/reference/details.yml
@@ -0,0 +1,147 @@
+types: |
+  To style your document, you need to work with values of different kinds: Lengths
+  specifying the size of your elements, colors for your text and shapes, and more.
+  Typst categorizes these into clearly defined _types_ and tells you where it
+  expects which type of value.
+
+  Apart from very basic types for numeric values and typical types known from
+  programming languages, Typst provides a special type for _content._ A value of
+  this type can hold anything that you can enter into your document: Text,
+  elements like headings and shapes, and style information.
+
+  In some places of Typst more specialized data types are used. Instead of listing
+  all of them here, they are explained where they are relevant.
+
+basics: |
+  Basic structural elements of documents.
+
+text: |
+  Style and transform your text.
+
+  The [text function]($func/text) is of particular interest.
+
+math: |
+  Typst has special [syntax]($syntax/#math) and library functions
+  to typeset mathematical formulas. Math formulas can be displayed inline with
+  text or as separate blocks. They will be typeset into their own block if they
+  start and end with at least one space (e.g. `[$ x^2 $]`).
+
+  In math, single letters are always displayed as is. Multiple letters, however,
+  are interpreted as variables and functions. To display multiple letters
+  verbatim, you can place them into quotes and to access single letter
+  variables, you can use the
+  [hashtag syntax]($scripting/#expressions).
+
+  ```example
+  $ A = pi r^2 $
+  $ "area" = pi dot "radius"^2 $
+  $ cal(A) :=
+      { x in RR | x "is natural" } $
+  ```
+
+  Math mode defines a wide selection of [symbols]($category/math/symbols) like
+  `pi`, `dot`, or `RR`. Many mathematical symbols are available in different
+  variants. You can select between different variants by applying
+  [modifiers]($type/symbol) to the symbol. Typst further recognizes a number of
+  shorthand sequences like `=>` that approximate a symbol. When such a shorthand
+  exists, the symbol's documentation lists it.
+
+  ```example
+  $ x < y => x gt.eq.not y $
+  ```
+
+  Formulas can also contain line breaks. Each line can contain one or multiple
+  _alignment points_ (`&`) which are then aligned.
+  ```example
+  $ sum_(x=0)^n
+      &= 1 + ... + n \
+      &= (n(n+1)) / 2 $
+  ```
+
+  Math mode supports special function calls without the hashtag prefix. In these
+  "math calls", the argument list works a little differently than in code:
+
+  - Within them, Typst is still in "math mode". Thus, you can write math directly
+    into them, but need to use hashtag syntax to pass code expressions (except
+    for strings, which are available in the math syntax).
+  - They support positional and named arguments, but don't support
+    trailing content blocks and argument spreading.
+  - They provide additional syntax for 2-dimensional argument lists. The
+    semicolon (`;`) merges preceding arguments separated by commas into an array
+    argument.
+
+  ```example
+  $ frac(a^2, 2) $
+  $ vec(1, 2, delim: "[") $
+  $ mat(1, 2; 3, 4) $
+  $ lim_x =
+      op("lim", limits: #true)_x $
+  ```
+
+  To write a verbatim comma or semicolon in a math call, escape it with a
+  backslash. The colon on the other hand is only recognized in a special way if
+  directly preceded by an identifier, so to display it verbatim in those cases,
+  you can just insert a space before it.
+
+  Functions calls preceded by a hashtag are normal code function calls and not
+  affected by these rules.
+
+layout: |
+  Arrange elements on the page.
+
+  Combine layout functions to create complex and automatic layouts.
+
+visualize: |
+  Draw and visualize data.
+
+  _Note:_ Functions for plotting and diagrams are not yet available. They will
+  be in the future.
+
+meta: |
+  Modify and use document metadata.
+
+  Here, you can also find functions to work with other elements in the document,
+  such as labels and headings.
+
+symbols: |
+  These two modules give names to symbols and emoji to make them easy to insert
+  with a normal keyboard. Alternatively, you can also always directly enter
+  Unicode symbols into your text and formulas. In addition to the symbols listed
+  below, math mode defines `dif` and `Dif`. These are not normal symbol values
+  because they also affect spacing and font style.
+
+sym: |
+  Insert general symbols by name.
+
+  For example, `#sym.arrow` produces the → symbol. Within
+  [formulas]($category/math), these symbols can be used without the `#sym.`
+  prefix.
+
+emoji: |
+  Insert emoji by name.
+
+  For example, `#emoji.face` produces the 😀 emoji. If you frequently use
+  certain emojis, you can also import them from the `emoji` module (`[#import
+  emoji: face]`) to use them without the `#emoji.` prefix.
+
+foundations: |
+  Foundational functions.
+
+calculate: |
+  Calculate with and process numeric values.
+
+  These functions are part of the `calc` module and not imported by default. In
+  addition to the functions listed below, the `calc` module also defines the
+  constants `pi`, `e`, `inf`, and `nan`.
+
+construct: |
+  Construct and convert between values of different types.
+
+data-loading: |
+  Load data from external files.
+
+  These functions help you with embedding data from experiments and APIs in your
+  documents.
+
+utility: |
+  Useful utility functions.
diff --git a/docs/src/reference/groups.yml b/docs/src/reference/groups.yml
new file mode 100644
index 00000000..476a2a26
--- /dev/null
+++ b/docs/src/reference/groups.yml
@@ -0,0 +1,63 @@
+- name: variants
+  title: Variants
+  functions: ["serif", "sans", "frak", "mono", "bb", "cal"]
+  description: |
+    Alternate typefaces within formulas.
+
+    These functions are distinct from the [`text`]($func/text) function because
+    math fonts contain multiple variants of each letter.
+
+- name: styles
+  title: Styles
+  functions: ["upright", "italic", "bold"]
+  description: |
+    Alternate letterforms within formulas.
+
+    These functions are distinct from the [`text`]($func/text) function because
+    math fonts contain multiple variants of each letter.
+
+- name: underover
+  title: Under/Over
+  functions: [
+    "underline",
+    "overline",
+    "underbrace",
+    "overbrace",
+    "underbracket",
+    "overbracket",
+  ]
+  description: |
+    Delimiters above or below parts of a formula.
+
+    The braces and brackets further allow you to add an optional annotation
+    below or above themselves.
+
+- name: roots
+  title: Roots
+  functions: ["root", "sqrt"]
+  description: Square and non-square roots.
+
+- name: attach
+  title: Attach
+  functions: ["attach", "scripts", "limits"]
+  description: |
+    Subscript, superscripts, and limits.
+
+    The `attach` function backs the `[$a_b^c$]` syntax that adds top and bottom
+    attachments to a part of a formula. Attachments can be displayed either as
+    sub/superscripts, or limits. Typst automatically decides which is more
+    suitable depending on the base, but you can also control this manually with
+    the `scripts` and `limits` functions.
+
+- name: lr
+  title: Left/Right
+  functions: ["lr", "abs", "norm", "floor", "ceil"]
+  description: |
+    Delimiter matching.
+
+    The `lr` function allows you to match two delimiters and scale them with the
+    content they contain. While this also happens automatically for delimiters
+    that match syntactically, `lr` allows you to match two arbitrary delimiters
+    and control their size exactly. Apart from the `lr` function, Typst provides
+    a few more functions that create delimiter pairings for absolute, ceiled,
+    and floored values as well as norms.
diff --git a/docs/src/reference/scripting.md b/docs/src/reference/scripting.md
new file mode 100644
index 00000000..6928d22a
--- /dev/null
+++ b/docs/src/reference/scripting.md
@@ -0,0 +1,265 @@
+---
+description: Automate your document with Typst's scripting capabilities.
+---
+
+# Scripting
+Typst embeds a powerful scripting language. You can automate your documents and
+create more sophisticated styles with code. Below is an overview over the
+scripting concepts.
+
+## Expressions { #expressions }
+In Typst, markup and code are fused into one. All but the most common elements
+are created with _functions._ To make this as convenient as possible, Typst
+provides compact syntax to embed a code expression into markup: An expression is
+introduced with a hashtag (`#`) and normal markup parsing resumes after the
+expression is finished. If a character would continue the expression but should
+be interpreted as text, the expression can forcibly be ended with a semicolon
+(`;`).
+
+```example
+#rect[Hello] \
+#emoji.face \
+#"hello".len()
+```
+
+The example above shows a few of the available expressions, including
+[function calls]($type/function),
+[field accesses]($scripting/#fields), and
+[method calls]($scripting/#methods). More kinds of expressions are
+discussed in the remainder of this chapter. A few kinds of expressions are not
+compatible with the hashtag syntax (e.g. binary operator expressions). To embed
+these into markup, you can use parentheses, as in `[#(1 + 2)]`.
+
+## Blocks { #blocks }
+To structure your code and embed markup into it, Typst provides two kinds of
+_blocks:_
+
+- **Code block:** `{{ let x = 1; x + 2 }}` \
+  When writing code, you'll probably want to split up your computation into
+  multiple statements, create some intermediate variables and so on. Code blocks
+  let you write multiple expressions where one is expected. The individual
+  expressions in a code block should be separated by line breaks or semicolons.
+  The output values of the individual expressions in a code block are joined to
+  determine the block's value. Expressions without useful output, like `{let}`
+  bindings yield `{none}`, which can be joined with any value without effect.
+
+- **Content block:** `{[*Hey* there!]}` \
+  With content blocks, you can handle markup/content as a programmatic value,
+  store it in variables and pass it to [functions]($type/function). Content
+  blocks are delimited by square brackets and can contain arbitrary markup. A
+  content block results in a value of type [content]($type/content). An
+  arbitrary number of content blocks can be passed as trailing arguments to
+  functions. That is, `{list([A], [B])}` is equivalent to `{list[A][B]}`.
+
+Content and code blocks can be nested arbitrarily. In the example below,
+`{[hello]}` is joined with the output of  `{a + [ the ] + b}` yielding
+`{[hello from the *world*]}`.
+
+```example
+#{
+  let a = [from]
+  let b = [*world*]
+  [hello ]
+  a + [ the ] + b
+}
+```
+
+## Let bindings { #bindings }
+As already demonstrated above, variables can be defined with `{let}` bindings.
+The variable is assigned the value of the expression that follows the `=` sign.
+The assignment of a value is optional, if no value is assigned, the variable
+will be initialized as `{none}`. The `{let}` keyword can also be used to create
+a [custom named function]($type/function/#definitions). Let bindings can be
+accessed for the rest of the containing block or document.
+
+```example
+#let name = "Typst"
+This is #name's documentation.
+It explains #name.
+
+#let add(x, y) = x + y
+Sum is #add(2, 3).
+```
+
+## Conditionals { #conditionals }
+With a conditional, you can display or compute different things depending on
+whether some condition is fulfilled. Typst supports `{if}`, `{else if}` and
+`{else}` expression. When the condition evaluates to `{true}`, the conditional
+yields the value resulting from the if's body, otherwise yields the value
+resulting from the else's body.
+
+```example
+#if 1 < 2 [
+  This is shown
+] else [
+  This is not.
+]
+```
+
+Each branch can have a code or content block as its body.
+
+- `{if condition {..}}`
+- `{if condition [..]}`
+- `{if condition [..] else {..}}`
+- `{if condition [..] else if condition {..} else [..]}`
+
+## Loops { #loops }
+With loops, you can repeat content or compute something iteratively. Typst
+supports two types of loops: `{for}` and `{while}` loops. The former iterate
+over a specified collection whereas the latter iterate as long as a condition
+stays fulfilled. Just like blocks, loops _join_ the results from each iteration
+into one value.
+
+In the example below, the three sentences created by the for loop join together
+into a single content value and the length-1 arrays in the while loop join
+together into one larger array.
+
+```example
+#for c in "ABC" [
+  #c is a letter.
+]
+
+#let n = 2
+#while n < 10 {
+  n = (n * 2) - 1
+  (n,)
+}
+```
+
+For loops can iterate over a variety of collections:
+
+- `{for letter in "abc" {..}}` \
+  Iterates over the characters of the [string]($type/string).
+  (Technically, iterates over the grapheme clusters of the string. Most of the
+  time, a grapheme cluster is just a single character/codepoint. However, some
+  constructs like flag emojis that consist of multiple codepoints are still only
+  one cluster.)
+
+- `{for value in array {..}}` \
+  `{for index, value in array {..}}`\
+  Iterates over the items in the [array]($type/array). Can also provide the
+  index of each element.
+
+- `{for value in dict {..}}` \
+  `{for key, value in dict {..}}` \
+  Iterates over the values or keys and values of the
+  [dictionary]($type/dictionary).
+
+- `{for value in args {..}}` \
+  `{for name, value in args {..}}` \
+  Iterates over the values or names and values of the
+  [arguments]($type/arguments). For positional arguments, the `name` is
+  `{none}`.
+
+To control the execution of the loop, Typst provides the `{break}` and
+`{continue}` statements. The former performs an early exit from the loop while
+the latter skips ahead to the next iteration of the loop.
+
+```example
+#for letter in "abc nope" {
+  if letter == " " {
+    break
+  }
+
+  letter
+}
+```
+
+The body of a loop can be a code or content block:
+
+- `{for .. in collection {..}}`
+- `{for .. in collection [..]}`
+- `{while condition [..]}`
+- `{while condition [..]}`
+
+## Fields { #fields }
+You can use _dot notation_ to access fields on a value. The value in question
+can be either:
+- a [dictionary]($type/dictionary) that has the specified key,
+- a [symbols]($type/symbol) that has the specified modifier,
+- a [module]($type/module) containing the specified definition,
+- [content]($type/content) that exposes the specified field. Most elements
+  expose some or all of the non-settable arguments passed to them as fields.
+
+```example
+#let dict = (greet: "Hello")
+#dict.greet \
+#emoji.face
+```
+
+## Methods { #methods }
+A method is a kind of a [function]($type/function) that is tightly coupled with
+a specific type. It is called on a value of its type using the same dot notation
+that is also used for fields: `{value.method(..)}`. The
+[type documentation]($type) lists the available methods for each of the built-in
+types. You cannot define your own methods.
+
+```example
+#let array = (1, 2, 3, 4)
+#array.pop() \
+#array.len() \
+
+#("a, b, c"
+    .split(", ")
+    .join[ --- ])
+```
+
+Methods are the only functions in Typst that can modify the value they are
+called on.
+
+## Modules { #modules }
+You can split up your Typst projects into multiple files called _modules._ A
+module can refer to the content and definitions of another module in multiple
+ways:
+
+- **Including:** `{include "bar.typ"}` \
+  Evaluates the file at the path `bar.typ` and returns the resulting
+  [content]($type/content).
+
+- **Import:** `{import "bar.typ"}` \
+  Evaluates the file at the path `bar.typ` and inserts the resulting
+  [module]($type/module) into the current scope as `bar` (filename without
+  extension).
+
+- **Import items:** `{import "bar.typ": a, b}` \
+  Evaluates the file at the path `bar.typ`, extracts the values of the variables
+  `a` and `b` (that need to be defined in `bar.typ`, e.g. through `{let}`
+  bindings) and defines them in the current file.Replacing `a, b` with `*` loads
+  all variables defined in a module.
+
+Instead of a path, you can also use a [module value]($type/module), as shown in
+the following example:
+
+```example
+#import emoji: face
+#face.grin
+```
+
+## Operators { #operators }
+The following table lists all available unary and binary operators with effect,
+arity (unary, binary) and precedence level (higher binds stronger).
+
+| Operator   | Effect                          | Arity  | Precedence |
+|:----------:|---------------------------------|:------:|:----------:|
+|  `{-}`     | Negation                        | Unary  |     7      |
+|  `{+}`     | No effect (exists for symmetry) | Unary  |     7      |
+|  `{*}`     | Multiplication                  | Binary |     6      |
+|  `{/}`     | Division                        | Binary |     6      |
+|  `{+}`     | Addition                        | Binary |     5      |
+|  `{-}`     | Subtraction                     | Binary |     5      |
+|  `{==}`    | Check equality                  | Binary |     4      |
+|  `{!=}`    | Check inequality                | Binary |     4      |
+|  `{<}`     | Check less-than                 | Binary |     4      |
+|  `{<=}`    | Check less-than or equal        | Binary |     4      |
+|  `{>}`     | Check greater-than              | Binary |     4      |
+|  `{>=}`    | Check greater-than or equal     | Binary |     4      |
+|  `{in}`    | Check if in collection          | Binary |     4      |
+| `{not in}` | Check if not in collection      | Binary |     4      |
+|  `{not}`   | Logical "not"                   | Unary  |     3      |
+|  `{and}`   | Short-circuiting logical "and"  | Binary |     3      |
+|  `{or}`    | Short-circuiting logical "or    | Binary |     2      |
+|  `{=}`     | Assignment                      | Binary |     1      |
+|  `{+=}`    | Add-Assignment                  | Binary |     1      |
+|  `{-=}`    | Subtraction-Assignment          | Binary |     1      |
+|  `{*=}`    | Multiplication-Assignment       | Binary |     1      |
+|  `{/=}`    | Division-Assignment             | Binary |     1      |
diff --git a/docs/src/reference/styling.md b/docs/src/reference/styling.md
new file mode 100644
index 00000000..92b5f8c9
--- /dev/null
+++ b/docs/src/reference/styling.md
@@ -0,0 +1,141 @@
+---
+description: All concepts needed to style your document with Typst.
+---
+
+# Styling
+Typst includes a flexible styling system that automatically applies styling of
+your choice to your document. With _set rules,_ you can configure basic
+properties of elements. This way, you create most common styles. However, there
+might not be a built-in property for everything you wish to do. For this reason,
+Typst further supports _show rules_ that can completely redefine the appearance
+of elements.
+
+## Set rules { #set-rules }
+With set rules, you can customize the appearance of elements. They are written
+as a [function call]($type/function) to the respective function preceded by the
+`{set}` keyword (or `[#set]` in markup). Only settable parameters must be
+provided as arguments. Refer to each function's documentation for a list of
+settable parameters. In the example below, we use two set rules to change the
+[font family]($func/text.family) and
+[heading numbering]($func/heading.numbering) style.
+
+```example
+#set text("Latin Modern Roman")
+#set heading(numbering: "I.")
+
+= Introduction
+With set rules, you can style
+your document.
+```
+
+A top level set rule stays in effect until the end of the file. When nested
+inside of a block, it is only in effect until the end of that block. With a
+block, you can thus restrict the effect of a rule to a particular segment of
+your document. Below, we use a content block to scope the list styling to one
+particular list.
+
+```example
+This list is affected:
+#[#set list(marker: [--])
+ - Dash]
+
+This one is not:
+- Bullet
+```
+
+Sometimes, you'll want to apply a set rule conditionally. For this, you can use
+a _set-if_ rule.
+
+```example
+#let task(body, critical: false) = {
+  set text(red) if critical
+  [- #body]
+}
+
+#task(critical: true)[Food today?]
+#task(critical: false)[Work deadline]
+```
+
+## Show rules { #show-rules }
+With show rules, you can deeply customize the look of a type of element. The
+most basic form of show rule is a _show-set rule._ Such a rule is written as the
+`{show}` keyword followed by a function name, a colon and then a set rule. This
+lets the set rule only apply to the selected element. In the example below,
+headings become dark blue while all other text stays black.
+
+```example
+#show heading: set text(navy)
+
+= This is navy-blue
+But this stays black.
+```
+
+With show-set rules you can mix and match properties from different functions to
+achieve many different effects. But they still limit you to what is predefined
+in Typst. For maximum flexibility, you can instead write a show rule that
+defines how to format an element from scratch. To write such a show rule,
+replace the set rule behind the colon with an arbitrary
+[function]($type/function). This functions receives the element in question and
+can return arbitrary content. Different
+[fields]($scripting/#fields) are available on the element passed
+to the function. Below, we define a show rule that formats headings for a
+fantasy encyclopedia.
+
+```example
+#set heading(numbering: "(I)")
+#show heading: it => block[
+  #set align(center)
+  #set text("Inria Serif")
+  \~ _#it.title;_
+      #it.numbers \~
+]
+
+= Dragon
+With a base health of 15, the
+dragon is the most powerful
+creature.
+
+= Manticore
+While less powerful than the
+dragon, the manticore gets
+extra style points.
+```
+
+Like set rules, show rules are in effect until the end of the current block or
+file.
+
+Instead of a function, the right-hand side of a show rule can also take a
+literal string or content block that should be directly substituted for the
+element. And apart from a function, the left-hand side of a show rule can also
+take a number of other _selectors_ that define what to apply the transformation
+to:
+
+- **Everything:** `{show rest => ..}` \
+  Transform everything after the show rule. This is useful to apply a more
+  complex layout to your whole document without wrapping everything in a giant
+  function call.
+
+- **Text:** `{show "Text": ..}` \
+  Style, transform or replace text.
+
+- **Regex:** `{show regex("\w+"): ..}` \
+  Select and transform text with a regular expression for even more flexibility.
+  See the documentation of the [`regex` function]($func/regex) for details.
+
+- **Function with fields:** `{show heading.where(level: 1): ..}` \
+  Transform only elements that have the specified fields. For example, you might
+  want to only change the style of level-1 headings.
+
+- **Label:** `{show <intro>: ..}` \
+  Select and transform elements that have the specified label.
+  See the documentation of the [`label` function]($func/label) for more details.
+
+```example
+#set text("Noto Serif")
+#show "Project": smallcaps
+#show "badly": "great"
+
+We started Project in 2019
+and are still working on it.
+Project is progressing badly.
+```
diff --git a/docs/src/reference/syntax.md b/docs/src/reference/syntax.md
new file mode 100644
index 00000000..b4d14e01
--- /dev/null
+++ b/docs/src/reference/syntax.md
@@ -0,0 +1,136 @@
+---
+description: |
+   A compact reference for Typst's syntax. Learn more about the language within
+   markup, math, and code mode.
+---
+
+# Syntax
+Typst is a markup language. This means that you can use simple syntax to
+accomplish common layout tasks. The lightweight markup syntax is complemented by
+set and show rules, which let you style your document easily and automatically.
+All this is backed by a tightly integrated scripting language with built-in and
+user-defined functions.
+
+## Markup { #markup }
+Typst provides built-in markup for the most common document elements. Most of
+the syntax elements are just shortcuts for a corresponding function. The table
+below lists all markup that is available and links to the  best place to learn
+more about their syntax and usage.
+
+| Name               | Example                  | See                          |
+| ------------------ | ------------------------ | ---------------------------- |
+| Paragraph break    | Blank line               | [`parbreak`]($func/parbreak) |
+| Strong emphasis    | `[*strong*]`             | [`strong`]($func/strong)     |
+| Emphasis           | `[_emphasis_]`           | [`emph`]($func/emph)         |
+| Raw text           | ``[`print(1)`]``         | [`raw`]($func/raw)           |
+| Link               | `[https://typst.app/]`   | [`link`]($func/link)         |
+| Label              | `[<intro>]`              | [`label`]($func/label)       |
+| Reference          | `[@intro]`               | [`ref`]($func/ref)           |
+| Heading            | `[= Heading]`            | [`heading`]($func/heading)   |
+| Bullet list        | `[- item]`               | [`list`]($func/list)         |
+| Numbered list      | `[+ item]`               | [`enum`]($func/enum)         |
+| Term list          | `[/ Term: description]`  | [`terms`]($func/terms)       |
+| Math               | `[$x^2$]`                | [Math]($category/math)     |
+| Line break         | `[\]`                    | [`linebreak`]($func/linebreak) |
+| Smart quote        | `['single' or "double"]` | [`smartquote`]($func/smartquote) |
+| Symbol shorthand   | `[~, ---]`               | [Symbols]($category/symbols/sym) |
+| Code expression    | `[#rect(width: 1cm)]`    | [Scripting]($scripting/#expressions) |
+| Character escape   | `[Tweet at us \#ad]`     | [Below](#escapes)            |
+| Comment            | `[/* block */, // line]` | [Below](#comments)           |
+
+## Math mode { #math }
+Math mode is a special markup mode that is used to typeset mathematical
+formulas. It is entered by wrapping a formula in `[$]` characters. The formula
+will be typeset into its own block if it starts and ends with at least one space
+(e.g. `[$ x^2 $]`). Inline math can be produced by omitting the whitespace (e.g.
+`[$x^2$]`). An overview over the syntax specific to math mode follows:
+
+| Name                   | Example                  | See                      |
+| ---------------------- | ------------------------ | ------------------------ |
+| Inline math            | `[$x^2$]`                | [Math]($category/math)   |
+| Block-level math       | `[$ x^2 $]`              | [Math]($category/math)   |
+| Bottom attachment      | `[$x_1$]`                | [`attach`]($category/math/attach) |
+| Top attachment         | `[$x^2$]`                | [`attach`]($category/math/attach) |
+| Fraction               | `[$1 + (a+b)/5$]`        | [`frac`]($func/frac)     |
+| Line break             | `[$x \ y ]`              | [`linebreak`]($func/linebreak) |
+| Alignment point        | `[$x &= 2 \ &= 3$]`      | [Math]($category/math)   |
+| Variable access        | `[$pi$]`                 | [Math]($category/math)   |
+| Field access           | `[$arrow.r.long$]`       | [Scripting]($scripting/#fields) |
+| Implied multiplication | `[$x y$]`                | [Math]($category/math)   |
+| Symbol shorthand       | `[$->, !=$]`             | [Symbols]($category/symbols/sym) |
+| Text/string in math    | `[$a "is natural"$]`     | [Math]($category/math)   |
+| Math function call     | `[$floor(x)$]`           | [Math]($category/math)   |
+| Code expression        | `[$#rect(width: 1cm)$]`  | [Scripting]($scripting/#expressions) |
+| Character escape       | `[$x\^2$]`               | [Below](#escapes)        |
+| Comment                | `[$/* comment */$]`      | [Below](#comments)       |
+
+## Code mode { #code }
+Within code blocks and expressions, new expressions can start without a leading
+`#` character. Many syntactic elements are specific to expressions. Below is
+a table listing all syntax that is available in code mode:
+
+| Name                     | Example                       | See                                                  |
+| ------------------------ | ----------------------------- | ---------------------------------------------------- |
+| Variable access          | `{x}`                         | [Scripting]($scripting/#blocks)       |
+| Any literal              | `{1pt, "hey"}`                | [Types]($types)                       |
+| Code block               | `{{ let x = 1; x + 2 }}`      | [Scripting]($scripting/#blocks)       |
+| Content block            | `{[*Hello*]}`                 | [Scripting]($scripting/#blocks)       |
+| Parenthesized expression | `{(1 + 2)}`                   | [Scripting]($scripting/#blocks)       |
+| Array                    | `{(1, 2, 3)}`                 | [Array]($type/array)                 |
+| Dictionary               | `{(a: "hi", b: 2)}`           | [Dictionary]($type/dictionary)       |
+| Unary operator           | `{-x}`                        | [Scripting]($scripting/#operators)    |
+| Binary operator          | `{x + y}`                     | [Scripting]($scripting/#operators)    |
+| Assignment               | `{x = 1}`                     | [Scripting]($scripting/#operators)    |
+| Field access             | `{x.y}`                       | [Scripting]($scripting/#fields)       |
+| Method call              | `{x.flatten()}`               | [Scripting]($scripting/#methods)      |
+| Function call            | `{min(x, y)}`                 | [Function]($type/function)           |
+| Unnamed function         | `{(x, y) => x + y}`           | [Function]($type/function)           |
+| Let binding              | `{let x = 1}`                 | [Scripting]($scripting/#bindings)     |
+| Named function           | `{let f(x) = 2 * x}`          | [Function]($type/function)           |
+| Set rule                 | `{set text(14pt)}`            | [Styling]($styling/#set-rules)        |
+| Set-if rule              | `{set text(..) if .. }`       | [Styling]($styling/#set-rules)        |
+| Show rule                | `{show raw: it => {..}}`      | [Styling]($styling/#set-rules)        |
+| Show-set rule            | `{show par: set block(..)}`   | [Styling]($styling/#show-rules)       |
+| Conditional              | `{if x == 1 {..} else {..}}`  | [Scripting]($scripting/#conditionals) |
+| For loop                 | `{for x in (1, 2, 3) {..}}`   | [Scripting]($scripting/#loops)        |
+| While loop               | `{while x < 10 {..}}`         | [Scripting]($scripting/#loops)        |
+| Loop control flow        | `{break, continue}`           | [Scripting]($scripting/#loops)        |
+| Return from function     | `{return x}`                  | [Function]($type/function)           |
+| Include module           | `{include "bar.typ"}`         | [Scripting]($scripting/#modules)      |
+| Import module            | `{import "bar.typ"}`          | [Scripting]($scripting/#modules)      |
+| Import items from module | `{import "bar.typ": a, b, c}` | [Scripting]($scripting/#modules)      |
+| Comment                  | `[/* block */, // line]`      | [Below](#comments)                                   |
+
+## Comments { #comments }
+Comments are ignored by Typst and will not be included in the output. This
+is useful to exclude old versions or to add annotations.
+To comment out a single line, start it with `//`:
+```example
+// our data barely supports
+// this claim
+
+We show with $p < 0.05$
+that the difference is
+significant.
+```
+
+Comments can also be wrapped between `/*` and `*/`. In this case, the comment
+can span over multiple lines:
+```example
+Our study design is as follows:
+/* Somebody write this up:
+   - 1000 participants.
+   - 2x2 data design. */
+```
+
+## Escape sequences { #escapes }
+Escape sequences are used to insert special characters that are otherwise have
+special meaning in Typst. To escape a character, precede it with a backslash. To
+insert any Unicode codepoint, you can write a hexadecimal escape sequence:
+`[\u{1f600}]`. The same kind of escape sequences also work in
+[strings]($type/string).
+
+```example
+I got an ice cream for
+\$1.50! \u{1f600}
+```
diff --git a/docs/src/reference/types.md b/docs/src/reference/types.md
new file mode 100644
index 00000000..744e1abd
--- /dev/null
+++ b/docs/src/reference/types.md
@@ -0,0 +1,837 @@
+# None
+A type that indicates the absence of any other value.
+
+The none type has exactly one value: `{none}`.
+
+When inserted into the document, it is not visible.
+This is also the value that is produced by empty code blocks.
+It can be [joined]($scripting/#blocks) with any value, yielding
+the other value.
+
+## Example
+```example
+Not visible: #none
+```
+
+# Auto
+A type that indicates a smart default.
+
+The auto type has exactly one value: `{auto}`.
+
+Parameters that support the `{auto}` value have some smart default or contextual
+behaviour. A good example is the [text direction]($func/text.dir) parameter.
+Setting it to `{auto}` lets Typst automatically determine the direction from the
+[text language]($func/text.lang).
+
+# Boolean
+A value with two states.
+
+The boolean type has two values: `{true}` and `{false}`. It denotes whether
+something is active or enabled.
+
+## Example
+```example
+#false \
+#true \
+#(1 < 2)
+```
+
+# Integer
+A whole number.
+
+The number can be negative, zero, or positive. As Typst uses 64 bits to store
+integers, integers cannot be smaller than `{-9223372036854775808}` or larger than
+`{9223372036854775807}`.
+
+## Example
+```example
+#(1 + 2) \
+#(2 - 5) \
+#(3 + 4 < 8)
+```
+
+# Float
+A floating-pointer number.
+
+A limited-precision representation of a real number. Typst uses 64 bits to
+store floats. Wherever a float is expected, you can also pass an
+[integer]($type/integer).
+
+## Example
+```example
+#3.14 \
+#1e4 \
+#(10 / 4)
+```
+
+# Length
+A size or distance, possibly expressed with contextual units.
+Typst supports the following length units:
+
+- Points: `{72pt}`
+- Millimeters: `{254mm}`
+- Centimeters: `{2.54cm}`
+- Inches: `{1in}`
+- Relative to font size: `{2.5em}`
+
+## Example
+```example
+#rect(width: 20pt) \
+#rect(width: 2em) \
+#rect(width: 1in)
+```
+
+# Angle
+An angle describing a rotation.
+Typst supports the following angular units:
+
+- Degrees: `{180deg}`
+- Radians: `{3.14rad}`
+
+## Example
+```example
+#rotate(10deg)[Hello there!]
+```
+
+# Ratio
+A ratio of a whole.
+
+Written as a number, followed by a percent sign.
+
+## Example
+```example
+#set align(center)
+#scale(x: 150%)[
+  Scaled apart.
+]
+```
+
+# Relative Length
+A length in relation to some known length.
+
+This type is a combination of a [length]($type/length) with a
+[ratio]($type/ratio). It results from addition and subtraction
+of a length and a ratio. Wherever a relative length is expected, you can also
+use a bare length or ratio.
+
+## Example
+```example
+#rect(width: 100% - 50pt)
+```
+
+# Fraction
+Defines how the the remaining space in a layout is distributed.
+
+Each fractionally sized element gets space based on the ratio of its fraction to
+the sum of all fractions.
+
+For more details, also see the [h]($func/h) and [v]($func/v) functions and the
+[grid function]($func/grid).
+
+## Example
+```example
+Left #h(1fr) Left-ish #h(2fr) Right
+```
+
+# Color
+A color in a specific color space.
+
+Typst supports:
+- sRGB through the [`rgb` function]($func/rgb)
+- Device CMYK through [`cmyk` function]($func/cmyk)
+- D65 Gray through the [`luma` function]($func/luma)
+
+Furthermore, Typst provides the following built-in colors:
+
+`black`, `gray`, `silver`, `white`, `navy`, `blue`, `aqua`, `teal`, `eastern`,
+`purple`, `fuchsia`, `maroon`, `red`, `orange`, `yellow`, `olive`, `green`, and
+`lime`.
+
+## Methods
+### lighten()
+Lightens a color.
+
+- amount: ratio (positional, required)
+  The factor to lighten the color by.
+
+### darken()
+Darkens a color.
+
+- amount: ratio (positional, required)
+  The factor to darken the color by.
+
+### negate()
+Produces the negative of the color.
+
+# Symbol
+A Unicode symbol.
+
+Typst defines common symbols so that they can easily be written with standard
+keyboards. The symbols are defined in modules, from which they can be accessed
+using [field access notation]($scripting/#fields):
+
+- General symbols are defined in the [`sym` module]($category/symbols/sym)
+- Emoji are defined in the [`emoji` module]($category/symbols/emoji)
+
+Moreover, you can define custom symbols with the [symbol]($func/symbol)
+function.
+
+```example
+#sym.arrow.r \
+#sym.gt.eq.not \
+$gt.eq.not$ \
+#emoji.face.halo
+```
+
+Many symbols have different variants, which can be selected by appending the
+modifiers with dot notation. The order of the modifiers is not relevant. Visit
+the documentation pages of the symbol modules and click on a symbol to see its
+available variants.
+
+```example
+$arrow.l$ \
+$arrow.r$ \
+$arrow.t.quad$
+```
+
+# String
+A sequence of Unicode codepoints.
+
+You can iterate over the characters (or rather, grapheme clusters) of the string
+using a [for loop]($scripting/#loops). Strings can be added with
+the `+` operator, [joined together]($scripting/#blocks) and
+multiplied with integers.
+
+Typst provides utility methods for string manipulation. Many of these methods
+(e.g., `split`, `trim` and `replace`) operate on _patterns:_ A pattern can be
+either a string or a [regular expression]($func/regex). This makes the methods
+quite versatile.
+
+_Note:_ Currently all lengths and indices are expressed in terms of UTF-8 bytes.
+This _might_ change to grapheme clusters in the future.
+
+### Example
+```example
+#"hello world!" \
+#"\"hello\n  world\"!" \
+#"1 2 3".split() \
+#"1,2;3".split(regex("[,;]")) \
+#(regex("\d+") in "ten euros") \
+#(regex("\d+") in "10 euros")
+```
+
+### Escape sequences
+Just like in markup, you can escape a few symbols in strings:
+- `[\\]` for a backslash
+- `[\"]` for a quote
+- `[\n]` for a newline
+- `[\r]` for a carriage return
+- `[\t]` for a tab
+- `[\u{1f600}]` for a hexadecimal Unicode escape sequence
+
+## Methods
+### len()
+The length of the string in UTF-8 encoded bytes.
+
+- returns: integer
+
+### first()
+Extract the first character (or rather, grapheme cluster) of the string.
+Fails with an error if the string is empty.
+
+- returns: any
+
+### last()
+Extract the last character (or rather, grapheme cluster) of the string.
+Fails with an error if the string is empty.
+
+- returns: any
+
+### at()
+Extract the first character (or rather, grapheme cluster) after the specified
+index. Fails with an error if the index is out of bounds.
+
+- index: integer (positional, required)
+  The byte index.
+- returns: string
+
+### slice()
+Extract a substring of the string.
+Fails with an error if the start or end index is out of bounds.
+
+- start: integer (positional, required)
+  The start byte index (inclusive).
+- end: integer (positional)
+  The end byte index (exclusive). If omitted, the whole slice until the end of the
+  string is extracted.
+- count: integer (named)
+  The number of bytes to extract. This is equivalent to passing `start + count`
+  as the `end` position. Mutually exclusive with `end`.
+- returns: string
+
+### contains()
+Whether the string contains the specified pattern.
+
+This method also has dedicated syntax: You can write `{"bc" in "abcd"}` instead
+of `{"abcd".contains("bc")}`.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- returns: boolean
+
+### starts-with()
+Whether the string starts with the specified pattern.
+
+- pattern: string or regex (positional, required)
+  The pattern the string might start with.
+- returns: boolean
+
+### ends-with()
+Whether the string ends with the specified pattern.
+
+- pattern: string or regex (positional, required)
+  The pattern the string might end with.
+- returns: boolean
+
+### find()
+Searches for the specified pattern in the string and returns the first match
+as a string or `{none}` if there is no match.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- returns: string or none
+
+### position()
+Searches for the specified pattern in the string and returns the index of the
+first match as an integer or `{none}` if there is no match.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- returns: integer or none
+
+### match()
+Searches for the specified pattern in the string and returns a dictionary
+with details about the first match or `{none}` if there is no match.
+
+The returned dictionary has the following keys:
+* `start`: The start offset of the match
+* `end`: The end offset of the match
+* `text`: The text that matched.
+* `captures`: An array containing a string for each matched capturing group. The
+  first item of the array contains the first matched capturing, not the whole
+  match! This is empty unless the `pattern` was a regex with capturing groups.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- returns: dictionary or none
+
+### matches()
+Searches for the specified pattern in the string and returns an array of
+dictionaries with details about all matches. For details about the returned
+dictionaries, see above.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- returns: array
+
+### replace()
+Replaces all or a specified number of matches of a pattern with a replacement
+string and returns the resulting string.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- replacement: string (positional, required)
+  The string to replace the matches with.
+- count: integer (named)
+  If given, only the first `count` matches of the pattern are placed.
+- returns: string
+
+### trim()
+Removes matches of a pattern from one or both sides of the string, once or
+repeatedly and returns the resulting string.
+
+- pattern: string or regex (positional, required)
+  The pattern to search for.
+- at: alignment (named)
+  Can be `start` or `end` to only trim the start or end of the string.
+  If omitted, both sides are trimmed.
+- repeat: boolean (named)
+  Whether to repeatedly removes matches of the pattern or just once.
+  Defaults to `{true}`.
+- returns: string
+
+### split()
+Splits a string at matches of a specified pattern and returns an array of
+the resulting parts.
+
+- pattern: string or regex (positional)
+  The pattern to split at. Defaults to whitespace.
+- returns: array
+
+# Content
+Representation of text, elements, and more.
+
+This type is at the heart of Typst. All markup you write and most
+[functions]($type/function) you call produce content values. You
+can create a content value by enclosing markup in square brackets. This is also
+how you pass content to functions. Typst does not allow you to peek into
+content, but you can affect its appearance in various ways using set and show
+rules. See the chapter on [styling]($styling) for more details.
+
+```example
+#type([*Hello!*]) \
+#strong[Hello!]
+```
+
+Content can be added with the `+` operator,
+[joined together]($scripting/#blocks) and multiplied with
+integers. Wherever content is expected, you can also pass a
+[string]($type/string) or `{none}`.
+
+### Reactivity
+Content is reactive to the styles that are active where it is inserted.
+When you write a set or show rule, content that was _created_ before the show
+rule is stilled affected by the show rule if it is _inserted_ after the show
+rule.
+
+```example
+// Content is created here.
+#let mytext = [= A heading]
+
+// But still affected by the
+// styles that are active here.
+#show heading: set text(green)
+#mytext
+```
+
+# Array
+A sequence of values.
+
+You can construct an array by enclosing a comma-separated sequence of values
+in parentheses. The values do not have to be of the same type.
+
+You can access and update array elements with the `.at()` method. Indices are
+zero-based and negative indices wrap around to the end of the array. You can
+iterate over an array using a [for loop]($scripting/#loops).
+Arrays can be added together with the `+` operator,
+[joined together]($scripting/#blocks) and multiplied with
+integers.
+
+Empty parenthesis yield an array of length zero and a parentheses-wrapped value
+with trailing comma yields an array of length one.
+
+## Example
+```example
+#let values = (1, 7, 4, -3, 2)
+
+#values.at(0) \
+#(values.at(0) = 3)
+#values.at(-1) \
+#values.find(calc.even) \
+#values.filter(calc.odd) \
+#values.map(calc.abs) \
+#values.rev() \
+#(1, (2, 3)).flatten() \
+#(("A", "B", "C")
+    .join(", ", last: " and "))
+```
+
+## Methods
+### len()
+The number of values in the array.
+
+- returns: integer
+
+### first()
+Returns the first element in the array.
+May be used on the left-hand side of an assignment.
+Fails with an error if the array is empty.
+
+- returns: any
+
+### last()
+Returns the last element in the array.
+May be used on the left-hand side of an assignment.
+Fails with an error if the array is empty.
+
+- returns: any
+
+### at()
+Returns the element at the specified index in the array.
+May be used on the left-hand side of an assignment.
+Fails with an error if the index is out of bounds.
+
+- index: integer (positional, required)
+  The index at which to retrieve the element.
+- returns: any
+
+### push()
+Add a value to the end of the array.
+
+- value: any (positional, required)
+  The value to insert at the end of the array.
+
+### pop()
+Remove the last element from the array and return it.
+Fails with an error if the array is empty.
+
+- returns: any
+  The removed last value.
+
+### insert()
+Insert a value into the array at the specified index.
+Fails with an error if the index is out of bounds.
+
+- index: integer (positional, required)
+  The index at which to insert the element.
+- value: any (positional, required)
+  The value to insert into the array.
+
+### remove()
+Remove the value at the specified index from the array and return it.
+
+- index: integer (positional, required)
+  The index at which to remove the element.
+- returns: any
+
+### slice()
+Extract a subslice of the array.
+Fails with an error if the start or index is out of bounds.
+
+- start: integer (positional, required)
+  The start index (inclusive).
+- end: integer (positional)
+  The end index (exclusive). If omitted, the whole slice until the end of the
+  array is extracted.
+- count: integer (named)
+  The number of elements to extract. This is equivalent to passing `start +
+  count` as the `end` position. Mutually exclusive with `end`.
+- returns: array
+
+### contains()
+Whether the array contains the specified value.
+
+This method also has dedicated syntax: You can write `{2 in (1, 2, 3)}` instead
+of `{(1, 2, 3).contains(2)}`.
+
+- value: any (positional, required)
+  The value to search for.
+- returns: boolean
+
+### find()
+Searches for an element for which the given function returns `{true}` and
+returns the first match or `{none}` if there is no match.
+
+- searcher: function (positional, required)
+  The function to apply to each element. Must return a boolean.
+- returns: any or none
+
+### position()
+Searches for an element for which the given function returns `{true}` and
+returns the index of the first match or `{none}` if there is no match.
+
+- searcher: function (positional, required)
+  The function to apply to each element. Must return a boolean.
+- returns: integer or none
+
+### filter()
+Produces a new array with only the elements from the original one for which the
+given function returns true.
+
+- test: function (positional, required)
+  The function to apply to each element. Must return a boolean.
+- returns: array
+
+### map()
+Produces a new array in which all elements from the original one were
+transformed with the given function.
+
+- mapper: function (positional, required)
+  The function to apply to each element.
+- returns: array
+
+### fold()
+Folds all elements into a single value using an accumulator function.
+
+- init: any (positional, required)
+  The initial value to start with.
+- folder: function (positional, required)
+  The folding function. Must have two parameters: One for the accumulated value
+  and one for an element.
+- returns: any
+
+### any()
+Whether the given function returns `{true}` for any element in the array.
+
+- test: function (positional, required)
+  The function to apply to each element. Must return a boolean.
+- returns: boolean
+
+### all()
+Whether the given function returns `{true}` for all elements in the array.
+
+- test: function (positional, required)
+  The function to apply to each element. Must return a boolean.
+- returns: boolean
+
+### flatten()
+Combine all nested arrays into a single flat one.
+
+- returns: array
+
+### rev()
+Return a new array with the same elements, but in reverse order.
+
+- returns: array
+
+### join()
+Combine all elements in the array into one.
+
+- separator: any (positional)
+  A value to insert between each element of the array.
+- last: any (named)
+  An alternative separator between the last two elements
+- returns: any
+
+### sorted()
+Return a new array with the same elements, but sorted.
+
+- returns: array
+
+# Dictionary
+A map from string keys to values.
+
+You can construct a dictionary by enclosing comma-separated `key: value` pairs
+in parentheses. The values do not have to be of the same type.
+
+A dictionary is conceptually similar to an array, but it is indexed by strings
+instead of integers. You can access and create dictionary entries with the
+`.at()` method. If you know the key statically, you can alternatively use
+[field access notation]($scripting/#fields) (`.key`) to access
+the value. Dictionaries can be added with the `+` operator and
+[joined together]($scripting/#blocks).
+
+You can iterate over the pairs in a dictionary using a
+[for loop]($scripting/#loops).
+Dictionaries are always ordered by key.
+
+Since empty parentheses already yield an empty array, you have to use the
+special `(:)` syntax to create an empty dictionary.
+
+
+## Example
+```example
+#let dict = (
+  name: "Typst",
+  born: 2019,
+)
+
+#dict.name \
+#(dict.launch = 20)
+#dict.len() \
+#dict.keys() \
+#dict.values() \
+#dict.at("born") \
+#dict.insert("city", "Berlin ")
+```
+
+## Methods
+### len()
+The number of pairs in the dictionary.
+
+- returns: integer
+
+### at()
+Returns the value associated with the specified key in the dictionary.
+May be used on the left-hand side of an assignment if the key is already
+present in the dictionary.
+Fails with an error if the key is not part of the dictionary.
+
+- index: integer (positional, required)
+  The index at which to retrieve the element.
+- returns: any
+
+### insert()
+Insert a new pair into the dictionary and return the value.
+
+- key: string (positional, required)
+  The key of the pair that should be inserted.
+- value: any (positional, required)
+  The value of the pair that should be inserted.
+
+### keys()
+Returns the keys of the dictionary as an array in sorted order.
+
+- returns: array
+
+### values()
+Returns the values of the dictionary as an array in key-order.
+
+- returns: array
+
+### pairs()
+Call a function for each key-value pair and return the results in an array.
+
+- mapper: function (positional, required)
+  The function to apply to each pair. Gets passed the key and value as two
+  separate arguments.
+- returns: array
+
+### remove()
+Remove a pair from the dictionary by key and return the value.
+
+- key: string (positional, required)
+  The key of the pair that should be removed.
+- returns: any
+
+# Function
+A mapping from argument values to a return value.
+
+You can call a function by writing a comma-separated list of function
+_arguments_ enclosed in parentheses directly after the function name.
+Additionally, you can pass any number of trailing content blocks arguments to a
+function _after_ the normal argument list. If the normal argument list would
+become empty, it can be omitted. Typst supports positional and named arguments.
+The former are identified by position and type, while the later are written as
+`name: value`.
+
+Within math mode, function calls have special behaviour. See the
+[math documentation]($category/math) for more details.
+
+### Example
+```example
+// Call a function.
+#list([A], [B])
+
+// Named arguments and trailing
+// content blocks.
+#enum(start: 2)[A][B]
+
+// Version without parentheses.
+#list[A][B]
+```
+
+Functions are a fundamental building block of Typst. Typst provides functions
+for a variety of typesetting tasks. Moreover, the markup you write is backed by
+functions and all styling happens through functions. This reference lists all
+available functions and how you can use them. Please also refer to the
+documentation about [set]($styling/#set-rules) and
+[show]($styling/#show-rules) rules to learn about additional ways
+you can work with functions in Typst.
+
+### Defining functions { #definitions }
+You can define your own function with a
+[let binding]($scripting/#bindings) that has a parameter list after
+the binding's name. The parameter list can contain positional parameters,
+named parameters with default values and
+[argument sinks]($type/arguments).
+The right-hand side of the binding can be a block or any other expression. It
+defines the function's return value and can depend on the parameters.
+
+```example
+#let alert(body, fill: red) = {
+  set text(white)
+  set align(center)
+  rect(
+    fill: fill,
+    inset: 8pt,
+    radius: 4pt,
+    [*Warning:\ #body*],
+  )
+}
+
+#alert[
+  Danger is imminent!
+]
+
+#alert(fill: blue)[
+  KEEP OFF TRACKS
+]
+```
+
+### Unnamed functions { #unnamed }
+You can also created an unnamed function without creating a binding by
+specifying a parameter list followed by `=>` and the function body. If your
+function has just one parameter, the parentheses around the parameter list are
+optional. Unnamed functions are mainly useful for show rules, but also for
+settable properties that take functions like the page function's
+[`footer`]($func/page.footer) property.
+
+```example
+#show "once?": it => [#it #it]
+once?
+```
+
+### Notable fact
+In Typst, all functions are _pure._ This means that for the same
+arguments, they always return the same result. They cannot "remember" things to
+produce another value when they are called a second time.
+
+## Methods
+### with()
+Returns a new function that has the given arguments pre-applied.
+
+- arguments: any (variadic)
+  The named and positional arguments to apply.
+- returns: function
+
+### where()
+Returns a selector that filters for elements belonging to this function
+whose fields have the values of the given arguments.
+
+- fields: any (named, variadic)
+  The field values to filter by.
+- returns: selector
+
+# Arguments
+Captured arguments to a function.
+
+Like built-in functions, custom functions can also take a variable number of
+arguments. You can specify an _argument sink_ which collects all excess
+arguments as `..sink`. The resulting `sink` value is of the `arguments` type. It
+exposes methods to access the positional and named arguments and is iterable
+with a [for loop]($scripting/#loops). Inversely, you can spread
+arguments, arrays and dictionaries into a function call with the spread operator:
+`{func(..args)}`.
+
+## Example
+```example
+#let format(title, ..authors) = [
+  *{title}* \
+  _Written by {authors
+    .pos()
+    .join(", ", last: " and ")}._
+]
+
+#format("ArtosFlow", "Jane", "Joe")
+```
+
+## Methods
+### pos()
+Returns the captured positional arguments as an array.
+
+- returns: array
+
+### named()
+Returns the captured named arguments as a dictionary.
+
+- returns: dictionary
+
+# Module
+An evaluated module, either built-in or resulting from a file.
+
+You can access definitions from the module using
+[field access notation]($scripting/#fields) and interact with it using the
+[import and include syntaxes]($scripting/#modules).
+
+## Example
+```example
+<<< #import "utils.typ"
+<<< #utils.add(2, 5)
+
+<<< #import utils: sub
+<<< #sub(1, 4)
+>>> #7
+>>>
+>>> #(-3)
+```
diff --git a/docs/src/reference/welcome.md b/docs/src/reference/welcome.md
new file mode 100644
index 00000000..dc38663d
--- /dev/null
+++ b/docs/src/reference/welcome.md
@@ -0,0 +1,29 @@
+---
+description: |
+  The Typst reference is a systematic and comprehensive guide to the Typst
+  typesetting language.
+---
+
+# Reference
+This reference documentation is a comprehensive guide to all of Typst's
+syntax, concepts, types, and functions. If you are completely new to Typst, we
+recommend starting with the [tutorial]($tutorial) and then coming back to
+the reference to learn more about Typst's features as you need them.
+
+## Language
+The reference starts with a language part that gives an overview over [Typst's
+syntax]($syntax) and contains information about concepts involved in
+[styling documents,]($styling) using
+[Typst's scripting capabilities,]($scripting) and a detailed documentation of
+all [data types]($types) in Typst.
+
+## Functions
+The second part includes chapters on all functions used to insert, style, transform,
+and layout content in Typst documents. Each function is documented with a
+description of its purpose, a list of its parameters, and examples of how to use
+it.
+
+The final part of the reference explains all functions that are used within
+Typst's code mode to manipulate and transform data. Just as in the previous
+part, each function is documented with a description of its purpose, a list of
+its parameters, and examples of how to use it.