Version bump

Cargo.lock

@@ -2735,7 +2735,7 @@ checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
 
 [[package]]
 name = "typst"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "comemo",
  "ecow",
@@ -2752,12 +2752,13 @@ dependencies = [
 
 [[package]]
 name = "typst-assets"
-version = "0.12.0"
+version = "0.13.0"
-source = "git+https://github.com/typst/typst-assets?rev=8cccef9#8cccef93b5da73a1c80389722cf2b655b624f577"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1051c56bbbf74d31ea6c6b1661e62fa0ebb8104403ee53f6dcd321600426e0b6"
 
 [[package]]
 name = "typst-cli"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "chrono",
  "clap",
@@ -2802,12 +2803,12 @@ dependencies = [
 
 [[package]]
 name = "typst-dev-assets"
-version = "0.12.0"
+version = "0.13.0"
-source = "git+https://github.com/typst/typst-dev-assets?rev=7f8999d#7f8999d19907cd6e1148b295efbc844921c0761c"
+source = "git+https://github.com/typst/typst-dev-assets?tag=v0.13.0#61aebe9575a5abff889f76d73c7b01dc8e17e340"
 
 [[package]]
 name = "typst-docs"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "clap",
  "ecow",
@@ -2830,7 +2831,7 @@ dependencies = [
 
 [[package]]
 name = "typst-eval"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "comemo",
  "ecow",
@@ -2848,7 +2849,7 @@ dependencies = [
 
 [[package]]
 name = "typst-fuzz"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "comemo",
  "libfuzzer-sys",
@@ -2860,7 +2861,7 @@ dependencies = [
 
 [[package]]
 name = "typst-html"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "comemo",
  "ecow",
@@ -2874,7 +2875,7 @@ dependencies = [
 
 [[package]]
 name = "typst-ide"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "comemo",
  "ecow",
@@ -2891,7 +2892,7 @@ dependencies = [
 
 [[package]]
 name = "typst-kit"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "dirs",
  "ecow",
@@ -2901,6 +2902,8 @@ dependencies = [
  "native-tls",
  "once_cell",
  "openssl",
+ "serde",
+ "serde_json",
  "tar",
  "typst-assets",
  "typst-library",
@@ -2912,7 +2915,7 @@ dependencies = [
 
 [[package]]
 name = "typst-layout"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "az",
  "bumpalo",
@@ -2942,7 +2945,7 @@ dependencies = [
 
 [[package]]
 name = "typst-library"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "az",
  "bitflags 2.8.0",
@@ -2964,6 +2967,7 @@ dependencies = [
  "kamadak-exif",
  "kurbo",
  "lipsum",
+ "memchr",
  "palette",
  "phf",
  "png",
@@ -3001,7 +3005,7 @@ dependencies = [
 
 [[package]]
 name = "typst-macros"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -3011,7 +3015,7 @@ dependencies = [
 
 [[package]]
 name = "typst-pdf"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "arrayvec",
  "base64",
@@ -3037,7 +3041,7 @@ dependencies = [
 
 [[package]]
 name = "typst-realize"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "arrayvec",
  "bumpalo",
@@ -3053,7 +3057,7 @@ dependencies = [
 
 [[package]]
 name = "typst-render"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "bytemuck",
  "comemo",
@@ -3069,7 +3073,7 @@ dependencies = [
 
 [[package]]
 name = "typst-svg"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "base64",
  "comemo",
@@ -3087,7 +3091,7 @@ dependencies = [
 
 [[package]]
 name = "typst-syntax"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "ecow",
  "serde",
@@ -3103,7 +3107,7 @@ dependencies = [
 
 [[package]]
 name = "typst-tests"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "clap",
  "comemo",
@@ -3128,7 +3132,7 @@ dependencies = [
 
 [[package]]
 name = "typst-timing"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "parking_lot",
  "serde",
@@ -3138,7 +3142,7 @@ dependencies = [
 
 [[package]]
 name = "typst-utils"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "once_cell",
  "portable-atomic",

Cargo.toml

@@ -4,7 +4,7 @@ default-members = ["crates/typst-cli"]
 resolver = "2"
 
 [workspace.package]
-version = "0.12.0"
+version = "0.13.0"
 rust-version = "1.80" # also change in ci.yml
 authors = ["The Typst Project Developers"]
 edition = "2021"
@@ -16,24 +16,24 @@ keywords = ["typst"]
 readme = "README.md"
 
 [workspace.dependencies]
-typst = { path = "crates/typst", version = "0.12.0" }
+typst = { path = "crates/typst", version = "0.13.0" }
-typst-cli = { path = "crates/typst-cli", version = "0.12.0" }
+typst-cli = { path = "crates/typst-cli", version = "0.13.0" }
-typst-eval = { path = "crates/typst-eval", version = "0.12.0" }
+typst-eval = { path = "crates/typst-eval", version = "0.13.0" }
-typst-html = { path = "crates/typst-html", version = "0.12.0" }
+typst-html = { path = "crates/typst-html", version = "0.13.0" }
-typst-ide = { path = "crates/typst-ide", version = "0.12.0" }
+typst-ide = { path = "crates/typst-ide", version = "0.13.0" }
-typst-kit = { path = "crates/typst-kit", version = "0.12.0" }
+typst-kit = { path = "crates/typst-kit", version = "0.13.0" }
-typst-layout = { path = "crates/typst-layout", version = "0.12.0" }
+typst-layout = { path = "crates/typst-layout", version = "0.13.0" }
-typst-library = { path = "crates/typst-library", version = "0.12.0" }
+typst-library = { path = "crates/typst-library", version = "0.13.0" }
-typst-macros = { path = "crates/typst-macros", version = "0.12.0" }
+typst-macros = { path = "crates/typst-macros", version = "0.13.0" }
-typst-pdf = { path = "crates/typst-pdf", version = "0.12.0" }
+typst-pdf = { path = "crates/typst-pdf", version = "0.13.0" }
-typst-realize = { path = "crates/typst-realize", version = "0.12.0" }
+typst-realize = { path = "crates/typst-realize", version = "0.13.0" }
-typst-render = { path = "crates/typst-render", version = "0.12.0" }
+typst-render = { path = "crates/typst-render", version = "0.13.0" }
-typst-svg = { path = "crates/typst-svg", version = "0.12.0" }
+typst-svg = { path = "crates/typst-svg", version = "0.13.0" }
-typst-syntax = { path = "crates/typst-syntax", version = "0.12.0" }
+typst-syntax = { path = "crates/typst-syntax", version = "0.13.0" }
-typst-timing = { path = "crates/typst-timing", version = "0.12.0" }
+typst-timing = { path = "crates/typst-timing", version = "0.13.0" }
-typst-utils = { path = "crates/typst-utils", version = "0.12.0" }
+typst-utils = { path = "crates/typst-utils", version = "0.13.0" }
-typst-assets = { git = "https://github.com/typst/typst-assets", rev = "8cccef9" }
+typst-assets = "0.13.0"
-typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "7f8999d" }
+typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", tag = "v0.13.0" }
 arrayvec = "0.7.4"
 az = "1.2"
 base64 = "0.22"
@@ -73,6 +73,7 @@ kamadak-exif = "0.6"
 kurbo = "0.11"
 libfuzzer-sys = "0.4"
 lipsum = "0.9"
+memchr = "2"
 miniz_oxide = "0.8"
 native-tls = "0.2"
 notify = "8"

crates/typst-cli/src/compile.rs

@@ -6,8 +6,9 @@ use std::path::{Path, PathBuf};
 use chrono::{DateTime, Datelike, Timelike, Utc};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::term;
-use ecow::{eco_format, EcoString};
+use ecow::eco_format;
 use parking_lot::RwLock;
+use pathdiff::diff_paths;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use typst::diag::{
     bail, At, Severity, SourceDiagnostic, SourceResult, StrResult, Warned,
@@ -188,7 +189,7 @@ pub fn compile_once(
 
     match output {
         // Export the PDF / PNG.
-        Ok(()) => {
+        Ok(outputs) => {
             let duration = start.elapsed();
 
             if config.watching {
@@ -202,7 +203,7 @@ pub fn compile_once(
             print_diagnostics(world, &[], &warnings, config.diagnostic_format)
                 .map_err(|err| eco_format!("failed to print diagnostics ({err})"))?;
 
-            write_make_deps(world, config)?;
+            write_make_deps(world, config, outputs)?;
             open_output(config)?;
         }
 
@@ -226,12 +227,15 @@ pub fn compile_once(
 fn compile_and_export(
     world: &mut SystemWorld,
     config: &mut CompileConfig,
-) -> Warned<SourceResult<()>> {
+) -> Warned<SourceResult<Vec<Output>>> {
     match config.output_format {
         OutputFormat::Html => {
             let Warned { output, warnings } = typst::compile::<HtmlDocument>(world);
             let result = output.and_then(|document| export_html(&document, config));
-            Warned { output: result, warnings }
+            Warned {
+                output: result.map(|()| vec![config.output.clone()]),
+                warnings,
+            }
         }
         _ => {
             let Warned { output, warnings } = typst::compile::<PagedDocument>(world);
@@ -257,9 +261,14 @@ fn export_html(document: &HtmlDocument, config: &CompileConfig) -> SourceResult<
 }
 
 /// Export to a paged target format.
-fn export_paged(document: &PagedDocument, config: &CompileConfig) -> SourceResult<()> {
+fn export_paged(
+    document: &PagedDocument,
+    config: &CompileConfig,
+) -> SourceResult<Vec<Output>> {
     match config.output_format {
-        OutputFormat::Pdf => export_pdf(document, config),
+        OutputFormat::Pdf => {
+            export_pdf(document, config).map(|()| vec![config.output.clone()])
+        }
         OutputFormat::Png => {
             export_image(document, config, ImageExportFormat::Png).at(Span::detached())
         }
@@ -327,7 +336,7 @@ fn export_image(
     document: &PagedDocument,
     config: &CompileConfig,
     fmt: ImageExportFormat,
-) -> StrResult<()> {
+) -> StrResult<Vec<Output>> {
     // Determine whether we have indexable templates in output
     let can_handle_multiple = match config.output {
         Output::Stdout => false,
@@ -383,7 +392,7 @@ fn export_image(
                         && config.export_cache.is_cached(*i, &page.frame)
                         && path.exists()
                     {
-                        return Ok(());
+                        return Ok(Output::Path(path.to_path_buf()));
                     }
 
                     Output::Path(path.to_owned())
@@ -392,11 +401,9 @@ fn export_image(
             };
 
             export_image_page(config, page, &output, fmt)?;
-            Ok(())
+            Ok(output)
         })
-        .collect::<Result<Vec<()>, EcoString>>()?;
+        .collect::<StrResult<Vec<Output>>>()
-
-    Ok(())
 }
 
 mod output_template {
@@ -501,14 +508,25 @@ impl ExportCache {
 /// Writes a Makefile rule describing the relationship between the output and
 /// its dependencies to the path specified by the --make-deps argument, if it
 /// was provided.
-fn write_make_deps(world: &mut SystemWorld, config: &CompileConfig) -> StrResult<()> {
+fn write_make_deps(
+    world: &mut SystemWorld,
+    config: &CompileConfig,
+    outputs: Vec<Output>,
+) -> StrResult<()> {
     let Some(ref make_deps_path) = config.make_deps else { return Ok(()) };
-    let Output::Path(output_path) = &config.output else {
+    let Ok(output_paths) = outputs
-        bail!("failed to create make dependencies file because output was stdout")
+        .into_iter()
-    };
+        .filter_map(|o| match o {
-    let Some(output_path) = output_path.as_os_str().to_str() else {
+            Output::Path(path) => Some(path.into_os_string().into_string()),
+            Output::Stdout => None,
+        })
+        .collect::<Result<Vec<_>, _>>()
+    else {
         bail!("failed to create make dependencies file because output path was not valid unicode")
     };
+    if output_paths.is_empty() {
+        bail!("failed to create make dependencies file because output was stdout")
+    }
 
     // Based on `munge` in libcpp/mkdeps.cc from the GCC source code. This isn't
     // perfect as some special characters can't be escaped.
@@ -522,6 +540,10 @@ fn write_make_deps(world: &mut SystemWorld, config: &CompileConfig) -> StrResult
                     res.push('$');
                     slashes = 0;
                 }
+                ':' => {
+                    res.push('\\');
+                    slashes = 0;
+                }
                 ' ' | '\t' => {
                     // `munge`'s source contains a comment here that says: "A
                     // space or tab preceded by 2N+1 backslashes represents N
@@ -544,18 +566,29 @@ fn write_make_deps(world: &mut SystemWorld, config: &CompileConfig) -> StrResult
 
     fn write(
         make_deps_path: &Path,
-        output_path: &str,
+        output_paths: Vec<String>,
         root: PathBuf,
         dependencies: impl Iterator<Item = PathBuf>,
     ) -> io::Result<()> {
         let mut file = File::create(make_deps_path)?;
+        let current_dir = std::env::current_dir()?;
+        let relative_root = diff_paths(&root, &current_dir).unwrap_or(root.clone());
 
-        file.write_all(munge(output_path).as_bytes())?;
+        for (i, output_path) in output_paths.into_iter().enumerate() {
+            if i != 0 {
+                file.write_all(b" ")?;
+            }
+            file.write_all(munge(&output_path).as_bytes())?;
+        }
         file.write_all(b":")?;
         for dependency in dependencies {
-            let Some(dependency) =
+            let relative_dependency = match dependency.strip_prefix(&root) {
-                dependency.strip_prefix(&root).unwrap_or(&dependency).to_str()
+                Ok(root_relative_dependency) => {
-            else {
+                    relative_root.join(root_relative_dependency)
+                }
+                Err(_) => dependency,
+            };
+            let Some(relative_dependency) = relative_dependency.to_str() else {
                 // Silently skip paths that aren't valid unicode so we still
                 // produce a rule that will work for the other paths that can be
                 // processed.
@@ -563,14 +596,14 @@ fn write_make_deps(world: &mut SystemWorld, config: &CompileConfig) -> StrResult
             };
 
             file.write_all(b" ")?;
-            file.write_all(munge(dependency).as_bytes())?;
+            file.write_all(munge(relative_dependency).as_bytes())?;
         }
         file.write_all(b"\n")?;
 
         Ok(())
     }
 
-    write(make_deps_path, output_path, world.root().to_owned(), world.dependencies())
+    write(make_deps_path, output_paths, world.root().to_owned(), world.dependencies())
         .map_err(|err| {
             eco_format!("failed to create make dependencies file due to IO error ({err})")
         })

crates/typst-eval/src/code.rs

@@ -55,7 +55,7 @@ fn eval_code<'a>(
             _ => expr.eval(vm)?,
         };
 
-        output = ops::join(output, value).at(span)?;
+        output = ops::join(output, value, &mut (&mut vm.engine, span)).at(span)?;
 
         if let Some(event) = &vm.flow {
             warn_for_discarded_content(&mut vm.engine, event, &output);

crates/typst-eval/src/flow.rs

@@ -83,7 +83,8 @@ impl Eval for ast::WhileLoop<'_> {
             }
 
             let value = body.eval(vm)?;
-            output = ops::join(output, value).at(body.span())?;
+            let span = body.span();
+            output = ops::join(output, value, &mut (&mut vm.engine, span)).at(span)?;
 
             match vm.flow {
                 Some(FlowEvent::Break(_)) => {
@@ -129,7 +130,9 @@ impl Eval for ast::ForLoop<'_> {
 
                     let body = self.body();
                     let value = body.eval(vm)?;
-                    output = ops::join(output, value).at(body.span())?;
+                    let span = body.span();
+                    output =
+                        ops::join(output, value, &mut (&mut vm.engine, span)).at(span)?;
 
                     match vm.flow {
                         Some(FlowEvent::Break(_)) => {

crates/typst-eval/src/import.rs

@@ -44,11 +44,10 @@ impl Eval for ast::ModuleImport<'_> {
         }
 
         // If there is a rename, import the source itself under that name.
-        let bare_name = self.bare_name();
         let new_name = self.new_name();
         if let Some(new_name) = new_name {
-            if let Ok(source_name) = &bare_name {
+            if let ast::Expr::Ident(ident) = self.source() {
-                if source_name == new_name.as_str() {
+                if ident.as_str() == new_name.as_str() {
                     // Warn on `import x as x`
                     vm.engine.sink.warn(warning!(
                         new_name.span(),
@@ -57,6 +56,7 @@ impl Eval for ast::ModuleImport<'_> {
                 }
             }
 
+            // Define renamed module on the scope.
             vm.define(new_name, source.clone());
         }
 

crates/typst-eval/src/ops.rs

@@ -1,4 +1,4 @@
-use typst_library::diag::{At, HintedStrResult, SourceResult};
+use typst_library::diag::{At, DeprecationSink, HintedStrResult, SourceResult};
 use typst_library::foundations::{ops, IntoValue, Value};
 use typst_syntax::ast::{self, AstNode};
 
@@ -23,22 +23,22 @@ impl Eval for ast::Binary<'_> {
 
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         match self.op() {
-            ast::BinOp::Add => apply_binary(self, vm, ops::add),
+            ast::BinOp::Add => apply_binary_with_sink(self, vm, ops::add),
             ast::BinOp::Sub => apply_binary(self, vm, ops::sub),
             ast::BinOp::Mul => apply_binary(self, vm, ops::mul),
             ast::BinOp::Div => apply_binary(self, vm, ops::div),
             ast::BinOp::And => apply_binary(self, vm, ops::and),
             ast::BinOp::Or => apply_binary(self, vm, ops::or),
-            ast::BinOp::Eq => apply_binary(self, vm, ops::eq),
+            ast::BinOp::Eq => apply_binary_with_sink(self, vm, ops::eq),
-            ast::BinOp::Neq => apply_binary(self, vm, ops::neq),
+            ast::BinOp::Neq => apply_binary_with_sink(self, vm, ops::neq),
             ast::BinOp::Lt => apply_binary(self, vm, ops::lt),
             ast::BinOp::Leq => apply_binary(self, vm, ops::leq),
             ast::BinOp::Gt => apply_binary(self, vm, ops::gt),
             ast::BinOp::Geq => apply_binary(self, vm, ops::geq),
-            ast::BinOp::In => apply_binary(self, vm, ops::in_),
+            ast::BinOp::In => apply_binary_with_sink(self, vm, ops::in_),
-            ast::BinOp::NotIn => apply_binary(self, vm, ops::not_in),
+            ast::BinOp::NotIn => apply_binary_with_sink(self, vm, ops::not_in),
             ast::BinOp::Assign => apply_assignment(self, vm, |_, b| Ok(b)),
-            ast::BinOp::AddAssign => apply_assignment(self, vm, ops::add),
+            ast::BinOp::AddAssign => apply_assignment_with_sink(self, vm, ops::add),
             ast::BinOp::SubAssign => apply_assignment(self, vm, ops::sub),
             ast::BinOp::MulAssign => apply_assignment(self, vm, ops::mul),
             ast::BinOp::DivAssign => apply_assignment(self, vm, ops::div),
@@ -65,6 +65,18 @@ fn apply_binary(
     op(lhs, rhs).at(binary.span())
 }
 
+/// Apply a basic binary operation, with the possiblity of deprecations.
+fn apply_binary_with_sink(
+    binary: ast::Binary,
+    vm: &mut Vm,
+    op: impl Fn(Value, Value, &mut dyn DeprecationSink) -> HintedStrResult<Value>,
+) -> SourceResult<Value> {
+    let span = binary.span();
+    let lhs = binary.lhs().eval(vm)?;
+    let rhs = binary.rhs().eval(vm)?;
+    op(lhs, rhs, &mut (&mut vm.engine, span)).at(span)
+}
+
 /// Apply an assignment operation.
 fn apply_assignment(
     binary: ast::Binary,
@@ -89,3 +101,23 @@ fn apply_assignment(
     *location = op(lhs, rhs).at(binary.span())?;
     Ok(Value::None)
 }
+
+/// Apply an assignment operation, with the possiblity of deprecations.
+fn apply_assignment_with_sink(
+    binary: ast::Binary,
+    vm: &mut Vm,
+    op: fn(Value, Value, &mut dyn DeprecationSink) -> HintedStrResult<Value>,
+) -> SourceResult<Value> {
+    let rhs = binary.rhs().eval(vm)?;
+    let location = binary.lhs().access(vm)?;
+    let lhs = std::mem::take(&mut *location);
+    let mut sink = vec![];
+    let span = binary.span();
+    *location = op(lhs, rhs, &mut (&mut sink, span)).at(span)?;
+    if !sink.is_empty() {
+        for warning in sink {
+            vm.engine.sink.warn(warning);
+        }
+    }
+    Ok(Value::None)
+}

crates/typst-ide/src/complete.rs

@@ -306,7 +306,10 @@ fn complete_math(ctx: &mut CompletionContext) -> bool {
     }
 
     // Behind existing atom or identifier: "$a|$" or "$abc|$".
-    if matches!(ctx.leaf.kind(), SyntaxKind::Text | SyntaxKind::MathIdent) {
+    if matches!(
+        ctx.leaf.kind(),
+        SyntaxKind::Text | SyntaxKind::MathText | SyntaxKind::MathIdent
+    ) {
         ctx.from = ctx.leaf.offset();
         math_completions(ctx);
         return true;
@@ -358,7 +361,7 @@ fn complete_field_accesses(ctx: &mut CompletionContext) -> bool {
     // Behind an expression plus dot: "emoji.|".
     if_chain! {
         if ctx.leaf.kind() == SyntaxKind::Dot
-            || (ctx.leaf.kind() == SyntaxKind::Text
+            || (matches!(ctx.leaf.kind(), SyntaxKind::Text | SyntaxKind::MathText)
                 && ctx.leaf.text() == ".");
         if ctx.leaf.range().end == ctx.cursor;
         if let Some(prev) = ctx.leaf.prev_sibling();
@@ -398,7 +401,17 @@ fn field_access_completions(
     value: &Value,
     styles: &Option<Styles>,
 ) {
-    for (name, binding) in value.ty().scope().iter() {
+    let scopes = {
+        let ty = value.ty().scope();
+        let elem = match value {
+            Value::Content(content) => Some(content.elem().scope()),
+            _ => None,
+        };
+        elem.into_iter().chain(Some(ty))
+    };
+
+    // Autocomplete methods from the element's or type's scope.
+    for (name, binding) in scopes.flat_map(|scope| scope.iter()) {
         ctx.call_completion(name.clone(), binding.read());
     }
 
@@ -1747,4 +1760,25 @@ mod tests {
             .must_include(["this", "that"])
             .must_exclude(["*", "figure"]);
     }
+
+    #[test]
+    fn test_autocomplete_type_methods() {
+        test("#\"hello\".", -1).must_include(["len", "contains"]);
+    }
+
+    #[test]
+    fn test_autocomplete_content_methods() {
+        test("#show outline.entry: it => it.\n#outline()\n= Hi", 30)
+            .must_include(["indented", "body", "page"]);
+    }
+
+    #[test]
+    fn test_autocomplete_symbol_variants() {
+        test("#sym.arrow.", -1)
+            .must_include(["r", "dashed"])
+            .must_exclude(["cases"]);
+        test("$ arrow. $", -3)
+            .must_include(["r", "dashed"])
+            .must_exclude(["cases"]);
+    }
 }

crates/typst-ide/src/jump.rs

@@ -73,7 +73,10 @@ pub fn jump_from_click(
                         let Some(id) = span.id() else { continue };
                         let source = world.source(id).ok()?;
                         let node = source.find(span)?;
-                        let pos = if node.kind() == SyntaxKind::Text {
+                        let pos = if matches!(
+                            node.kind(),
+                            SyntaxKind::Text | SyntaxKind::MathText
+                        ) {
                             let range = node.range();
                             let mut offset = range.start + usize::from(span_offset);
                             if (click.x - pos.x) > width / 2.0 {
@@ -115,7 +118,7 @@ pub fn jump_from_cursor(
     cursor: usize,
 ) -> Vec<Position> {
     fn is_text(node: &LinkedNode) -> bool {
-        node.get().kind() == SyntaxKind::Text
+        matches!(node.kind(), SyntaxKind::Text | SyntaxKind::MathText)
     }
 
     let root = LinkedNode::new(source.root());
@@ -261,6 +264,11 @@ mod tests {
         test_click(s, point(21.0, 12.0), cursor(56));
     }
 
+    #[test]
+    fn test_jump_from_click_math() {
+        test_click("$a + b$", point(28.0, 14.0), cursor(5));
+    }
+
     #[test]
     fn test_jump_from_cursor() {
         let s = "*Hello* #box[ABC] World";
@@ -268,6 +276,11 @@ mod tests {
         test_cursor(s, 14, pos(1, 37.55, 16.58));
     }
 
+    #[test]
+    fn test_jump_from_cursor_math() {
+        test_cursor("$a + b$", -3, pos(1, 27.51, 16.83));
+    }
+
     #[test]
     fn test_backlink() {
         let s = "#footnote[Hi]";

crates/typst-kit/Cargo.toml

@@ -23,6 +23,8 @@ flate2 = { workspace = true, optional = true }
 fontdb = { workspace = true, optional = true }
 native-tls = { workspace = true, optional = true }
 once_cell = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
 tar = { workspace = true, optional = true }
 ureq = { workspace = true, optional = true }
 

crates/typst-kit/src/package.rs

@@ -5,10 +5,9 @@ use std::path::{Path, PathBuf};
 
 use ecow::eco_format;
 use once_cell::sync::OnceCell;
+use serde::Deserialize;
 use typst_library::diag::{bail, PackageError, PackageResult, StrResult};
-use typst_syntax::package::{
+use typst_syntax::package::{PackageSpec, PackageVersion, VersionlessPackageSpec};
-    PackageInfo, PackageSpec, PackageVersion, VersionlessPackageSpec,
-};
 
 use crate::download::{Downloader, Progress};
 
@@ -32,7 +31,7 @@ pub struct PackageStorage {
     /// The downloader used for fetching the index and packages.
     downloader: Downloader,
     /// The cached index of the default namespace.
-    index: OnceCell<Vec<PackageInfo>>,
+    index: OnceCell<Vec<serde_json::Value>>,
 }
 
 impl PackageStorage {
@@ -42,6 +41,18 @@ impl PackageStorage {
         package_cache_path: Option<PathBuf>,
         package_path: Option<PathBuf>,
         downloader: Downloader,
+    ) -> Self {
+        Self::with_index(package_cache_path, package_path, downloader, OnceCell::new())
+    }
+
+    /// Creates a new package storage with a pre-defined index.
+    ///
+    /// Useful for testing.
+    fn with_index(
+        package_cache_path: Option<PathBuf>,
+        package_path: Option<PathBuf>,
+        downloader: Downloader,
+        index: OnceCell<Vec<serde_json::Value>>,
     ) -> Self {
         Self {
             package_cache_path: package_cache_path.or_else(|| {
@@ -51,7 +62,7 @@ impl PackageStorage {
                 dirs::data_dir().map(|data_dir| data_dir.join(DEFAULT_PACKAGES_SUBDIR))
             }),
             downloader,
-            index: OnceCell::new(),
+            index,
         }
     }
 
@@ -109,6 +120,7 @@ impl PackageStorage {
             // version.
             self.download_index()?
                 .iter()
+                .filter_map(|value| MinimalPackageInfo::deserialize(value).ok())
                 .filter(|package| package.name == spec.name)
                 .map(|package| package.version)
                 .max()
@@ -131,7 +143,7 @@ impl PackageStorage {
     }
 
     /// Download the package index. The result of this is cached for efficiency.
-    pub fn download_index(&self) -> StrResult<&[PackageInfo]> {
+    pub fn download_index(&self) -> StrResult<&[serde_json::Value]> {
         self.index
             .get_or_try_init(|| {
                 let url = format!("{DEFAULT_REGISTRY}/{DEFAULT_NAMESPACE}/index.json");
@@ -186,3 +198,54 @@ impl PackageStorage {
         })
     }
 }
+
+/// Minimal information required about a package to determine its latest
+/// version.
+#[derive(Deserialize)]
+struct MinimalPackageInfo {
+    name: String,
+    version: PackageVersion,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lazy_deser_index() {
+        let storage = PackageStorage::with_index(
+            None,
+            None,
+            Downloader::new("typst/test"),
+            OnceCell::with_value(vec![
+                serde_json::json!({
+                    "name": "charged-ieee",
+                    "version": "0.1.0",
+                    "entrypoint": "lib.typ",
+                }),
+                serde_json::json!({
+                    "name": "unequivocal-ams",
+                    // This version number is currently not valid, so this package
+                    // can't be parsed.
+                    "version": "0.2.0-dev",
+                    "entrypoint": "lib.typ",
+                }),
+            ]),
+        );
+
+        let ieee_version = storage.determine_latest_version(&VersionlessPackageSpec {
+            namespace: "preview".into(),
+            name: "charged-ieee".into(),
+        });
+        assert_eq!(ieee_version, Ok(PackageVersion { major: 0, minor: 1, patch: 0 }));
+
+        let ams_version = storage.determine_latest_version(&VersionlessPackageSpec {
+            namespace: "preview".into(),
+            name: "unequivocal-ams".into(),
+        });
+        assert_eq!(
+            ams_version,
+            Err("failed to find package @preview/unequivocal-ams".into())
+        )
+    }
+}

crates/typst-layout/src/flow/collect.rs

@@ -124,7 +124,6 @@ impl<'a> Collector<'a, '_, '_> {
             styles,
             self.base,
             self.expand,
-            None,
         )?
         .into_frames();
 
@@ -133,7 +132,8 @@ impl<'a> Collector<'a, '_, '_> {
             self.output.push(Child::Tag(&elem.tag));
         }
 
-        self.lines(lines, styles);
+        let leading = ParElem::leading_in(styles);
+        self.lines(lines, leading, styles);
 
         for (c, _) in &self.children[end..] {
             let elem = c.to_packed::<TagElem>().unwrap();
@@ -169,10 +169,12 @@ impl<'a> Collector<'a, '_, '_> {
         )?
         .into_frames();
 
-        let spacing = ParElem::spacing_in(styles);
+        let spacing = elem.spacing(styles);
+        let leading = elem.leading(styles);
+
         self.output.push(Child::Rel(spacing.into(), 4));
 
-        self.lines(lines, styles);
+        self.lines(lines, leading, styles);
 
         self.output.push(Child::Rel(spacing.into(), 4));
         self.par_situation = ParSituation::Consecutive;
@@ -181,9 +183,8 @@ impl<'a> Collector<'a, '_, '_> {
     }
 
     /// Collect laid-out lines.
-    fn lines(&mut self, lines: Vec<Frame>, styles: StyleChain<'a>) {
+    fn lines(&mut self, lines: Vec<Frame>, leading: Abs, styles: StyleChain<'a>) {
         let align = AlignElem::alignment_in(styles).resolve(styles);
-        let leading = ParElem::leading_in(styles);
         let costs = TextElem::costs_in(styles);
 
         // Determine whether to prevent widow and orphans.

crates/typst-layout/src/flow/mod.rs

@@ -197,7 +197,50 @@ pub fn layout_flow<'a>(
     mode: FlowMode,
 ) -> SourceResult<Fragment> {
     // Prepare configuration that is shared across the whole flow.
-    let config = Config {
+    let config = configuration(shared, regions, columns, column_gutter, mode);
+
+    // Collect the elements into pre-processed children. These are much easier
+    // to handle than the raw elements.
+    let bump = Bump::new();
+    let children = collect(
+        engine,
+        &bump,
+        children,
+        locator.next(&()),
+        Size::new(config.columns.width, regions.full),
+        regions.expand.x,
+        mode,
+    )?;
+
+    let mut work = Work::new(&children);
+    let mut finished = vec![];
+
+    // This loop runs once per region produced by the flow layout.
+    loop {
+        let frame = compose(engine, &mut work, &config, locator.next(&()), regions)?;
+        finished.push(frame);
+
+        // Terminate the loop when everything is processed, though draining the
+        // backlog if necessary.
+        if work.done() && (!regions.expand.y || regions.backlog.is_empty()) {
+            break;
+        }
+
+        regions.next();
+    }
+
+    Ok(Fragment::frames(finished))
+}
+
+/// Determine the flow's configuration.
+fn configuration<'x>(
+    shared: StyleChain<'x>,
+    regions: Regions,
+    columns: NonZeroUsize,
+    column_gutter: Rel<Abs>,
+    mode: FlowMode,
+) -> Config<'x> {
+    Config {
         mode,
         shared,
         columns: {
@@ -235,39 +278,7 @@ pub fn layout_flow<'a>(
                 )
             },
         }),
-    };
-
-    // Collect the elements into pre-processed children. These are much easier
-    // to handle than the raw elements.
-    let bump = Bump::new();
-    let children = collect(
-        engine,
-        &bump,
-        children,
-        locator.next(&()),
-        Size::new(config.columns.width, regions.full),
-        regions.expand.x,
-        mode,
-    )?;
-
-    let mut work = Work::new(&children);
-    let mut finished = vec![];
-
-    // This loop runs once per region produced by the flow layout.
-    loop {
-        let frame = compose(engine, &mut work, &config, locator.next(&()), regions)?;
-        finished.push(frame);
-
-        // Terminate the loop when everything is processed, though draining the
-        // backlog if necessary.
-        if work.done() && (!regions.expand.y || regions.backlog.is_empty()) {
-            break;
-        }
-
-        regions.next();
     }
-
-    Ok(Fragment::frames(finished))
 }
 
 /// The work that is left to do by flow layout.

crates/typst-layout/src/image.rs

@@ -95,6 +95,8 @@ pub fn layout_image(
     } else {
         // If neither is forced, take the natural image size at the image's
         // DPI bounded by the available space.
+        //
+        // Division by DPI is fine since it's guaranteed to be positive.
         let dpi = image.dpi().unwrap_or(Image::DEFAULT_DPI);
         let natural = Axes::new(pxw, pxh).map(|v| Abs::inches(v / dpi));
         Size::new(

crates/typst-layout/src/inline/collect.rs

@@ -2,10 +2,8 @@ use typst_library::diag::warning;
 use typst_library::foundations::{Packed, Resolve};
 use typst_library::introspection::{SplitLocator, Tag, TagElem};
 use typst_library::layout::{
-    Abs, AlignElem, BoxElem, Dir, Fr, Frame, HElem, InlineElem, InlineItem, Sizing,
+    Abs, BoxElem, Dir, Fr, Frame, HElem, InlineElem, InlineItem, Sizing, Spacing,
-    Spacing,
 };
-use typst_library::model::{EnumElem, ListElem, TermsElem};
 use typst_library::routines::Pair;
 use typst_library::text::{
     is_default_ignorable, LinebreakElem, SmartQuoteElem, SmartQuoter, SmartQuotes,
@@ -123,40 +121,20 @@ pub fn collect<'a>(
     children: &[Pair<'a>],
     engine: &mut Engine<'_>,
     locator: &mut SplitLocator<'a>,
-    styles: StyleChain<'a>,
+    config: &Config,
     region: Size,
-    situation: Option<ParSituation>,
 ) -> SourceResult<(String, Vec<Segment<'a>>, SpanMapper)> {
     let mut collector = Collector::new(2 + children.len());
     let mut quoter = SmartQuoter::new();
 
-    let outer_dir = TextElem::dir_in(styles);
+    if !config.first_line_indent.is_zero() {
+        collector.push_item(Item::Absolute(config.first_line_indent, false));
+        collector.spans.push(1, Span::detached());
+    }
 
-    if let Some(situation) = situation {
+    if !config.hanging_indent.is_zero() {
-        let first_line_indent = ParElem::first_line_indent_in(styles);
+        collector.push_item(Item::Absolute(-config.hanging_indent, false));
-        if !first_line_indent.amount.is_zero()
+        collector.spans.push(1, Span::detached());
-            && match situation {
-                // First-line indent for the first paragraph after a list bullet
-                // just looks bad.
-                ParSituation::First => first_line_indent.all && !in_list(styles),
-                ParSituation::Consecutive => true,
-                ParSituation::Other => first_line_indent.all,
-            }
-            && AlignElem::alignment_in(styles).resolve(styles).x
-                == outer_dir.start().into()
-        {
-            collector.push_item(Item::Absolute(
-                first_line_indent.amount.resolve(styles),
-                false,
-            ));
-            collector.spans.push(1, Span::detached());
-        }
-
-        let hang = ParElem::hanging_indent_in(styles);
-        if !hang.is_zero() {
-            collector.push_item(Item::Absolute(-hang, false));
-            collector.spans.push(1, Span::detached());
-        }
     }
 
     for &(child, styles) in children {
@@ -167,7 +145,7 @@ pub fn collect<'a>(
         } else if let Some(elem) = child.to_packed::<TextElem>() {
             collector.build_text(styles, |full| {
                 let dir = TextElem::dir_in(styles);
-                if dir != outer_dir {
+                if dir != config.dir {
                     // Insert "Explicit Directional Embedding".
                     match dir {
                         Dir::LTR => full.push_str(LTR_EMBEDDING),
@@ -182,7 +160,7 @@ pub fn collect<'a>(
                     full.push_str(&elem.text);
                 }
 
-                if dir != outer_dir {
+                if dir != config.dir {
                     // Insert "Pop Directional Formatting".
                     full.push_str(POP_EMBEDDING);
                 }
@@ -265,16 +243,6 @@ pub fn collect<'a>(
     Ok((collector.full, collector.segments, collector.spans))
 }
 
-/// Whether we have a list ancestor.
-///
-/// When we support some kind of more general ancestry mechanism, this can
-/// become more elegant.
-fn in_list(styles: StyleChain) -> bool {
-    ListElem::depth_in(styles).0 > 0
-        || !EnumElem::parents_in(styles).is_empty()
-        || TermsElem::within_in(styles)
-}
-
 /// Collects segments.
 struct Collector<'a> {
     full: String,

crates/typst-layout/src/inline/finalize.rs

@@ -9,7 +9,6 @@ pub fn finalize(
     engine: &mut Engine,
     p: &Preparation,
     lines: &[Line],
-    styles: StyleChain,
     region: Size,
     expand: bool,
     locator: &mut SplitLocator<'_>,
@@ -19,9 +18,10 @@ pub fn finalize(
     let width = if !region.x.is_finite()
         || (!expand && lines.iter().all(|line| line.fr().is_zero()))
     {
-        region
+        region.x.min(
-            .x
+            p.config.hanging_indent
-            .min(p.hang + lines.iter().map(|line| line.width).max().unwrap_or_default())
+                + lines.iter().map(|line| line.width).max().unwrap_or_default(),
+        )
     } else {
         region.x
     };
@@ -29,7 +29,7 @@ pub fn finalize(
     // Stack the lines into one frame per region.
     lines
         .iter()
-        .map(|line| commit(engine, p, line, width, region.y, locator, styles))
+        .map(|line| commit(engine, p, line, width, region.y, locator))
         .collect::<SourceResult<_>>()
         .map(Fragment::frames)
 }

crates/typst-layout/src/inline/line.rs

@@ -2,10 +2,9 @@ use std::fmt::{self, Debug, Formatter};
 use std::ops::{Deref, DerefMut};
 
 use typst_library::engine::Engine;
-use typst_library::foundations::NativeElement;
 use typst_library::introspection::{SplitLocator, Tag};
 use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
-use typst_library::model::{ParLine, ParLineMarker};
+use typst_library::model::ParLineMarker;
 use typst_library::text::{Lang, TextElem};
 use typst_utils::Numeric;
 
@@ -135,7 +134,7 @@ pub fn line<'a>(
 
     // Whether the line is justified.
     let justify = full.ends_with(LINE_SEPARATOR)
-        || (p.justify && breakpoint != Breakpoint::Mandatory);
+        || (p.config.justify && breakpoint != Breakpoint::Mandatory);
 
     // Process dashes.
     let dash = if breakpoint.is_hyphen() || full.ends_with(SHY) {
@@ -157,14 +156,14 @@ pub fn line<'a>(
     // Add a hyphen at the line start, if a previous dash should be repeated.
     if pred.map_or(false, |pred| should_repeat_hyphen(pred, full)) {
         if let Some(shaped) = items.first_text_mut() {
-            shaped.prepend_hyphen(engine, p.fallback);
+            shaped.prepend_hyphen(engine, p.config.fallback);
         }
     }
 
     // Add a hyphen at the line end, if we ended on a soft hyphen.
     if dash == Some(Dash::Soft) {
         if let Some(shaped) = items.last_text_mut() {
-            shaped.push_hyphen(engine, p.fallback);
+            shaped.push_hyphen(engine, p.config.fallback);
         }
     }
 
@@ -234,13 +233,13 @@ where
 {
     // If there is nothing bidirectional going on, skip reordering.
     let Some(bidi) = &p.bidi else {
-        f(range, p.dir == Dir::RTL);
+        f(range, p.config.dir == Dir::RTL);
         return;
     };
 
     // The bidi crate panics for empty lines.
     if range.is_empty() {
-        f(range, p.dir == Dir::RTL);
+        f(range, p.config.dir == Dir::RTL);
         return;
     }
 
@@ -308,13 +307,13 @@ fn collect_range<'a>(
 /// punctuation marks at line start or line end.
 fn adjust_cj_at_line_boundaries(p: &Preparation, text: &str, items: &mut Items) {
     if text.starts_with(BEGIN_PUNCT_PAT)
-        || (p.cjk_latin_spacing && text.starts_with(is_of_cj_script))
+        || (p.config.cjk_latin_spacing && text.starts_with(is_of_cj_script))
     {
         adjust_cj_at_line_start(p, items);
     }
 
     if text.ends_with(END_PUNCT_PAT)
-        || (p.cjk_latin_spacing && text.ends_with(is_of_cj_script))
+        || (p.config.cjk_latin_spacing && text.ends_with(is_of_cj_script))
     {
         adjust_cj_at_line_end(p, items);
     }
@@ -332,7 +331,10 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
         let shrink = glyph.shrinkability().0;
         glyph.shrink_left(shrink);
         shaped.width -= shrink.at(shaped.size);
-    } else if p.cjk_latin_spacing && glyph.is_cj_script() && glyph.x_offset > Em::zero() {
+    } else if p.config.cjk_latin_spacing
+        && glyph.is_cj_script()
+        && glyph.x_offset > Em::zero()
+    {
         // If the first glyph is a CJK character adjusted by
         // [`add_cjk_latin_spacing`], restore the original width.
         let glyph = shaped.glyphs.to_mut().first_mut().unwrap();
@@ -359,7 +361,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
         let punct = shaped.glyphs.to_mut().last_mut().unwrap();
         punct.shrink_right(shrink);
         shaped.width -= shrink.at(shaped.size);
-    } else if p.cjk_latin_spacing
+    } else if p.config.cjk_latin_spacing
         && glyph.is_cj_script()
         && (glyph.x_advance - glyph.x_offset) > Em::one()
     {
@@ -424,16 +426,15 @@ pub fn commit(
     width: Abs,
     full: Abs,
     locator: &mut SplitLocator<'_>,
-    styles: StyleChain,
 ) -> SourceResult<Frame> {
-    let mut remaining = width - line.width - p.hang;
+    let mut remaining = width - line.width - p.config.hanging_indent;
     let mut offset = Abs::zero();
 
     // We always build the line from left to right. In an LTR paragraph, we must
     // thus add the hanging indent to the offset. In an RTL paragraph, the
     // hanging indent arises naturally due to the line width.
-    if p.dir == Dir::LTR {
+    if p.config.dir == Dir::LTR {
-        offset += p.hang;
+        offset += p.config.hanging_indent;
     }
 
     // Handle hanging punctuation to the left.
@@ -554,11 +555,13 @@ pub fn commit(
     let mut output = Frame::soft(size);
     output.set_baseline(top);
 
-    add_par_line_marker(&mut output, styles, engine, locator, top);
+    if let Some(marker) = &p.config.numbering_marker {
+        add_par_line_marker(&mut output, marker, engine, locator, top);
+    }
 
     // Construct the line's frame.
     for (offset, frame) in frames {
-        let x = offset + p.align.position(remaining);
+        let x = offset + p.config.align.position(remaining);
         let y = top - frame.baseline();
         output.push_frame(Point::new(x, y), frame);
     }
@@ -575,26 +578,18 @@ pub fn commit(
 /// number in the margin, is aligned to the line's baseline.
 fn add_par_line_marker(
     output: &mut Frame,
-    styles: StyleChain,
+    marker: &Packed<ParLineMarker>,
     engine: &mut Engine,
     locator: &mut SplitLocator,
     top: Abs,
 ) {
-    let Some(numbering) = ParLine::numbering_in(styles) else { return };
-    let margin = ParLine::number_margin_in(styles);
-    let align = ParLine::number_align_in(styles);
-
-    // Delay resolving the number clearance until line numbers are laid out to
-    // avoid inconsistent spacing depending on varying font size.
-    let clearance = ParLine::number_clearance_in(styles);
-
     // Elements in tags must have a location for introspection to work. We do
     // the work here instead of going through all of the realization process
     // just for this, given we don't need to actually place the marker as we
     // manually search for it in the frame later (when building a root flow,
     // where line numbers can be displayed), so we just need it to be in a tag
     // and to be valid (to have a location).
-    let mut marker = ParLineMarker::new(numbering, align, margin, clearance).pack();
+    let mut marker = marker.clone();
     let key = typst_utils::hash128(&marker);
     let loc = locator.next_location(engine.introspector, key);
     marker.set_location(loc);
@@ -606,7 +601,7 @@ fn add_par_line_marker(
     // line's general baseline. However, the line number will still need to
     // manually adjust its own 'y' position based on its own baseline.
     let pos = Point::with_y(top);
-    output.push(pos, FrameItem::Tag(Tag::Start(marker)));
+    output.push(pos, FrameItem::Tag(Tag::Start(marker.pack())));
     output.push(pos, FrameItem::Tag(Tag::End(loc, key)));
 }
 

crates/typst-layout/src/inline/linebreak.rs

@@ -110,15 +110,7 @@ pub fn linebreak<'a>(
     p: &'a Preparation<'a>,
     width: Abs,
 ) -> Vec<Line<'a>> {
-    let linebreaks = p.linebreaks.unwrap_or_else(|| {
+    match p.config.linebreaks {
-        if p.justify {
-            Linebreaks::Optimized
-        } else {
-            Linebreaks::Simple
-        }
-    });
-
-    match linebreaks {
         Linebreaks::Simple => linebreak_simple(engine, p, width),
         Linebreaks::Optimized => linebreak_optimized(engine, p, width),
     }
@@ -384,7 +376,7 @@ fn linebreak_optimized_approximate(
 
             // Whether the line is justified. This is not 100% accurate w.r.t
             // to line()'s behaviour, but good enough.
-            let justify = p.justify && breakpoint != Breakpoint::Mandatory;
+            let justify = p.config.justify && breakpoint != Breakpoint::Mandatory;
 
             // We don't really know whether the line naturally ends with a dash
             // here, so we can miss that case, but it's ok, since all of this
@@ -573,7 +565,7 @@ fn raw_ratio(
         // calculate the extra amount. Also, don't divide by zero.
         let extra_stretch = (delta - adjustability) / justifiables.max(1) as f64;
         // Normalize the amount by half the em size.
-        ratio = 1.0 + extra_stretch / (p.size / 2.0);
+        ratio = 1.0 + extra_stretch / (p.config.font_size / 2.0);
     }
 
     // The min value must be < MIN_RATIO, but how much smaller doesn't matter
@@ -663,9 +655,9 @@ fn breakpoints(p: &Preparation, mut f: impl FnMut(usize, Breakpoint)) {
         return;
     }
 
-    let hyphenate = p.hyphenate != Some(false);
+    let hyphenate = p.config.hyphenate != Some(false);
     let lb = LINEBREAK_DATA.as_borrowed();
-    let segmenter = match p.lang {
+    let segmenter = match p.config.lang {
         Some(Lang::CHINESE | Lang::JAPANESE) => &CJ_SEGMENTER,
         _ => &SEGMENTER,
     };
@@ -830,18 +822,18 @@ fn linebreak_link(link: &str, mut f: impl FnMut(usize)) {
 
 /// Whether hyphenation is enabled at the given offset.
 fn hyphenate_at(p: &Preparation, offset: usize) -> bool {
-    p.hyphenate
+    p.config.hyphenate.unwrap_or_else(|| {
-        .or_else(|| {
+        let (_, item) = p.get(offset);
-            let (_, item) = p.get(offset);
+        match item.text() {
-            let styles = item.text()?.styles;
+            Some(text) => TextElem::hyphenate_in(text.styles).unwrap_or(p.config.justify),
-            Some(TextElem::hyphenate_in(styles))
+            None => false,
-        })
+        }
-        .unwrap_or(false)
+    })
 }
 
 /// The text language at the given offset.
 fn lang_at(p: &Preparation, offset: usize) -> Option<hypher::Lang> {
-    let lang = p.lang.or_else(|| {
+    let lang = p.config.lang.or_else(|| {
         let (_, item) = p.get(offset);
         let styles = item.text()?.styles;
         Some(TextElem::lang_in(styles))
@@ -865,13 +857,13 @@ impl CostMetrics {
     fn compute(p: &Preparation) -> Self {
         Self {
             // When justifying, we may stretch spaces below their natural width.
-            min_ratio: if p.justify { MIN_RATIO } else { 0.0 },
+            min_ratio: if p.config.justify { MIN_RATIO } else { 0.0 },
-            min_approx_ratio: if p.justify { MIN_APPROX_RATIO } else { 0.0 },
+            min_approx_ratio: if p.config.justify { MIN_APPROX_RATIO } else { 0.0 },
             // Approximate hyphen width for estimates.
-            approx_hyphen_width: Em::new(0.33).at(p.size),
+            approx_hyphen_width: Em::new(0.33).at(p.config.font_size),
             // Costs.
-            hyph_cost: DEFAULT_HYPH_COST * p.costs.hyphenation().get(),
+            hyph_cost: DEFAULT_HYPH_COST * p.config.costs.hyphenation().get(),
-            runt_cost: DEFAULT_RUNT_COST * p.costs.runt().get(),
+            runt_cost: DEFAULT_RUNT_COST * p.config.costs.runt().get(),
         }
     }
 

crates/typst-layout/src/inline/mod.rs

@@ -13,12 +13,17 @@ pub use self::box_::layout_box;
 use comemo::{Track, Tracked, TrackedMut};
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
-use typst_library::foundations::{Packed, StyleChain};
+use typst_library::foundations::{Packed, Resolve, Smart, StyleChain};
 use typst_library::introspection::{Introspector, Locator, LocatorLink, SplitLocator};
-use typst_library::layout::{Fragment, Size};
+use typst_library::layout::{Abs, AlignElem, Dir, FixedAlignment, Fragment, Size};
-use typst_library::model::ParElem;
+use typst_library::model::{
+    EnumElem, FirstLineIndent, Linebreaks, ListElem, ParElem, ParLine, ParLineMarker,
+    TermsElem,
+};
 use typst_library::routines::{Arenas, Pair, RealizationKind, Routines};
+use typst_library::text::{Costs, Lang, TextElem};
 use typst_library::World;
+use typst_utils::{Numeric, SliceExt};
 
 use self::collect::{collect, Item, Segment, SpanMapper};
 use self::deco::decorate;
@@ -98,7 +103,7 @@ fn layout_par_impl(
         styles,
     )?;
 
-    layout_inline(
+    layout_inline_impl(
         &mut engine,
         &children,
         &mut locator,
@@ -106,33 +111,134 @@ fn layout_par_impl(
         region,
         expand,
         Some(situation),
+        &ConfigBase {
+            justify: elem.justify(styles),
+            linebreaks: elem.linebreaks(styles),
+            first_line_indent: elem.first_line_indent(styles),
+            hanging_indent: elem.hanging_indent(styles),
+        },
     )
 }
 
 /// Lays out realized content with inline layout.
-#[allow(clippy::too_many_arguments)]
 pub fn layout_inline<'a>(
     engine: &mut Engine,
     children: &[Pair<'a>],
     locator: &mut SplitLocator<'a>,
-    styles: StyleChain<'a>,
+    shared: StyleChain<'a>,
+    region: Size,
+    expand: bool,
+) -> SourceResult<Fragment> {
+    layout_inline_impl(
+        engine,
+        children,
+        locator,
+        shared,
+        region,
+        expand,
+        None,
+        &ConfigBase {
+            justify: ParElem::justify_in(shared),
+            linebreaks: ParElem::linebreaks_in(shared),
+            first_line_indent: ParElem::first_line_indent_in(shared),
+            hanging_indent: ParElem::hanging_indent_in(shared),
+        },
+    )
+}
+
+/// The internal implementation of [`layout_inline`].
+#[allow(clippy::too_many_arguments)]
+fn layout_inline_impl<'a>(
+    engine: &mut Engine,
+    children: &[Pair<'a>],
+    locator: &mut SplitLocator<'a>,
+    shared: StyleChain<'a>,
     region: Size,
     expand: bool,
     par: Option<ParSituation>,
+    base: &ConfigBase,
 ) -> SourceResult<Fragment> {
+    // Prepare configuration that is shared across the whole inline layout.
+    let config = configuration(base, children, shared, par);
+
     // Collect all text into one string for BiDi analysis.
-    let (text, segments, spans) =
+    let (text, segments, spans) = collect(children, engine, locator, &config, region)?;
-        collect(children, engine, locator, styles, region, par)?;
 
     // Perform BiDi analysis and performs some preparation steps before we
     // proceed to line breaking.
-    let p = prepare(engine, children, &text, segments, spans, styles, par)?;
+    let p = prepare(engine, &config, &text, segments, spans)?;
 
     // Break the text into lines.
-    let lines = linebreak(engine, &p, region.x - p.hang);
+    let lines = linebreak(engine, &p, region.x - config.hanging_indent);
 
     // Turn the selected lines into frames.
-    finalize(engine, &p, &lines, styles, region, expand, locator)
+    finalize(engine, &p, &lines, region, expand, locator)
+}
+
+/// Determine the inline layout's configuration.
+fn configuration(
+    base: &ConfigBase,
+    children: &[Pair],
+    shared: StyleChain,
+    situation: Option<ParSituation>,
+) -> Config {
+    let justify = base.justify;
+    let font_size = TextElem::size_in(shared);
+    let dir = TextElem::dir_in(shared);
+
+    Config {
+        justify,
+        linebreaks: base.linebreaks.unwrap_or_else(|| {
+            if justify {
+                Linebreaks::Optimized
+            } else {
+                Linebreaks::Simple
+            }
+        }),
+        first_line_indent: {
+            let FirstLineIndent { amount, all } = base.first_line_indent;
+            if !amount.is_zero()
+                && match situation {
+                    // First-line indent for the first paragraph after a list
+                    // bullet just looks bad.
+                    Some(ParSituation::First) => all && !in_list(shared),
+                    Some(ParSituation::Consecutive) => true,
+                    Some(ParSituation::Other) => all,
+                    None => false,
+                }
+                && AlignElem::alignment_in(shared).resolve(shared).x == dir.start().into()
+            {
+                amount.at(font_size)
+            } else {
+                Abs::zero()
+            }
+        },
+        hanging_indent: if situation.is_some() {
+            base.hanging_indent
+        } else {
+            Abs::zero()
+        },
+        numbering_marker: ParLine::numbering_in(shared).map(|numbering| {
+            Packed::new(ParLineMarker::new(
+                numbering,
+                ParLine::number_align_in(shared),
+                ParLine::number_margin_in(shared),
+                // Delay resolving the number clearance until line numbers are
+                // laid out to avoid inconsistent spacing depending on varying
+                // font size.
+                ParLine::number_clearance_in(shared),
+            ))
+        }),
+        align: AlignElem::alignment_in(shared).fix(dir).x,
+        font_size,
+        dir,
+        hyphenate: shared_get(children, shared, TextElem::hyphenate_in)
+            .map(|uniform| uniform.unwrap_or(justify)),
+        lang: shared_get(children, shared, TextElem::lang_in),
+        fallback: TextElem::fallback_in(shared),
+        cjk_latin_spacing: TextElem::cjk_latin_spacing_in(shared).is_auto(),
+        costs: TextElem::costs_in(shared),
+    }
 }
 
 /// Distinguishes between a few different kinds of paragraphs.
@@ -148,3 +254,66 @@ pub enum ParSituation {
     /// Any other kind of paragraph.
     Other,
 }
+
+/// Raw values from a `ParElem` or style chain. Used to initialize a [`Config`].
+struct ConfigBase {
+    justify: bool,
+    linebreaks: Smart<Linebreaks>,
+    first_line_indent: FirstLineIndent,
+    hanging_indent: Abs,
+}
+
+/// Shared configuration for the whole inline layout.
+struct Config {
+    /// Whether to justify text.
+    justify: bool,
+    /// How to determine line breaks.
+    linebreaks: Linebreaks,
+    /// The indent the first line of a paragraph should have.
+    first_line_indent: Abs,
+    /// The indent that all but the first line of a paragraph should have.
+    hanging_indent: Abs,
+    /// Configuration for line numbering.
+    numbering_marker: Option<Packed<ParLineMarker>>,
+    /// The resolved horizontal alignment.
+    align: FixedAlignment,
+    /// The text size.
+    font_size: Abs,
+    /// The dominant direction.
+    dir: Dir,
+    /// A uniform hyphenation setting (only `Some(_)` if it's the same for all
+    /// children, otherwise `None`).
+    hyphenate: Option<bool>,
+    /// The text language (only `Some(_)` if it's the same for all
+    /// children, otherwise `None`).
+    lang: Option<Lang>,
+    /// Whether font fallback is enabled.
+    fallback: bool,
+    /// Whether to add spacing between CJK and Latin characters.
+    cjk_latin_spacing: bool,
+    /// Costs for various layout decisions.
+    costs: Costs,
+}
+
+/// Get a style property, but only if it is the same for all of the children.
+fn shared_get<T: PartialEq>(
+    children: &[Pair],
+    styles: StyleChain<'_>,
+    getter: fn(StyleChain) -> T,
+) -> Option<T> {
+    let value = getter(styles);
+    children
+        .group_by_key(|&(_, s)| s)
+        .all(|(s, _)| getter(s) == value)
+        .then_some(value)
+}
+
+/// Whether we have a list ancestor.
+///
+/// When we support some kind of more general ancestry mechanism, this can
+/// become more elegant.
+fn in_list(styles: StyleChain) -> bool {
+    ListElem::depth_in(styles).0 > 0
+        || !EnumElem::parents_in(styles).is_empty()
+        || TermsElem::within_in(styles)
+}

crates/typst-layout/src/inline/prepare.rs

@@ -1,9 +1,4 @@
-use typst_library::foundations::{Resolve, Smart};
+use typst_library::layout::{Dir, Em};
-use typst_library::layout::{Abs, AlignElem, Dir, Em, FixedAlignment};
-use typst_library::model::Linebreaks;
-use typst_library::routines::Pair;
-use typst_library::text::{Costs, Lang, TextElem};
-use typst_utils::SliceExt;
 use unicode_bidi::{BidiInfo, Level as BidiLevel};
 
 use super::*;
@@ -17,6 +12,8 @@ use super::*;
 pub struct Preparation<'a> {
     /// The full text.
     pub text: &'a str,
+    /// Configuration for inline layout.
+    pub config: &'a Config,
     /// Bidirectional text embedding levels.
     ///
     /// This is `None` if all text directions are uniform (all the base
@@ -28,28 +25,6 @@ pub struct Preparation<'a> {
     pub indices: Vec<usize>,
     /// The span mapper.
     pub spans: SpanMapper,
-    /// Whether to hyphenate if it's the same for all children.
-    pub hyphenate: Option<bool>,
-    /// Costs for various layout decisions.
-    pub costs: Costs,
-    /// The dominant direction.
-    pub dir: Dir,
-    /// The text language if it's the same for all children.
-    pub lang: Option<Lang>,
-    /// The resolved horizontal alignment.
-    pub align: FixedAlignment,
-    /// Whether to justify text.
-    pub justify: bool,
-    /// Hanging indent to apply.
-    pub hang: Abs,
-    /// Whether to add spacing between CJK and Latin characters.
-    pub cjk_latin_spacing: bool,
-    /// Whether font fallback is enabled.
-    pub fallback: bool,
-    /// How to determine line breaks.
-    pub linebreaks: Smart<Linebreaks>,
-    /// The text size.
-    pub size: Abs,
 }
 
 impl<'a> Preparation<'a> {
@@ -80,15 +55,12 @@ impl<'a> Preparation<'a> {
 #[typst_macros::time]
 pub fn prepare<'a>(
     engine: &mut Engine,
-    children: &[Pair<'a>],
+    config: &'a Config,
     text: &'a str,
     segments: Vec<Segment<'a>>,
     spans: SpanMapper,
-    styles: StyleChain<'a>,
-    situation: Option<ParSituation>,
 ) -> SourceResult<Preparation<'a>> {
-    let dir = TextElem::dir_in(styles);
+    let default_level = match config.dir {
-    let default_level = match dir {
         Dir::RTL => BidiLevel::rtl(),
         _ => BidiLevel::ltr(),
     };
@@ -124,51 +96,20 @@ pub fn prepare<'a>(
         indices.extend(range.clone().map(|_| i));
     }
 
-    let cjk_latin_spacing = TextElem::cjk_latin_spacing_in(styles).is_auto();
+    if config.cjk_latin_spacing {
-    if cjk_latin_spacing {
         add_cjk_latin_spacing(&mut items);
     }
 
-    // Only apply hanging indent to real paragraphs.
-    let hang = if situation.is_some() {
-        ParElem::hanging_indent_in(styles)
-    } else {
-        Abs::zero()
-    };
-
     Ok(Preparation {
+        config,
         text,
         bidi: is_bidi.then_some(bidi),
         items,
         indices,
         spans,
-        hyphenate: shared_get(children, styles, TextElem::hyphenate_in),
-        costs: TextElem::costs_in(styles),
-        dir,
-        lang: shared_get(children, styles, TextElem::lang_in),
-        align: AlignElem::alignment_in(styles).resolve(styles).x,
-        justify: ParElem::justify_in(styles),
-        hang,
-        cjk_latin_spacing,
-        fallback: TextElem::fallback_in(styles),
-        linebreaks: ParElem::linebreaks_in(styles),
-        size: TextElem::size_in(styles),
     })
 }
 
-/// Get a style property, but only if it is the same for all of the children.
-fn shared_get<T: PartialEq>(
-    children: &[Pair],
-    styles: StyleChain<'_>,
-    getter: fn(StyleChain) -> T,
-) -> Option<T> {
-    let value = getter(styles);
-    children
-        .group_by_key(|&(_, s)| s)
-        .all(|(s, _)| getter(s) == value)
-        .then_some(value)
-}
-
 /// Add some spacing between Han characters and western characters. See
 /// Requirements for Chinese Text Layout, Section 3.2.2 Mixed Text Composition
 /// in Horizontal Written Mode

crates/typst-layout/src/math/text.rs

@@ -107,7 +107,6 @@ fn layout_inline_text(
             styles,
             Size::splat(Abs::inf()),
             false,
-            None,
         )?
         .into_frame();
 

crates/typst-layout/src/shapes.rs

@@ -1281,7 +1281,7 @@ impl ControlPoints {
     }
 }
 
-/// Helper to draw arcs with bezier curves.
+/// Helper to draw arcs with Bézier curves.
 trait CurveExt {
     fn arc(&mut self, start: Point, center: Point, end: Point);
     fn arc_move(&mut self, start: Point, center: Point, end: Point);
@@ -1305,7 +1305,7 @@ impl CurveExt for Curve {
     }
 }
 
-/// Get the control points for a bezier curve that approximates a circular arc for
+/// Get the control points for a Bézier curve that approximates a circular arc for
 /// a start point, an end point and a center of the circle whose arc connects
 /// the two.
 fn bezier_arc_control(start: Point, center: Point, end: Point) -> [Point; 2] {

crates/typst-library/Cargo.toml

@@ -38,6 +38,7 @@ indexmap = { workspace = true }
 kamadak-exif = { workspace = true }
 kurbo = { workspace = true }
 lipsum = { workspace = true }
+memchr = { workspace = true }
 palette = { workspace = true }
 phf = { workspace = true }
 png = { workspace = true }

crates/typst-library/src/diag.rs

@@ -232,18 +232,42 @@ impl From<SyntaxError> for SourceDiagnostic {
 /// Destination for a deprecation message when accessing a deprecated value.
 pub trait DeprecationSink {
     /// Emits the given deprecation message into this sink.
-    fn emit(self, message: &str);
+    fn emit(&mut self, message: &str);
+
+    /// Emits the given deprecation message into this sink, with the given
+    /// hints.
+    fn emit_with_hints(&mut self, message: &str, hints: &[&str]);
 }
 
 impl DeprecationSink for () {
-    fn emit(self, _: &str) {}
+    fn emit(&mut self, _: &str) {}
+    fn emit_with_hints(&mut self, _: &str, _: &[&str]) {}
+}
+
+impl DeprecationSink for (&mut Vec<SourceDiagnostic>, Span) {
+    fn emit(&mut self, message: &str) {
+        self.0.push(SourceDiagnostic::warning(self.1, message));
+    }
+
+    fn emit_with_hints(&mut self, message: &str, hints: &[&str]) {
+        self.0.push(
+            SourceDiagnostic::warning(self.1, message)
+                .with_hints(hints.iter().copied().map(Into::into)),
+        );
+    }
 }
 
 impl DeprecationSink for (&mut Engine<'_>, Span) {
-    /// Emits the deprecation message as a warning.
+    fn emit(&mut self, message: &str) {
-    fn emit(self, message: &str) {
         self.0.sink.warn(SourceDiagnostic::warning(self.1, message));
     }
+
+    fn emit_with_hints(&mut self, message: &str, hints: &[&str]) {
+        self.0.sink.warn(
+            SourceDiagnostic::warning(self.1, message)
+                .with_hints(hints.iter().copied().map(Into::into)),
+        );
+    }
 }
 
 /// A part of a diagnostic's [trace](SourceDiagnostic::trace).

crates/typst-library/src/foundations/array.rs

@@ -9,7 +9,9 @@ use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use typst_syntax::{Span, Spanned};
 
-use crate::diag::{bail, At, HintedStrResult, SourceDiagnostic, SourceResult, StrResult};
+use crate::diag::{
+    bail, At, DeprecationSink, HintedStrResult, SourceDiagnostic, SourceResult, StrResult,
+};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, func, ops, repr, scope, ty, Args, Bytes, CastInfo, Context, Dict, FromValue,
@@ -143,6 +145,11 @@ impl Array {
 
         Ok(self.iter().cloned().cycle().take(count).collect())
     }
+
+    /// The internal implementation of [`Array::contains`].
+    pub fn contains_impl(&self, value: &Value, sink: &mut dyn DeprecationSink) -> bool {
+        self.0.iter().any(|v| ops::equal(v, value, sink))
+    }
 }
 
 #[scope]
@@ -290,10 +297,12 @@ impl Array {
     #[func]
     pub fn contains(
         &self,
+        engine: &mut Engine,
+        span: Span,
         /// The value to search for.
         value: Value,
     ) -> bool {
-        self.0.contains(&value)
+        self.contains_impl(&value, &mut (engine, span))
     }
 
     /// Searches for an item for which the given function returns `{true}` and
@@ -576,6 +585,8 @@ impl Array {
     #[func]
     pub fn sum(
         self,
+        engine: &mut Engine,
+        span: Span,
         /// What to return if the array is empty. Must be set if the array can
         /// be empty.
         #[named]
@@ -587,7 +598,7 @@ impl Array {
             .or(default)
             .ok_or("cannot calculate sum of empty array with no default")?;
         for item in iter {
-            acc = ops::add(acc, item)?;
+            acc = ops::add(acc, item, &mut (&mut *engine, span))?;
         }
         Ok(acc)
     }
@@ -686,6 +697,8 @@ impl Array {
     #[func]
     pub fn join(
         self,
+        engine: &mut Engine,
+        span: Span,
         /// A value to insert between each item of the array.
         #[default]
         separator: Option<Value>,
@@ -701,13 +714,18 @@ impl Array {
         for (i, value) in self.into_iter().enumerate() {
             if i > 0 {
                 if i + 1 == len && last.is_some() {
-                    result = ops::join(result, last.take().unwrap())?;
+                    result = ops::join(
+                        result,
+                        last.take().unwrap(),
+                        &mut (&mut *engine, span),
+                    )?;
                 } else {
-                    result = ops::join(result, separator.clone())?;
+                    result =
+                        ops::join(result, separator.clone(), &mut (&mut *engine, span))?;
                 }
             }
 
-            result = ops::join(result, value)?;
+            result = ops::join(result, value, &mut (&mut *engine, span))?;
         }
 
         Ok(result)
@@ -862,13 +880,14 @@ impl Array {
         self,
         engine: &mut Engine,
         context: Tracked<Context>,
+        span: Span,
         /// If given, applies this function to the elements in the array to
         /// determine the keys to deduplicate by.
         #[named]
         key: Option<Func>,
     ) -> SourceResult<Array> {
         let mut out = EcoVec::with_capacity(self.0.len());
-        let mut key_of = |x: Value| match &key {
+        let key_of = |engine: &mut Engine, x: Value| match &key {
             // NOTE: We are relying on `comemo`'s memoization of function
             // evaluation to not excessively reevaluate the `key`.
             Some(f) => f.call(engine, context, [x]),
@@ -879,14 +898,18 @@ impl Array {
         // 1. We would like to preserve the order of the elements.
         // 2. We cannot hash arbitrary `Value`.
         'outer: for value in self {
-            let key = key_of(value.clone())?;
+            let key = key_of(&mut *engine, value.clone())?;
             if out.is_empty() {
                 out.push(value);
                 continue;
             }
 
             for second in out.iter() {
-                if ops::equal(&key, &key_of(second.clone())?) {
+                if ops::equal(
+                    &key,
+                    &key_of(&mut *engine, second.clone())?,
+                    &mut (&mut *engine, span),
+                ) {
                     continue 'outer;
                 }
             }

crates/typst-library/src/foundations/float.rs

@@ -110,7 +110,7 @@ impl f64 {
         f64::signum(self)
     }
 
-    /// Converts bytes to a float.
+    /// Interprets bytes as a float.
     ///
     /// ```example
     /// #float.from-bytes(bytes((0, 0, 0, 0, 0, 0, 240, 63))) \
@@ -120,8 +120,10 @@ impl f64 {
     pub fn from_bytes(
         /// The bytes that should be converted to a float.
         ///
-        /// Must be of length exactly 8 so that the result fits into a 64-bit
+        /// Must have a length of either 4 or 8. The bytes are then
-        /// float.
+        /// interpreted in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)'s
+        /// binary32 (single-precision) or binary64 (double-precision) format
+        /// depending on the length of the bytes.
         bytes: Bytes,
         /// The endianness of the conversion.
         #[named]
@@ -158,6 +160,13 @@ impl f64 {
         #[named]
         #[default(Endianness::Little)]
         endian: Endianness,
+        /// The size of the resulting bytes.
+        ///
+        /// This must be either 4 or 8. The call will return the
+        /// representation of this float in either
+        /// [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)'s binary32
+        /// (single-precision) or binary64 (double-precision) format
+        /// depending on the provided size.
         #[named]
         #[default(8)]
         size: u32,

crates/typst-library/src/foundations/ops.rs

@@ -5,7 +5,7 @@ use std::cmp::Ordering;
 use ecow::eco_format;
 use typst_utils::Numeric;
 
-use crate::diag::{bail, HintedStrResult, StrResult};
+use crate::diag::{bail, DeprecationSink, HintedStrResult, StrResult};
 use crate::foundations::{
     format_str, Datetime, IntoValue, Regex, Repr, SymbolElem, Value,
 };
@@ -21,7 +21,7 @@ macro_rules! mismatch {
 }
 
 /// Join a value with another value.
-pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
+pub fn join(lhs: Value, rhs: Value, sink: &mut dyn DeprecationSink) -> StrResult<Value> {
     use Value::*;
     Ok(match (lhs, rhs) {
         (a, None) => a,
@@ -39,6 +39,17 @@ pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
         (Array(a), Array(b)) => Array(a + b),
         (Dict(a), Dict(b)) => Dict(a + b),
         (Args(a), Args(b)) => Args(a + b),
+
+        // Type compatibility.
+        (Type(a), Str(b)) => {
+            warn_type_str_join(sink);
+            Str(format_str!("{a}{b}"))
+        }
+        (Str(a), Type(b)) => {
+            warn_type_str_join(sink);
+            Str(format_str!("{a}{b}"))
+        }
+
         (a, b) => mismatch!("cannot join {} with {}", a, b),
     })
 }
@@ -88,7 +99,11 @@ pub fn neg(value: Value) -> HintedStrResult<Value> {
 }
 
 /// Compute the sum of two values.
-pub fn add(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
+pub fn add(
+    lhs: Value,
+    rhs: Value,
+    sink: &mut dyn DeprecationSink,
+) -> HintedStrResult<Value> {
     use Value::*;
     Ok(match (lhs, rhs) {
         (a, None) => a,
@@ -156,6 +171,16 @@ pub fn add(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
         (Datetime(a), Duration(b)) => Datetime(a + b),
         (Duration(a), Datetime(b)) => Datetime(b + a),
 
+        // Type compatibility.
+        (Type(a), Str(b)) => {
+            warn_type_str_add(sink);
+            Str(format_str!("{a}{b}"))
+        }
+        (Str(a), Type(b)) => {
+            warn_type_str_add(sink);
+            Str(format_str!("{a}{b}"))
+        }
+
         (Dyn(a), Dyn(b)) => {
             // Alignments can be summed.
             if let (Some(&a), Some(&b)) =
@@ -394,13 +419,21 @@ pub fn or(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
 }
 
 /// Compute whether two values are equal.
-pub fn eq(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
+pub fn eq(
-    Ok(Value::Bool(equal(&lhs, &rhs)))
+    lhs: Value,
+    rhs: Value,
+    sink: &mut dyn DeprecationSink,
+) -> HintedStrResult<Value> {
+    Ok(Value::Bool(equal(&lhs, &rhs, sink)))
 }
 
 /// Compute whether two values are unequal.
-pub fn neq(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
+pub fn neq(
-    Ok(Value::Bool(!equal(&lhs, &rhs)))
+    lhs: Value,
+    rhs: Value,
+    sink: &mut dyn DeprecationSink,
+) -> HintedStrResult<Value> {
+    Ok(Value::Bool(!equal(&lhs, &rhs, sink)))
 }
 
 macro_rules! comparison {
@@ -419,7 +452,7 @@ comparison!(gt, ">", Ordering::Greater);
 comparison!(geq, ">=", Ordering::Greater | Ordering::Equal);
 
 /// Determine whether two values are equal.
-pub fn equal(lhs: &Value, rhs: &Value) -> bool {
+pub fn equal(lhs: &Value, rhs: &Value, sink: &mut dyn DeprecationSink) -> bool {
     use Value::*;
     match (lhs, rhs) {
         // Compare reflexively.
@@ -463,6 +496,12 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
             rat == rel.rel && rel.abs.is_zero()
         }
 
+        // Type compatibility.
+        (Type(ty), Str(str)) | (Str(str), Type(ty)) => {
+            warn_type_str_equal(sink);
+            ty.compat_name() == str.as_str()
+        }
+
         _ => false,
     }
 }
@@ -534,8 +573,12 @@ fn try_cmp_arrays(a: &[Value], b: &[Value]) -> StrResult<Ordering> {
 }
 
 /// Test whether one value is "in" another one.
-pub fn in_(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
+pub fn in_(
-    if let Some(b) = contains(&lhs, &rhs) {
+    lhs: Value,
+    rhs: Value,
+    sink: &mut dyn DeprecationSink,
+) -> HintedStrResult<Value> {
+    if let Some(b) = contains(&lhs, &rhs, sink) {
         Ok(Value::Bool(b))
     } else {
         mismatch!("cannot apply 'in' to {} and {}", lhs, rhs)
@@ -543,8 +586,12 @@ pub fn in_(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
 }
 
 /// Test whether one value is "not in" another one.
-pub fn not_in(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
+pub fn not_in(
-    if let Some(b) = contains(&lhs, &rhs) {
+    lhs: Value,
+    rhs: Value,
+    sink: &mut dyn DeprecationSink,
+) -> HintedStrResult<Value> {
+    if let Some(b) = contains(&lhs, &rhs, sink) {
         Ok(Value::Bool(!b))
     } else {
         mismatch!("cannot apply 'not in' to {} and {}", lhs, rhs)
@@ -552,13 +599,27 @@ pub fn not_in(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
 }
 
 /// Test for containment.
-pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
+pub fn contains(
+    lhs: &Value,
+    rhs: &Value,
+    sink: &mut dyn DeprecationSink,
+) -> Option<bool> {
     use Value::*;
     match (lhs, rhs) {
         (Str(a), Str(b)) => Some(b.as_str().contains(a.as_str())),
         (Dyn(a), Str(b)) => a.downcast::<Regex>().map(|regex| regex.is_match(b)),
         (Str(a), Dict(b)) => Some(b.contains(a)),
-        (a, Array(b)) => Some(b.contains(a.clone())),
+        (a, Array(b)) => Some(b.contains_impl(a, sink)),
+
+        // Type compatibility.
+        (Type(a), Str(b)) => {
+            warn_type_in_str(sink);
+            Some(b.as_str().contains(a.compat_name()))
+        }
+        (Type(a), Dict(b)) => {
+            warn_type_in_dict(sink);
+            Some(b.contains(a.compat_name()))
+        }
 
         _ => Option::None,
     }
@@ -568,3 +629,46 @@ pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
 fn too_large() -> &'static str {
     "value is too large"
 }
+
+#[cold]
+fn warn_type_str_add(sink: &mut dyn DeprecationSink) {
+    sink.emit_with_hints(
+        "adding strings and types is deprecated",
+        &["convert the type to a string with `str` first"],
+    );
+}
+
+#[cold]
+fn warn_type_str_join(sink: &mut dyn DeprecationSink) {
+    sink.emit_with_hints(
+        "joining strings and types is deprecated",
+        &["convert the type to a string with `str` first"],
+    );
+}
+
+#[cold]
+fn warn_type_str_equal(sink: &mut dyn DeprecationSink) {
+    sink.emit_with_hints(
+        "comparing strings with types is deprecated",
+        &[
+            "compare with the literal type instead",
+            "this comparison will always return `false` in future Typst releases",
+        ],
+    );
+}
+
+#[cold]
+fn warn_type_in_str(sink: &mut dyn DeprecationSink) {
+    sink.emit_with_hints(
+        "checking whether a type is contained in a string is deprecated",
+        &["this compatibility behavior only exists because `type` used to return a string"],
+    );
+}
+
+#[cold]
+fn warn_type_in_dict(sink: &mut dyn DeprecationSink) {
+    sink.emit_with_hints(
+        "checking whether a type is contained in a dictionary is deprecated",
+        &["this compatibility behavior only exists because `type` used to return a string"],
+    );
+}

crates/typst-library/src/foundations/plugin.rs

@@ -148,9 +148,7 @@ use crate::loading::{DataSource, Load};
 #[func(scope)]
 pub fn plugin(
     engine: &mut Engine,
-    /// A path to a WebAssembly file or raw WebAssembly bytes.
+    /// A [path]($syntax/#paths) to a WebAssembly file or raw WebAssembly bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Module> {
     let data = source.load(engine.world)?;

crates/typst-library/src/foundations/scope.rs

@@ -300,7 +300,7 @@ impl Binding {
     /// As the `sink`
     /// - pass `()` to ignore the message.
     /// - pass `(&mut engine, span)` to emit a warning into the engine.
-    pub fn read_checked(&self, sink: impl DeprecationSink) -> &Value {
+    pub fn read_checked(&self, mut sink: impl DeprecationSink) -> &Value {
         if let Some(message) = self.deprecation {
             sink.emit(message);
         }

crates/typst-library/src/foundations/ty.rs

@@ -44,6 +44,16 @@ use crate::foundations::{
 /// #type(int) \
 /// #type(type)
 /// ```
+///
+/// # Compatibility
+/// In Typst 0.7 and lower, the `type` function returned a string instead of a
+/// type. Compatibility with the old way will remain until Typst 0.14 to give
+/// package authors time to upgrade.
+///
+/// - Checks like `{int == "integer"}` evaluate to `{true}`
+/// - Adding/joining a type and string will yield a string
+/// - The `{in}` operator on a type and a dictionary will evaluate to `{true}`
+///   if the dictionary has a string key matching the type's name
 #[ty(scope, cast)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Type(Static<NativeTypeData>);
@@ -106,6 +116,14 @@ impl Type {
     }
 }
 
+// Type compatibility.
+impl Type {
+    /// The type's backward-compatible name.
+    pub fn compat_name(&self) -> &str {
+        self.long_name()
+    }
+}
+
 #[scope]
 impl Type {
     /// Determines a value's type.

crates/typst-library/src/foundations/value.rs

@@ -292,7 +292,8 @@ impl Repr for Value {
 
 impl PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-        ops::equal(self, other)
+        // No way to emit deprecation warnings here :(
+        ops::equal(self, other, &mut ())
     }
 }
 

crates/typst-library/src/loading/cbor.rs

@@ -20,9 +20,7 @@ use crate::loading::{DataSource, Load};
 #[func(scope, title = "CBOR")]
 pub fn cbor(
     engine: &mut Engine,
-    /// A path to a CBOR file or raw CBOR bytes.
+    /// A [path]($syntax/#paths) to a CBOR file or raw CBOR bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
     let data = source.load(engine.world)?;

crates/typst-library/src/loading/csv.rs

@@ -26,9 +26,7 @@ use crate::loading::{DataSource, Load, Readable};
 #[func(scope, title = "CSV")]
 pub fn csv(
     engine: &mut Engine,
-    /// Path to a CSV file or raw CSV bytes.
+    /// A [path]($syntax/#paths) to a CSV file or raw CSV bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
     /// The delimiter that separates columns in the CSV file.
     /// Must be a single ASCII character.

crates/typst-library/src/loading/json.rs

@@ -51,9 +51,7 @@ use crate::loading::{DataSource, Load, Readable};
 #[func(scope, title = "JSON")]
 pub fn json(
     engine: &mut Engine,
-    /// Path to a JSON file or raw JSON bytes.
+    /// A [path]($syntax/#paths) to a JSON file or raw JSON bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
     let data = source.load(engine.world)?;

crates/typst-library/src/loading/toml.rs

@@ -29,9 +29,7 @@ use crate::loading::{DataSource, Load, Readable};
 #[func(scope, title = "TOML")]
 pub fn toml(
     engine: &mut Engine,
-    /// A path to a TOML file or raw TOML bytes.
+    /// A [path]($syntax/#paths) to a TOML file or raw TOML bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
     let data = source.load(engine.world)?;

crates/typst-library/src/loading/xml.rs

@@ -58,9 +58,7 @@ use crate::loading::{DataSource, Load, Readable};
 #[func(scope, title = "XML")]
 pub fn xml(
     engine: &mut Engine,
-    /// A path to an XML file or raw XML bytes.
+    /// A [path]($syntax/#paths) to an XML file or raw XML bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
     let data = source.load(engine.world)?;

crates/typst-library/src/loading/yaml.rs

@@ -41,9 +41,7 @@ use crate::loading::{DataSource, Load, Readable};
 #[func(scope, title = "YAML")]
 pub fn yaml(
     engine: &mut Engine,
-    /// A path to a YAML file or raw YAML bytes.
+    /// A [path]($syntax/#paths) to a YAML file or raw YAML bytes.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
     let data = source.load(engine.world)?;

crates/typst-library/src/model/link.rs

@@ -11,7 +11,7 @@ use crate::foundations::{
 use crate::html::{attr, tag, HtmlElem};
 use crate::introspection::Location;
 use crate::layout::Position;
-use crate::text::{Hyphenate, TextElem};
+use crate::text::TextElem;
 
 /// Links to a URL or a location in the document.
 ///
@@ -138,7 +138,7 @@ impl Show for Packed<LinkElem> {
 impl ShowSet for Packed<LinkElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         let mut out = Styles::new();
-        out.set(TextElem::set_hyphenate(Hyphenate(Smart::Custom(false))));
+        out.set(TextElem::set_hyphenate(Smart::Custom(false)));
         out
     }
 }

crates/typst-library/src/model/outline.rs

@@ -623,7 +623,7 @@ impl OutlineEntry {
 
     /// The content which is displayed in place of the referred element at its
     /// entry in the outline. For a heading, this is its
-    /// [`body`]($heading.body), for a figure a caption, and for equations it is
+    /// [`body`]($heading.body); for a figure a caption and for equations, it is
     /// empty.
     #[func]
     pub fn body(&self) -> StrResult<Content> {

crates/typst-library/src/pdf/embed.rs

@@ -1,9 +1,12 @@
 use ecow::EcoString;
+use typst_library::foundations::Target;
 use typst_syntax::Spanned;
 
-use crate::diag::{At, SourceResult};
+use crate::diag::{warning, At, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{elem, Bytes, Cast, Content, Derived, Packed, Show, StyleChain};
+use crate::foundations::{
+    elem, Bytes, Cast, Content, Derived, Packed, Show, StyleChain, TargetElem,
+};
 use crate::introspection::Locatable;
 use crate::World;
 
@@ -32,12 +35,10 @@ use crate::World;
 ///   embedded file conforms to PDF/A-1 or PDF/A-2.
 #[elem(Show, Locatable)]
 pub struct EmbedElem {
-    /// Path of the file to be embedded.
+    /// The [path]($syntax/#paths) of the file to be embedded.
     ///
     /// Must always be specified, but is only read from if no data is provided
     /// in the following argument.
-    ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
     #[required]
     #[parse(
         let Spanned { v: path, span } =
@@ -80,7 +81,12 @@ pub struct EmbedElem {
 }
 
 impl Show for Packed<EmbedElem> {
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        if TargetElem::target_in(styles) == Target::Html {
+            engine
+                .sink
+                .warn(warning!(self.span(), "embed was ignored during HTML export"));
+        }
         Ok(Content::empty())
     }
 }

crates/typst-library/src/text/mod.rs

@@ -51,7 +51,6 @@ use crate::foundations::{
 };
 use crate::layout::{Abs, Axis, Dir, Em, Length, Ratio, Rel};
 use crate::math::{EquationElem, MathSize};
-use crate::model::ParElem;
 use crate::visualize::{Color, Paint, RelativeTo, Stroke};
 use crate::World;
 
@@ -504,9 +503,8 @@ pub struct TextElem {
     /// enabling hyphenation can
     /// improve justification.
     /// ```
-    #[resolve]
     #[ghost]
-    pub hyphenate: Hyphenate,
+    pub hyphenate: Smart<bool>,
 
     /// The "cost" of various choices when laying out text. A higher cost means
     /// the layout engine will make the choice less often. Costs are specified
@@ -1110,27 +1108,6 @@ impl Resolve for TextDir {
     }
 }
 
-/// Whether to hyphenate text.
-#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct Hyphenate(pub Smart<bool>);
-
-cast! {
-    Hyphenate,
-    self => self.0.into_value(),
-    v: Smart<bool> => Self(v),
-}
-
-impl Resolve for Hyphenate {
-    type Output = bool;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        match self.0 {
-            Smart::Auto => ParElem::justify_in(styles),
-            Smart::Custom(v) => v,
-        }
-    }
-}
-
 /// A set of stylistic sets to enable.
 #[derive(Debug, Copy, Clone, Default, Eq, PartialEq, Hash)]
 pub struct StylisticSets(u32);
@@ -1403,24 +1380,7 @@ pub fn is_default_ignorable(c: char) -> bool {
 fn check_font_list(engine: &mut Engine, list: &Spanned<FontList>) {
     let book = engine.world.book();
     for family in &list.v {
-        let found = book.contains_family(family.as_str());
+        if !book.contains_family(family.as_str()) {
-        if family.as_str() == "linux libertine" {
-            let mut warning = warning!(
-                list.span,
-                "Typst's default font has changed from Linux Libertine to its successor Libertinus Serif";
-                hint: "please set the font to `\"Libertinus Serif\"` instead"
-            );
-
-            if found {
-                warning.hint(
-                    "Linux Libertine is available on your system - \
-                     you can ignore this warning if you are sure you want to use it",
-                );
-                warning.hint("this warning will be removed in Typst 0.13");
-            }
-
-            engine.sink.warn(warning);
-        } else if !found {
             engine.sink.warn(warning!(
                 list.span,
                 "unknown font family: {}",

crates/typst-library/src/text/raw.rs

@@ -21,9 +21,7 @@ use crate::html::{tag, HtmlElem};
 use crate::layout::{BlockBody, BlockElem, Em, HAlignment};
 use crate::loading::{DataSource, Load};
 use crate::model::{Figurable, ParElem};
-use crate::text::{
+use crate::text::{FontFamily, FontList, LinebreakElem, LocalName, TextElem, TextSize};
-    FontFamily, FontList, Hyphenate, LinebreakElem, LocalName, TextElem, TextSize,
-};
 use crate::visualize::Color;
 use crate::World;
 
@@ -448,10 +446,14 @@ impl Show for Packed<RawElem> {
         let mut realized = Content::sequence(seq);
 
         if TargetElem::target_in(styles).is_html() {
-            return Ok(HtmlElem::new(tag::pre)
+            return Ok(HtmlElem::new(if self.block(styles) {
-                .with_body(Some(realized))
+                tag::pre
-                .pack()
+            } else {
-                .spanned(self.span()));
+                tag::code
+            })
+            .with_body(Some(realized))
+            .pack()
+            .spanned(self.span()));
         }
 
         if self.block(styles) {
@@ -472,7 +474,7 @@ impl ShowSet for Packed<RawElem> {
         let mut out = Styles::new();
         out.set(TextElem::set_overhang(false));
         out.set(TextElem::set_lang(Lang::ENGLISH));
-        out.set(TextElem::set_hyphenate(Hyphenate(Smart::Custom(false))));
+        out.set(TextElem::set_hyphenate(Smart::Custom(false)));
         out.set(TextElem::set_size(TextSize(Em::new(0.8).into())));
         out.set(TextElem::set_font(FontList(vec![FontFamily::new("DejaVu Sans Mono")])));
         out.set(TextElem::set_cjk_latin_spacing(Smart::Custom(None)));

crates/typst-library/src/text/smartquote.rs

@@ -251,6 +251,7 @@ impl<'s> SmartQuotes<'s> {
             "el" => ("‘", "’", "«", "»"),
             "he" => ("’", "’", "”", "”"),
             "hr" => ("‘", "’", "„", "”"),
+            "bg" => ("’", "’", "„", "“"),
             _ if lang.dir() == Dir::RTL => ("’", "‘", "”", "“"),
             _ => default,
         };

crates/typst-library/src/visualize/curve.rs

@@ -10,12 +10,12 @@ use crate::foundations::{
 use crate::layout::{Abs, Axes, BlockElem, Length, Point, Rel, Size};
 use crate::visualize::{FillRule, Paint, Stroke};
 
-/// A curve consisting of movements, lines, and Beziér segments.
+/// A curve consisting of movements, lines, and Bézier segments.
 ///
 /// At any point in time, there is a conceptual pen or cursor.
 /// - Move elements move the cursor without drawing.
 /// - Line/Quadratic/Cubic elements draw a segment from the cursor to a new
-///   position, potentially with control point for a Beziér curve.
+///   position, potentially with control point for a Bézier curve.
 /// - Close elements draw a straight or smooth line back to the start of the
 ///   curve or the latest preceding move segment.
 ///
@@ -26,7 +26,7 @@ use crate::visualize::{FillRule, Paint, Stroke};
 /// or relative to the current pen/cursor position, that is, the position where
 /// the previous segment ended.
 ///
-/// Beziér curve control points can be skipped by passing `{none}` or
+/// Bézier curve control points can be skipped by passing `{none}` or
 /// automatically mirrored from the preceding segment by passing `{auto}`.
 ///
 /// # Example
@@ -88,7 +88,7 @@ pub struct CurveElem {
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
-    /// The components of the curve, in the form of moves, line and Beziér
+    /// The components of the curve, in the form of moves, line and Bézier
     /// segment, and closes.
     #[variadic]
     pub components: Vec<CurveComponent>,
@@ -225,7 +225,7 @@ pub struct CurveLine {
     pub relative: bool,
 }
 
-/// Adds a quadratic Beziér curve segment from the last point to `end`, using
+/// Adds a quadratic Bézier curve segment from the last point to `end`, using
 /// `control` as the control point.
 ///
 /// ```example
@@ -245,9 +245,9 @@ pub struct CurveLine {
 /// ```
 #[elem(name = "quad", title = "Curve Quadratic Segment")]
 pub struct CurveQuad {
-    /// The control point of the quadratic Beziér curve.
+    /// The control point of the quadratic Bézier curve.
     ///
-    /// - If `{auto}` and this segment follows another quadratic Beziér curve,
+    /// - If `{auto}` and this segment follows another quadratic Bézier curve,
     ///   the previous control point will be mirrored.
     /// - If `{none}`, the control point defaults to `end`, and the curve will
     ///   be a straight line.
@@ -272,7 +272,7 @@ pub struct CurveQuad {
     pub relative: bool,
 }
 
-/// Adds a cubic Beziér curve segment from the last point to `end`, using
+/// Adds a cubic Bézier curve segment from the last point to `end`, using
 /// `control-start` and `control-end` as the control points.
 ///
 /// ```example
@@ -388,7 +388,7 @@ pub enum CloseMode {
     Straight,
 }
 
-/// A curve consisting of movements, lines, and Beziér segments.
+/// A curve consisting of movements, lines, and Bézier segments.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
 pub struct Curve(pub Vec<CurveItem>);
 

crates/typst-library/src/visualize/gradient.rs

@@ -582,12 +582,11 @@ impl Gradient {
                 let mut stops = stops
                     .iter()
                     .map(move |&(color, offset)| {
-                        let t = i as f64 / n as f64;
                         let r = offset.get();
                         if i % 2 == 1 && mirror {
-                            (color, Ratio::new(t + (1.0 - r) / n as f64))
+                            (color, Ratio::new((i as f64 + 1.0 - r) / n as f64))
                         } else {
-                            (color, Ratio::new(t + r / n as f64))
+                            (color, Ratio::new((i as f64 + r) / n as f64))
                         }
                     })
                     .collect::<Vec<_>>();
@@ -1230,7 +1229,7 @@ fn process_stops(stops: &[Spanned<GradientStop>]) -> SourceResult<Vec<(Color, Ra
             };
 
             if stop.get() < last_stop {
-                bail!(*span, "offsets must be in strictly monotonic order");
+                bail!(*span, "offsets must be in monotonic order");
             }
 
             last_stop = stop.get();

crates/typst-library/src/visualize/image/mod.rs

@@ -46,10 +46,11 @@ use crate::text::LocalName;
 /// ```
 #[elem(scope, Show, LocalName, Figurable)]
 pub struct ImageElem {
-    /// A path to an image file or raw bytes making up an image in one of the
+    /// A [path]($syntax/#paths) to an image file or raw bytes making up an
-    /// supported [formats]($image.format).
+    /// image in one of the supported [formats]($image.format).
     ///
-    /// For more details about paths, see the [Paths section]($syntax/#paths).
+    /// Bytes can be used to specify raw pixel data in a row-major,
+    /// left-to-right, top-to-bottom format.
     ///
     /// ```example
     /// #let original = read("diagram.svg")
@@ -397,8 +398,7 @@ impl ImageFormat {
             return Some(Self::Raster(RasterFormat::Exchange(format)));
         }
 
-        // SVG or compressed SVG.
+        if is_svg(data) {
-        if data.starts_with(b"<svg") || data.starts_with(&[0x1f, 0x8b]) {
             return Some(Self::Vector(VectorFormat::Svg));
         }
 
@@ -406,6 +406,21 @@ impl ImageFormat {
     }
 }
 
+/// Checks whether the data looks like an SVG or a compressed SVG.
+fn is_svg(data: &[u8]) -> bool {
+    // Check for the gzip magic bytes. This check is perhaps a bit too
+    // permissive as other formats than SVGZ could use gzip.
+    if data.starts_with(&[0x1f, 0x8b]) {
+        return true;
+    }
+
+    // If the first 2048 bytes contain the SVG namespace declaration, we assume
+    // that it's an SVG. Note that, if the SVG does not contain a namespace
+    // declaration, usvg will reject it.
+    let head = &data[..data.len().min(2048)];
+    memchr::memmem::find(head, b"http://www.w3.org/2000/svg").is_some()
+}
+
 /// A vector graphics format.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
 pub enum VectorFormat {

crates/typst-library/src/visualize/image/raster.rs

@@ -160,6 +160,8 @@ impl RasterImage {
     }
 
     /// The image's pixel density in pixels per inch, if known.
+    ///
+    /// This is guaranteed to be positive.
     pub fn dpi(&self) -> Option<f64> {
         self.0.dpi
     }
@@ -334,6 +336,9 @@ fn apply_rotation(image: &mut DynamicImage, rotation: u32) {
 }
 
 /// Try to determine the DPI (dots per inch) of the image.
+///
+/// This is guaranteed to be a positive value, or `None` if invalid or
+/// unspecified.
 fn determine_dpi(data: &[u8], exif: Option<&exif::Exif>) -> Option<f64> {
     // Try to extract the DPI from the EXIF metadata. If that doesn't yield
     // anything, fall back to specialized procedures for extracting JPEG or PNG
@@ -341,6 +346,7 @@ fn determine_dpi(data: &[u8], exif: Option<&exif::Exif>) -> Option<f64> {
     exif.and_then(exif_dpi)
         .or_else(|| jpeg_dpi(data))
         .or_else(|| png_dpi(data))
+        .filter(|&dpi| dpi > 0.0)
 }
 
 /// Try to get the DPI from the EXIF metadata.

crates/typst-library/src/visualize/path.rs

@@ -8,7 +8,7 @@ use crate::foundations::{
 use crate::layout::{Axes, BlockElem, Length, Rel};
 use crate::visualize::{FillRule, Paint, Stroke};
 
-/// A path through a list of points, connected by Bezier curves.
+/// A path through a list of points, connected by Bézier curves.
 ///
 /// # Example
 /// ```example
@@ -59,8 +59,8 @@ pub struct PathElem {
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
-    /// Whether to close this path with one last bezier curve. This curve will
+    /// Whether to close this path with one last Bézier curve. This curve will
-    /// takes into account the adjacent control points. If you want to close
+    /// take into account the adjacent control points. If you want to close
     /// with a straight line, simply add one last point that's the same as the
     /// start point.
     #[default(false)]

crates/typst-library/src/visualize/shape.rs

@@ -412,7 +412,7 @@ pub enum Geometry {
     Line(Point),
     /// A rectangle with its origin in the topleft corner.
     Rect(Size),
-    /// A curve consisting of movements, lines, and Bezier segments.
+    /// A curve consisting of movements, lines, and Bézier segments.
     Curve(Curve),
 }
 

docs/changelog/0.13.0.md

@@ -1,9 +1,9 @@
 ---
-title: Unreleased changes planned for 0.13.0
+title: 0.13.0
-description: Changes slated to appear in Typst 0.13.0
+description: Changes in Typst 0.13.0
 ---
 
-# Unreleased
+# Version 0.13.0 (February 19, 2025)
 
 ## Highlights
 - There is now a distinction between [proper paragraphs]($par) and just
@@ -16,7 +16,7 @@ description: Changes slated to appear in Typst 0.13.0
 - The `image` function now supports raw [pixel raster formats]($image.format)
   for generating images from within Typst
 - Functions that accept [file paths]($syntax/#paths) now also accept raw
-  [bytes] instead, for full flexibility
+  [bytes], for full flexibility
 - WebAssembly [plugins]($plugin) are more flexible and automatically run
   multi-threaded
 - Fixed a long-standing bug where single-letter strings in math (`[$"a"$]`)
@@ -45,6 +45,7 @@ description: Changes slated to appear in Typst 0.13.0
     result in a warning
   - The default show rules of various built-in elements like lists, quotes, etc.
     were adjusted to ensure they produce/don't produce paragraphs as appropriate
+  - Removed support for booleans and content in [`outline.indent`]
 - The [`outline`] function was fully reworked to improve its out-of-the-box
   behavior **(Breaking change)**
   - [Outline entries]($outline.entry) are now [blocks]($block) and are thus
@@ -98,8 +99,9 @@ description: Changes slated to appear in Typst 0.13.0
 - Fixed interaction of clipping and outset on [`box`] and [`block`]
 - Fixed panic with [`path`] of infinite length
 - Fixed non-solid (e.g. tiling) text fills in clipped blocks
-- Auto-detection of image formats from a raw buffer now has basic support for
+- Fixed a crash for images with a DPI value of zero
-  SVGs
+- Fixed floating-point error in [`gradient.repeat`]
+- Auto-detection of image formats from a raw buffer now has support for SVGs
 
 ## Scripting
 - Functions that accept [file paths]($syntax/#paths) now also accept raw
@@ -155,7 +157,7 @@ description: Changes slated to appear in Typst 0.13.0
 - Fixed multi-line annotations (e.g. overbrace) changing the math baseline
 - Fixed merging of attachments when the base is a nested equation
 - Fixed resolving of contextual (em-based) text sizes within math
-- Fixed spacing around ⊥
+- Fixed spacing around up tacks (⊥)
 
 ## Bibliography
 - Prose and author-only citations now use editor names if the author names are
@@ -186,12 +188,12 @@ description: Changes slated to appear in Typst 0.13.0
 - [CJK-Latin-spacing]($text.cjk-latin-spacing) does not affect [raw] text
   anymore
 - Fixed wrong language codes being used for Greek and Ukrainian
-- Fixed default quotes for Croatian
+- Fixed default quotes for Croatian and Bulgarian
 - Fixed crash in RTL text handling
 - Added support for [`raw`] syntax highlighting for a few new languages: CFML,
   NSIS, and WGSL
 - New font metadata exception for New Computer Modern Sans Math
-- Updated bundled New Computer Modern fonts to version 7.0
+- Updated bundled New Computer Modern fonts to version 7.0.1
 
 ## Layout
 - Fixed various bugs with footnotes
@@ -229,7 +231,7 @@ description: Changes slated to appear in Typst 0.13.0
 - A shebang `#!` at the very start of a file is now ignored
 
 ## PDF export
-- Added `pdf.embed` function for embedding arbitrary files in the exported PDF
+- Added [`pdf.embed`] function for embedding arbitrary files in the exported PDF
 - Added support for PDF/A-3b export
 - The PDF timestamp will now contain the timezone by default
 
@@ -270,6 +272,9 @@ feature flag.
 - Added a live reloading HTTP server to `typst watch` when targeting HTML
 - Fixed self-update not being aware about certain target architectures
 - Fixed crash when piping `typst fonts` output to another command
+- Fixed handling of relative paths in `--make-deps` output
+- Fixed handling of multipage SVG and PNG export in `--make-deps` output
+- Colons in filenames are now correctly escaped in `--make-deps` output
 
 ## Symbols
 - New
@@ -312,8 +317,20 @@ feature flag.
   functions directly accepting both paths and bytes
 - The `sect` and its variants in favor of `inter`, and `integral.sect` in favor
   of `integral.inter`
-- Fully removed type/str compatibility behavior (e.g. `{int == "integer"}`)
+- The compatibility behavior of type/str comparisons (e.g. `{int == "integer"}`)
-  which was temporarily introduced in Typst 0.8 **(Breaking change)**
+  which was temporarily introduced in Typst 0.8 now emits warnings. It will be
+  removed in Typst 0.14.
+
+## Removals
+- Removed `style` function and `styles` argument of [`measure`], use a [context]
+  expression instead **(Breaking change)**
+- Removed `state.display` function, use [`state.get`] instead
+  **(Breaking change)**
+- Removed `location` argument of [`state.at`], [`counter.at`], and [`query`]
+  **(Breaking change)**
+- Removed compatibility behavior where [`counter.display`] worked without
+  [context] **(Breaking change)**
+- Removed compatibility behavior of [`locate`] **(Breaking change)**
 
 ## Development
 - The `typst::compile` function is now generic and can return either a
@@ -322,3 +339,6 @@ feature flag.
   feature is enabled
 - Increased minimum supported Rust version to 1.80
 - Fixed linux/arm64 Docker image
+
+## Contributors
+<contributors from="v0.12.0" to="v0.13.0" />

docs/changelog/welcome.md

@@ -10,7 +10,7 @@ forward. This section documents all changes to Typst since its initial public
 release.
 
 ## Versions
-- [Unreleased changes planned for Typst 0.13.0]($changelog/0.13.0)
+- [Typst 0.13.0]($changelog/0.13.0)
 - [Typst 0.12.0]($changelog/0.12.0)
 - [Typst 0.11.1]($changelog/0.11.1)
 - [Typst 0.11.0]($changelog/0.11.0)

docs/reference/export/png.md

@@ -11,7 +11,7 @@ the PNG you exported, you will notice a loss of quality. Typst calculates the
 resolution of your PNGs based on each page's physical dimensions and the PPI. If
 you need guidance for choosing a PPI value, consider the following:
 
-- A DPI value of 300 or 600 is typical for desktop printing.
+- A value of 300 or 600 is typical for desktop printing.
 - Professional prints of detailed graphics can go up to 1200 PPI.
 - If your document is only viewed at a distance, e.g. a poster, you may choose a
   smaller value than 300.

docs/src/lib.rs

@@ -550,8 +550,6 @@ fn func_outline(model: &FuncModel, id_base: &str) -> Vec<OutlineItem> {
                     .collect(),
             });
         }
-
-        outline.extend(scope_outline(&model.scope));
     } else {
         outline.extend(model.params.iter().map(|param| OutlineItem {
             id: eco_format!("{id_base}-{}", urlify(param.name)),
@@ -560,27 +558,30 @@ fn func_outline(model: &FuncModel, id_base: &str) -> Vec<OutlineItem> {
         }));
     }
 
+    outline.extend(scope_outline(&model.scope, id_base));
+
     outline
 }
 
 /// Produce an outline for a function scope.
-fn scope_outline(scope: &[FuncModel]) -> Option<OutlineItem> {
+fn scope_outline(scope: &[FuncModel], id_base: &str) -> Option<OutlineItem> {
     if scope.is_empty() {
         return None;
     }
 
-    Some(OutlineItem {
+    let dash = if id_base.is_empty() { "" } else { "-" };
-        id: "definitions".into(),
+    let id = eco_format!("{id_base}{dash}definitions");
-        name: "Definitions".into(),
+
-        children: scope
+    let children = scope
-            .iter()
+        .iter()
-            .map(|func| {
+        .map(|func| {
-                let id = urlify(&eco_format!("definitions-{}", func.name));
+            let id = urlify(&eco_format!("{id}-{}", func.name));
-                let children = func_outline(func, &id);
+            let children = func_outline(func, &id);
-                OutlineItem { id, name: func.title.into(), children }
+            OutlineItem { id, name: func.title.into(), children }
-            })
+        })
-            .collect(),
+        .collect();
-    })
+
+    Some(OutlineItem { id, name: "Definitions".into(), children })
 }
 
 /// Create a page for a group of functions.
@@ -687,7 +688,7 @@ fn type_outline(model: &TypeModel) -> Vec<OutlineItem> {
         });
     }
 
-    outline.extend(scope_outline(&model.scope));
+    outline.extend(scope_outline(&model.scope, ""));
     outline
 }
 

tests/src/world.rs

@@ -251,6 +251,6 @@ fn lines(
     (1..=count)
         .map(|n| numbering.apply(engine, context, &[n]))
         .collect::<SourceResult<Array>>()?
-        .join(Some('\n'.into_value()), None)
+        .join(engine, span, Some('\n'.into_value()), None)
         .at(span)
 }

tests/suite/foundations/type.typ

@@ -2,6 +2,60 @@
 #test(type(1), int)
 #test(type(ltr), direction)
 #test(type(10 / 3), float)
+#test(type(10) == int, true)
+#test(type(10) != int, false)
+
+--- type-string-compatibility-add ---
+// Warning: 7-23 adding strings and types is deprecated
+// Hint: 7-23 convert the type to a string with `str` first
+#test("is " + type(10), "is integer")
+// Warning: 7-23 adding strings and types is deprecated
+// Hint: 7-23 convert the type to a string with `str` first
+#test(type(10) + " is", "integer is")
+
+--- type-string-compatibility-join ---
+// Warning: 16-24 joining strings and types is deprecated
+// Hint: 16-24 convert the type to a string with `str` first
+#test({ "is "; type(10) }, "is integer")
+// Warning: 19-24 joining strings and types is deprecated
+// Hint: 19-24 convert the type to a string with `str` first
+#test({ type(10); " is" }, "integer is")
+
+--- type-string-compatibility-equal ---
+// Warning: 7-28 comparing strings with types is deprecated
+// Hint: 7-28 compare with the literal type instead
+// Hint: 7-28 this comparison will always return `false` in future Typst releases
+#test(type(10) == "integer", true)
+// Warning: 7-26 comparing strings with types is deprecated
+// Hint: 7-26 compare with the literal type instead
+// Hint: 7-26 this comparison will always return `false` in future Typst releases
+#test(type(10) != "float", true)
+
+--- type-string-compatibility-in-array ---
+// Warning: 7-35 comparing strings with types is deprecated
+// Hint: 7-35 compare with the literal type instead
+// Hint: 7-35 this comparison will always return `false` in future Typst releases
+#test(int in ("integer", "string"), true)
+// Warning: 7-37 comparing strings with types is deprecated
+// Hint: 7-37 compare with the literal type instead
+// Hint: 7-37 this comparison will always return `false` in future Typst releases
+#test(float in ("integer", "string"), false)
+
+--- type-string-compatibility-in-str ---
+// Warning: 7-35 checking whether a type is contained in a string is deprecated
+// Hint: 7-35 this compatibility behavior only exists because `type` used to return a string
+#test(int in "integers or strings", true)
+// Warning: 7-35 checking whether a type is contained in a string is deprecated
+// Hint: 7-35 this compatibility behavior only exists because `type` used to return a string
+#test(str in "integers or strings", true)
+// Warning: 7-37 checking whether a type is contained in a string is deprecated
+// Hint: 7-37 this compatibility behavior only exists because `type` used to return a string
+#test(float in "integers or strings", false)
+
+--- type-string-compatibility-in-dict ---
+// Warning: 7-37 checking whether a type is contained in a dictionary is deprecated
+// Hint: 7-37 this compatibility behavior only exists because `type` used to return a string
+#test(int in (integer: 1, string: 2), true)
 
 --- issue-3110-type-constructor ---
 // Let the error message report the type name.

tests/suite/model/par.typ

@@ -322,6 +322,20 @@ A
 
 #context test(query(<a>).len(), 1)
 
+--- issue-5831-par-constructor-args ---
+// Make sure that all arguments are also respected in the constructor.
+A
+#par(
+  leading: 2pt,
+  spacing: 20pt,
+  justify: true,
+  linebreaks: "simple",
+  first-line-indent: (amount: 1em, all: true),
+  hanging-indent: 5pt,
+)[
+  The par function has a constructor and justification.
+]
+
 --- show-par-set-block-hint ---
 // Warning: 2-36 `show par: set block(spacing: ..)` has no effect anymore
 // Hint: 2-36 this is specific to paragraphs as they are not considered blocks anymore

tests/suite/scripting/import.typ

@@ -255,6 +255,10 @@
 // Warning: 17-21 unnecessary import rename to same name
 #import enum as enum
 
+--- import-rename-necessary ---
+#import "module.typ" as module: a
+#test(module.a, a)
+
 --- import-rename-unnecessary-mixed ---
 // Warning: 17-21 unnecessary import rename to same name
 #import enum as enum: item
@@ -263,10 +267,6 @@
 // Warning: 31-35 unnecessary import rename to same name
 #import enum as enum: item as item
 
---- import-item-rename-unnecessary-string ---
-// Warning: 25-31 unnecessary import rename to same name
-#import "module.typ" as module
-
 --- import-item-rename-unnecessary-but-ok ---
 #import "modul" + "e.typ" as module
 #test(module.b, 1)

tests/suite/text/font.typ

@@ -77,11 +77,6 @@ I
 #let var = text(font: ("list-of", "nonexistent-fonts"))[don't]
 #var
 
---- text-font-linux-libertine ---
-// Warning: 17-34 Typst's default font has changed from Linux Libertine to its successor Libertinus Serif
-// Hint: 17-34 please set the font to `"Libertinus Serif"` instead
-#set text(font: "Linux Libertine")
-
 --- issue-5499-text-fill-in-clip-block ---
 
 #let t = tiling(

tests/suite/visualize/gradient.typ

@@ -658,3 +658,11 @@ $ A = mat(
   height: 10pt,
   fill: gradient.linear(violet, blue, space: cmyk)
 )
+
+--- issue-5819-gradient-repeat ---
+// Ensure the gradient constructor generates monotonic stops which can be fed
+// back into the gradient constructor itself.
+#let my-gradient = gradient.linear(red, blue).repeat(5)
+#let _ = gradient.linear(..my-gradient.stops())
+#let my-gradient2 = gradient.linear(red, blue).repeat(5, mirror: true)
+#let _ = gradient.linear(..my-gradient2.stops())

tests/suite/visualize/image.typ

@@ -65,6 +65,17 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
   caption: [Bilingual text]
 )
 
+--- image-svg-auto-detection ---
+#image(bytes(
+  ```
+  <?xml version="1.0" encoding="utf-8"?>
+  <!-- An SVG -->
+  <svg width="200" height="150" xmlns="http://www.w3.org/2000/svg">
+    <rect fill="red" stroke="black" x="25" y="25" width="150" height="100"/>
+  </svg>
+  ```.text
+))
+
 --- image-pixmap-rgb8 ---
 #image(
   bytes((
@@ -152,8 +163,8 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 #image("path/does/not/exist")
 
 --- image-bad-format ---
-// Error: 2-22 unknown image format
+// Error: 2-37 unknown image format
-#image("./image.typ")
+#image("/assets/plugins/hello.wasm")
 
 --- image-bad-svg ---
 // Error: 2-33 failed to parse SVG (found closing tag 'g' instead of 'style' in line 4)