- name: variants
title: Variants
category: math
path: ["math"]
filter: ["serif", "sans", "frak", "mono", "bb", "cal", "scr"]
details: |
Alternate typefaces within formulas.
These functions are distinct from the [`text`] function because math fonts
contain multiple variants of each letter.
- name: styles
title: Styles
category: math
path: ["math"]
filter: ["upright", "italic", "bold"]
details: |
Alternate letterforms within formulas.
These functions are distinct from the [`text`] function because math fonts
contain multiple variants of each letter.
- name: sizes
title: Sizes
category: math
path: ["math"]
filter: ["display", "inline", "script", "sscript"]
details: |
Forced size styles for expressions within formulas.
These functions allow manual configuration of the size of equation elements
to make them look as in a display/inline equation or as if used in a root or
sub/superscripts.
- name: underover
title: Under/Over
category: math
path: ["math"]
filter:
[
"underline",
"overline",
"underbrace",
"overbrace",
"underbracket",
"overbracket",
"underparen",
"overparen",
"undershell",
"overshell",
]
details: |
Delimiters above or below parts of an equation.
The braces and brackets further allow you to add an optional annotation
below or above themselves.
- name: roots
title: Roots
category: math
path: ["math"]
filter: ["root", "sqrt"]
details: |
Square and non-square roots.
# Example
```example
$ sqrt(3 - 2 sqrt(2)) = sqrt(2) - 1 $
$ root(3, x) $
```
- name: attach
title: Attach
category: math
path: ["math"]
filter: ["attach", "scripts", "limits"]
details: |
Subscript, superscripts, and limits.
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.
If you want the base to stretch to fit long top and bottom attachments (for
example, an arrow with text above it), use the [`stretch`]($math.stretch)
function.
# Example
```example
$ sum_(i=0)^n a_i = 2^(1+i) $
```
# Syntax
This function also has dedicated syntax for attachments after the base: Use
the underscore (`_`) to indicate a subscript i.e. bottom attachment and the
hat (`^`) to indicate a superscript i.e. top attachment.
- name: lr
title: Left/Right
category: math
path: ["math"]
filter: ["lr", "mid", "abs", "norm", "floor", "ceil", "round"]
details: |
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.
To prevent a delimiter from being matched by Typst, and thus auto-scaled,
escape it with a backslash. To instead disable auto-scaling completely, use
`{set math.lr(size: 1em)}`.
# Example
```example
$ [a, b/2] $
$ lr(]sum_(x=1)^n], size: #50%) x $
$ abs((x + y) / 2) $
$ \{ (x / y) \} $
#set math.lr(size: 1em)
$ { (a / b), a, b in (0; 1/2] } $
```
- name: calc
title: Calculation
category: foundations
path: ["calc"]
details: |
Module for calculations and processing of numeric values.
These definitions 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`, `tau`, `e`, and `inf`.
- name: std
title: Standard library
category: foundations
path: ["std"]
details: |
A module that contains all globally accessible items.
# Using "shadowed" definitions
The `std` module is useful whenever you overrode a name from the global
scope (this is called _shadowing_). For instance, you might have used the
name `text` for a parameter. To still access the `text` element, write
`std.text`.
```example
>>> #set page(margin: (left: 3em))
#let par = [My special paragraph.]
#let special(text) = {
set std.text(style: "italic")
set std.par.line(numbering: "1")
text
}
#special(par)
#lorem(10)
```
# Conditional access
You can also use this in combination with the [dictionary
constructor]($dictionary) to conditionally access global definitions. This
can, for instance, be useful to use new or experimental functionality when
it is available, while falling back to an alternative implementation if
used on an older Typst version. In particular, this allows us to create
[polyfills](https://en.wikipedia.org/wiki/Polyfill_(programming)).
This can be as simple as creating an alias to prevent warning messages, for
example, conditionally using `pattern` in Typst version 0.12, but using
[`tiling`] in newer versions. Since the parameters accepted by the `tiling`
function match those of the older `pattern` function, using the `tiling`
function when available and falling back to `pattern` otherwise will unify
the usage across all versions. Note that, when creating a polyfill,
[`sys.version`]($category/foundations/sys) can also be very useful.
```typ
#let tiling = if "tiling" in std { tiling } else { pattern }
...
```
- name: sys
title: System
category: foundations
path: ["sys"]
details: |
Module for system interactions.
This module defines the following items:
- The `sys.version` constant (of type [`version`]) that specifies
the currently active Typst compiler version.
- The `sys.inputs` [dictionary], which makes external inputs
available to the project. An input specified in the command line as
`--input key=value` becomes available under `sys.inputs.key` as
`{"value"}`. To include spaces in the value, it may be enclosed with
single or double quotes.
The value is always of type [string]($str). More complex data
may be parsed manually using functions like [`json`]($json).
- name: sym
title: General
category: symbols
path: ["sym"]
details: |
Named general symbols.
For example, `#sym.arrow` produces the → symbol. Within
[formulas]($category/math), these symbols can be used without the `#sym.`
prefix.
The `d` in an integral's `dx` can be written as `[$dif x$]`.
Outside math formulas, `dif` can be accessed as `math.dif`.
- name: emoji
title: Emoji
category: symbols
path: ["emoji"]
details: |
Named emojis.
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.
- name: typed
title: Typed HTML
category: html
path: ["html"]
details: |
A typed layer over raw HTML elements.
The `html` module provides a typed layer over the raw [`html.elem`] function
that allows you to conveniently create HTML elements. HTML attributes are
exposed as function parameters that accept Typst types and automatically
take care of converting those into the appropriate HTML.
Some parameters are common to all typed HTML functions. These are listed at
the bottom in the [Global Attributes](#global-attributes) section instead of
explicitly on each element for readability.
# Example
```typ
#html.video(
controls: true,
width: 1280,
height: 720,
src: "sunrise.mp4",
)[
Your browser does not support the video tag.
]
```