typst 0.13.5 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e4b47eadd66459fc03839fddfb0d95a2757a63c5ed6475bf0000ac6a8edf72b
-  data.tar.gz: 2bfe1a0c9e7d542d6f64d59de0c777a86a3c56f11962c997f6a0e378e5a348d2
+  metadata.gz: 5e9d8a961dbfb1f5c4b2abcc506c2a4b8d51aa65bc628837f853c1d1cf27b769
+  data.tar.gz: c9268f5475181810a42292ae8f85df0d8943462e48912568ba37e1896071b689
 SHA512:
-  metadata.gz: e5626d390a3e6f3d844b0e91e3df609d9a167d2b1b496634b50133110b57ed7a2756db3c6ee23de327849d22ddc5d45a9088af576a26512d49afef31e0b0aae6
-  data.tar.gz: ff150b69ed67845d4a4a48f1b1bda2421905dc7a035270f1ae6a5ec8ad2911523499bb23256b1e2aa10f0c5ab51f74f27201e33b2f6827c3db4f4adb1e630870
+  metadata.gz: bb05e491212ca31f0d4b9dd61fd42338117abc3b0f692c18767763705c592ebcbbc2b55592c3f3f9465183e9979390e462d635c070cbd548b48ac47c72dd4c8d
+  data.tar.gz: 0e7efcc12d9b6ad8720441b604ec6c31053341ec5094544d7dcb2313577afd344c5bbf386d37105f06988cd80fcea6b7c324a19f699ef580b0d18a9208db6d89

data/Rakefile

@@ -40,8 +40,8 @@ task 'gem:native' do |t|
 end
 
 task 'gem:native:push' do |t|
+  sh "gem signin"
   CROSS_PLATFORMS.each do |platform|
-    sh "gem signin"
     sh "gem push pkg/typst-#{spec.version}-#{platform}.gem"
   end
 end

data/ext/typst/Cargo.toml

@@ -1,18 +1,18 @@
 [package]
 name = "typst"
-version = "0.13.5"
+version = "0.14.2"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
-chrono = { version = "0.4.38", default-features = false, features = [
+chrono = { version = "0.4.42", default-features = false, features = [
     "clock",
     "std",
 ] }
-codespan-reporting = "0.11"
-comemo = "0.4"
+codespan-reporting = "0.13"
+comemo = "0.5.0"
 dirs = "5" #
 ecow = "0.2"
 env_logger = "0.10.1" #
@@ -28,21 +28,21 @@ siphasher = "1.0" #
 tar = "0.4" #
 #typst = { git = "https://github.com/typst/typst.git", tag = "v0.13.0" }
 #typst-library = { git = "https://github.com/typst/typst.git", tag = "v0.13.0" }
-serde = { version = "1.0.217", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
-typst = "0.13.1"
-typst-library  = "0.13.1"
-typst-kit = { version = "0.13.1", features = [
+typst = "0.14.2"
+typst-library  = "0.14.2"
+typst-kit = { version = "0.14.2", features = [
     "downloads",
     "embed-fonts",
     "vendor-openssl",
 ] }
-typst-pdf = "0.13.1"
-typst-svg = "0.13.1"
-typst-html = "0.13.1"
-typst-render = "0.13.1"
-typst-eval = "0.13.1"
+typst-pdf = "0.14.2"
+typst-svg = "0.14.2"
+typst-html = "0.14.2"
+typst-render = "0.14.2"
+typst-eval = "0.14.2"
 ureq = { version = "2", default-features = false, features = [
     "gzip",
     "socks-proxy",
@@ -51,4 +51,4 @@ walkdir = "2.4.0"
 
 # enable rb-sys feature to test against Ruby head. This is only needed if you
 # want to work with the unreleased, in-development, next version of Ruby
-rb-sys = { version = "0.9.116", default-features = false, features = ["stable-api-compiled-fallback"] }
+rb-sys = { version = "0.9.119", default-features = false, features = ["stable-api-compiled-fallback"] }

data/ext/typst/src/compiler.rs

@@ -4,9 +4,10 @@ use codespan_reporting::term::{self, termcolor};
 use ecow::{eco_format, EcoString};
 use typst::diag::{Severity, SourceDiagnostic, StrResult, Warned};
 use typst::foundations::Datetime;
-use typst::html::HtmlDocument;
+use typst_html::HtmlDocument;
 use typst::layout::PagedDocument;
-use typst::syntax::{FileId, Source, Span};
+//use typst::syntax::{FileId, Source, Span};
+use typst::syntax::{FileId, Lines, Span};
 use typst::{World, WorldExt};
 
 use crate::world::SystemWorld;
@@ -167,7 +168,7 @@ pub fn format_diagnostics(
         )
         .with_labels(label(world, diagnostic.span).into_iter().collect());
 
-        term::emit(&mut w, &config, world, &diag)?;
+        term::emit_to_write_style(&mut w, &config, world, &diag)?;
 
         // Stacktrace-like helper diagnostics.
         for point in &diagnostic.trace {
@@ -176,7 +177,7 @@ pub fn format_diagnostics(
                 .with_message(message)
                 .with_labels(label(world, point.span).into_iter().collect());
 
-            term::emit(&mut w, &config, world, &help)?;
+            term::emit_to_write_style(&mut w, &config, world, &help)?;
         }
     }
 
@@ -192,7 +193,7 @@ fn label(world: &SystemWorld, span: Span) -> Option<Label<FileId>> {
 impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
     type FileId = FileId;
     type Name = String;
-    type Source = Source;
+    type Source = Lines<String>;
 
     fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
         let vpath = id.vpath();

data/ext/typst/src/query.rs

@@ -2,11 +2,13 @@ use comemo::Track;
 use ecow::{eco_format, EcoString};
 use serde::Serialize;
 use typst::diag::{bail, StrResult, Warned};
+use typst::engine::Sink;
 use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
 use typst::layout::PagedDocument;
 use typst::syntax::Span;
+use typst::syntax::SyntaxMode;
 use typst::World;
-use typst_eval::{eval_string, EvalMode};
+use typst_eval::eval_string; //{eval_string, EvalMode};
 
 use crate::world::SystemWorld;
 
@@ -73,9 +75,10 @@ fn retrieve(
     let selector = eval_string(
         &typst::ROUTINES,
         world.track(),
+        Sink::new().track_mut(),
         &command.selector,
         Span::detached(),
-        EvalMode::Code,
+        SyntaxMode::Code,
         Scope::default(),
     )
     .map_err(|errors| {

data/ext/typst/src/world.rs

@@ -3,13 +3,14 @@ use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};
 
 use chrono::{DateTime, Datelike, Local};
+//use rustc_hash::FxHashMap;
 use ecow::eco_format;
 use typst::diag::{FileError, FileResult, StrResult};
 use typst::foundations::{Bytes, Datetime, Dict};
-use typst::syntax::{FileId, Source, VirtualPath};
+use typst::syntax::{FileId, Lines, Source, VirtualPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
-use typst::{Features, Library, LibraryBuilder, World};
+use typst::{Features, Library, LibraryExt, World};
 use typst_kit::{
     fonts::{FontSearcher, FontSlot},
     package::PackageStorage,
@@ -129,9 +130,20 @@ impl SystemWorld {
 
     /// Lookup a source file by id.
     #[track_caller]
-    pub fn lookup(&self, id: FileId) -> Source {
-        self.source(id)
-            .expect("file id does not point to any source file")
+    pub fn lookup(&self, id: FileId) -> Lines<String> {
+//        self.source(id)
+//            .expect("file id does not point to any source file")
+        self.slot(id, |slot| {
+            if let Some(source) = slot.source.get() {
+                let source = source.as_ref().expect("file is not valid");
+                source.lines().clone()
+            } else if let Some(bytes) = slot.file.get() {
+                let bytes = bytes.as_ref().expect("file is not valid");
+                Lines::try_from(bytes).expect("file is not valid utf-8")
+            } else {
+                panic!("file id does not point to any source file");
+            }
+        })
     }
 }
 
@@ -193,7 +205,7 @@ impl SystemWorldBuilder {
             input,
             root: self.root,
             main: FileId::new(None, main_path),
-            library: LazyHash::new(LibraryBuilder::default().with_inputs(self.inputs).with_features(self.features).build()),
+            library: LazyHash::new(Library::builder().with_inputs(self.inputs).with_features(self.features).build()),
             book: LazyHash::new(fonts.book),
             fonts: fonts.fonts,
             slots: Mutex::default(),
@@ -300,6 +312,11 @@ impl<T: Clone> SlotCell<T> {
         self.accessed = false;
     }
 
+    /// Gets the contents of the cell.
+    fn get(&self) -> Option<&FileResult<T>> {
+        self.data.as_ref()
+    }
+
     /// Gets the contents of the cell or initialize them.
     fn get_or_init(
         &mut self,

metadata

@@ -1,57 +1,62 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.13.5
+  version: 0.14.2
 platform: ruby
 authors:
 - Flinn
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.116
+        version: 0.9.119
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.116
+        version: 0.9.119
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: hexapdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +71,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
-description:
 email: flinn@actsasflinn.com
 executables: []
 extensions:
@@ -79,7 +83,6 @@ files:
 - Rakefile
 - ext/typst/Cargo.toml
 - ext/typst/extconf.rb
-- ext/typst/src/compiler-new.rs
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
 - ext/typst/src/fonts.rs
@@ -110,11 +113,12 @@ files:
 - lib/formats/svg.rb
 - lib/query.rb
 - lib/typst.rb
+- lib/typst/typst.bundle
+- lib/typst/typst.so
 homepage: https://github.com/actsasflinn/typst-rb
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -129,8 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.

data/ext/typst/src/compiler-new.rs

@@ -1,771 +0,0 @@
-use std::ffi::OsStr;
-use std::fs::{self, File};
-use std::io::{self, Write};
-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;
-//use parking_lot::RwLock;
-use pathdiff::diff_paths;
-//use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use typst::diag::{
-    bail, At, Severity, SourceDiagnostic, SourceResult, StrResult, Warned,
-};
-use typst::foundations::{Datetime, Smart};
-use typst::html::HtmlDocument;
-use typst::layout::{Frame, Page, PageRanges, PagedDocument};
-use typst::syntax::{FileId, Source, Span};
-use typst::WorldExt;
-use typst_pdf::{PdfOptions, PdfStandards, Timestamp};
-
-use typst_cli::args::{
-    CompileArgs, CompileCommand, DiagnosticFormat, Input, Output, OutputFormat,
-    PdfStandard, WatchCommand,
-};
-//#[cfg(feature = "http-server")]
-//use crate::server::HtmlServer;
-//use crate::timings::Timer;
-
-//use crate::watch::Status;
-use crate::world::SystemWorld;
-//use crate::{set_failed, terminal};
-
-type CodespanResult<T> = Result<T, CodespanError>;
-type CodespanError = codespan_reporting::files::Error;
-
-/*
-/// Execute a compilation command.
-pub fn compile(timer: &mut Timer, command: &CompileCommand) -> StrResult<()> {
-    let mut config = CompileConfig::new(command)?;
-    let mut world =
-        SystemWorld::new(&command.args.input, &command.args.world, &command.args.process)
-            .map_err(|err| eco_format!("{err}"))?;
-    timer.record(&mut world, |world| compile_once(world, &mut config))?
-}
-*/
-
-/// A preprocessed `CompileCommand`.
-pub struct CompileConfig {
-    /// Whether we are watching.
-    pub watching: bool,
-    /// Path to input Typst file or stdin.
-    pub input: Input,
-    /// Path to output file (PDF, PNG, SVG, or HTML).
-    pub output: Output,
-    /// The format of the output file.
-    pub output_format: OutputFormat,
-    /// Which pages to export.
-    pub pages: Option<PageRanges>,
-    /// The document's creation date formatted as a UNIX timestamp, with UTC suffix.
-    pub creation_timestamp: Option<DateTime<Utc>>,
-    /// The format to emit diagnostics in.
-    pub diagnostic_format: DiagnosticFormat,
-    /// Opens the output file with the default viewer or a specific program after
-    /// compilation.
-    pub open: Option<Option<String>>,
-    /// One (or multiple comma-separated) PDF standards that Typst will enforce
-    /// conformance with.
-    pub pdf_standards: PdfStandards,
-    /// A path to write a Makefile rule describing the current compilation.
-    pub make_deps: Option<PathBuf>,
-    /// The PPI (pixels per inch) to use for PNG export.
-    pub ppi: f32,
-    /// The export cache for images, used for caching output files in `typst
-    /// watch` sessions with images.
-    pub export_cache: ExportCache,
-//    /// Server for `typst watch` to HTML.
-//    #[cfg(feature = "http-server")]
-//    pub server: Option<HtmlServer>,
-}
-
-impl CompileConfig {
-    /// Preprocess a `CompileCommand`, producing a compilation config.
-    pub fn new(command: &CompileCommand) -> StrResult<Self> {
-        Self::new_impl(&command.args, None)
-    }
-
-    /// Preprocess a `WatchCommand`, producing a compilation config.
-    pub fn watching(command: &WatchCommand) -> StrResult<Self> {
-        Self::new_impl(&command.args, Some(command))
-    }
-
-    /// The shared implementation of [`CompileConfig::new`] and
-    /// [`CompileConfig::watching`].
-    fn new_impl(args: &CompileArgs, watch: Option<&WatchCommand>) -> StrResult<Self> {
-        let input = args.input.clone();
-
-        let output_format = if let Some(specified) = args.format {
-            specified
-        } else if let Some(Output::Path(output)) = &args.output {
-            match output.extension() {
-                Some(ext) if ext.eq_ignore_ascii_case("pdf") => OutputFormat::Pdf,
-                Some(ext) if ext.eq_ignore_ascii_case("png") => OutputFormat::Png,
-                Some(ext) if ext.eq_ignore_ascii_case("svg") => OutputFormat::Svg,
-                Some(ext) if ext.eq_ignore_ascii_case("html") => OutputFormat::Html,
-                _ => bail!(
-                    "could not infer output format for path {}.\n\
-                     consider providing the format manually with `--format/-f`",
-                    output.display()
-                ),
-            }
-        } else {
-            OutputFormat::Pdf
-        };
-
-        let output = args.output.clone().unwrap_or_else(|| {
-            let Input::Path(path) = &input else {
-                panic!("output must be specified when input is from stdin, as guarded by the CLI");
-            };
-            Output::Path(path.with_extension(
-                match output_format {
-                    OutputFormat::Pdf => "pdf",
-                    OutputFormat::Png => "png",
-                    OutputFormat::Svg => "svg",
-                    OutputFormat::Html => "html",
-                },
-            ))
-        });
-
-        let pages = args.pages.as_ref().map(|export_ranges| {
-            PageRanges::new(export_ranges.iter().map(|r| r.0.clone()).collect())
-        });
-
-        let pdf_standards = {
-            let list = args
-                .pdf_standard
-                .iter()
-                .map(|standard| match standard {
-                    PdfStandard::V_1_7 => typst_pdf::PdfStandard::V_1_7,
-                    PdfStandard::A_2b => typst_pdf::PdfStandard::A_2b,
-                    PdfStandard::A_3b => typst_pdf::PdfStandard::A_3b,
-                })
-                .collect::<Vec<_>>();
-            PdfStandards::new(&list)?
-        };
-
-        /*
-        #[cfg(feature = "http-server")]
-        let server = match watch {
-            Some(command)
-                if output_format == OutputFormat::Html && !command.server.no_serve =>
-            {
-                Some(HtmlServer::new(&input, &command.server)?)
-            }
-            _ => None,
-        };
-        */
-
-        Ok(Self {
-            watching: watch.is_some(),
-            input,
-            output,
-            output_format,
-            pages,
-            pdf_standards,
-            creation_timestamp: args.world.creation_timestamp,
-            make_deps: args.make_deps.clone(),
-            ppi: args.ppi,
-            diagnostic_format: args.process.diagnostic_format,
-            open: args.open.clone(),
-            export_cache: ExportCache::new(),
-            //#[cfg(feature = "http-server")]
-            //server,
-        })
-    }
-}
-
-/// Compile a single time.
-///
-/// Returns whether it compiled without errors.
-#[typst_macros::time(name = "compile once")]
-pub fn compile_once(
-    world: &mut SystemWorld,
-    config: &mut CompileConfig,
-) -> StrResult<()> {
-    let start = std::time::Instant::now();
-    if config.watching {
-        Status::Compiling.print(config).unwrap();
-    }
-
-    let Warned { output, warnings } = compile_and_export(world, config);
-
-    match output {
-        // Export the PDF / PNG.
-        Ok(outputs) => {
-            let duration = start.elapsed();
-
-            if config.watching {
-                if warnings.is_empty() {
-                    Status::Success(duration).print(config).unwrap();
-                } else {
-                    Status::PartialSuccess(duration).print(config).unwrap();
-                }
-            }
-
-            print_diagnostics(world, &[], &warnings, config.diagnostic_format)
-                .map_err(|err| eco_format!("failed to print diagnostics ({err})"))?;
-
-            write_make_deps(world, config, outputs)?;
-            open_output(config)?;
-        }
-
-        // Print diagnostics.
-        Err(errors) => {
-            set_failed();
-
-            if config.watching {
-                Status::Error.print(config).unwrap();
-            }
-
-            print_diagnostics(world, &errors, &warnings, config.diagnostic_format)
-                .map_err(|err| eco_format!("failed to print diagnostics ({err})"))?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Compile and then export the document.
-fn compile_and_export(
-    world: &mut SystemWorld,
-    config: &mut CompileConfig,
-) -> 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.map(|()| vec![config.output.clone()]),
-                warnings,
-            }
-        }
-        _ => {
-            let Warned { output, warnings } = typst::compile::<PagedDocument>(world);
-            let result = output.and_then(|document| export_paged(&document, config));
-            Warned { output: result, warnings }
-        }
-    }
-}
-
-/// Export to HTML.
-fn export_html(document: &HtmlDocument, config: &CompileConfig) -> SourceResult<()> {
-    let html = typst_html::html(document)?;
-    let result = config.output.write(html.as_bytes());
-
-//    #[cfg(feature = "http-server")]
-//    if let Some(server) = &config.server {
-//        server.update(html);
-//    }
-
-    result
-        .map_err(|err| eco_format!("failed to write HTML file ({err})"))
-        .at(Span::detached())
-}
-
-/// Export to a paged target format.
-fn export_paged(
-    document: &PagedDocument,
-    config: &CompileConfig,
-) -> SourceResult<Vec<Output>> {
-    match config.output_format {
-        OutputFormat::Pdf => {
-            export_pdf(document, config).map(|()| vec![config.output.clone()])
-        }
-        OutputFormat::Png => {
-            export_image(document, config, ImageExportFormat::Png).at(Span::detached())
-        }
-        OutputFormat::Svg => {
-            export_image(document, config, ImageExportFormat::Svg).at(Span::detached())
-        }
-        OutputFormat::Html => unreachable!(),
-    }
-}
-
-/// Export to a PDF.
-fn export_pdf(document: &PagedDocument, config: &CompileConfig) -> SourceResult<()> {
-    // If the timestamp is provided through the CLI, use UTC suffix,
-    // else, use the current local time and timezone.
-    let timestamp = match config.creation_timestamp {
-        Some(timestamp) => convert_datetime(timestamp).map(Timestamp::new_utc),
-        None => {
-            let local_datetime = chrono::Local::now();
-            convert_datetime(local_datetime).and_then(|datetime| {
-                Timestamp::new_local(
-                    datetime,
-                    local_datetime.offset().local_minus_utc() / 60,
-                )
-            })
-        }
-    };
-    let options = PdfOptions {
-        ident: Smart::Auto,
-        timestamp,
-        page_ranges: config.pages.clone(),
-        standards: config.pdf_standards.clone(),
-    };
-    let buffer = typst_pdf::pdf(document, &options)?;
-    config
-        .output
-        .write(&buffer)
-        .map_err(|err| eco_format!("failed to write PDF file ({err})"))
-        .at(Span::detached())?;
-    Ok(())
-}
-
-/// Convert [`chrono::DateTime`] to [`Datetime`]
-fn convert_datetime<Tz: chrono::TimeZone>(
-    date_time: chrono::DateTime<Tz>,
-) -> Option<Datetime> {
-    Datetime::from_ymd_hms(
-        date_time.year(),
-        date_time.month().try_into().ok()?,
-        date_time.day().try_into().ok()?,
-        date_time.hour().try_into().ok()?,
-        date_time.minute().try_into().ok()?,
-        date_time.second().try_into().ok()?,
-    )
-}
-
-/// An image format to export in.
-#[derive(Clone, Copy)]
-enum ImageExportFormat {
-    Png,
-    Svg,
-}
-
-/// Export to one or multiple images.
-fn export_image(
-    document: &PagedDocument,
-    config: &CompileConfig,
-    fmt: ImageExportFormat,
-) -> StrResult<Vec<Output>> {
-    // Determine whether we have indexable templates in output
-    let can_handle_multiple = match config.output {
-        Output::Stdout => false,
-        Output::Path(ref output) => {
-            output_template::has_indexable_template(output.to_str().unwrap_or_default())
-        }
-    };
-
-    let exported_pages = document
-        .pages
-        .iter()
-        .enumerate()
-        .filter(|(i, _)| {
-            config.pages.as_ref().map_or(true, |exported_page_ranges| {
-                exported_page_ranges.includes_page_index(*i)
-            })
-        })
-        .collect::<Vec<_>>();
-
-    if !can_handle_multiple && exported_pages.len() > 1 {
-        let err = match config.output {
-            Output::Stdout => "to stdout",
-            Output::Path(_) => {
-                "without a page number template ({p}, {0p}) in the output path"
-            }
-        };
-        bail!("cannot export multiple images {err}");
-    }
-
-    // The results are collected in a `Vec<()>` which does not allocate.
-    exported_pages
-        .par_iter()
-        .map(|(i, page)| {
-            // Use output with converted path.
-            let output = match &config.output {
-                Output::Path(path) => {
-                    let storage;
-                    let path = if can_handle_multiple {
-                        storage = output_template::format(
-                            path.to_str().unwrap_or_default(),
-                            i + 1,
-                            document.pages.len(),
-                        );
-                        Path::new(&storage)
-                    } else {
-                        path
-                    };
-
-                    // If we are not watching, don't use the cache.
-                    // If the frame is in the cache, skip it.
-                    // If the file does not exist, always create it.
-                    if config.watching
-                        && config.export_cache.is_cached(*i, &page.frame)
-                        && path.exists()
-                    {
-                        return Ok(Output::Path(path.to_path_buf()));
-                    }
-
-                    Output::Path(path.to_owned())
-                }
-                Output::Stdout => Output::Stdout,
-            };
-
-            export_image_page(config, page, &output, fmt)?;
-            Ok(output)
-        })
-        .collect::<StrResult<Vec<Output>>>()
-}
-
-mod output_template {
-    const INDEXABLE: [&str; 3] = ["{p}", "{0p}", "{n}"];
-
-    pub fn has_indexable_template(output: &str) -> bool {
-        INDEXABLE.iter().any(|template| output.contains(template))
-    }
-
-    pub fn format(output: &str, this_page: usize, total_pages: usize) -> String {
-        // Find the base 10 width of number `i`
-        fn width(i: usize) -> usize {
-            1 + i.checked_ilog10().unwrap_or(0) as usize
-        }
-
-        let other_templates = ["{t}"];
-        INDEXABLE.iter().chain(other_templates.iter()).fold(
-            output.to_string(),
-            |out, template| {
-                let replacement = match *template {
-                    "{p}" => format!("{this_page}"),
-                    "{0p}" | "{n}" => format!("{:01$}", this_page, width(total_pages)),
-                    "{t}" => format!("{total_pages}"),
-                    _ => unreachable!("unhandled template placeholder {template}"),
-                };
-                out.replace(template, replacement.as_str())
-            },
-        )
-    }
-}
-
-/// Export single image.
-fn export_image_page(
-    config: &CompileConfig,
-    page: &Page,
-    output: &Output,
-    fmt: ImageExportFormat,
-) -> StrResult<()> {
-    match fmt {
-        ImageExportFormat::Png => {
-            let pixmap = typst_render::render(page, config.ppi / 72.0);
-            let buf = pixmap
-                .encode_png()
-                .map_err(|err| eco_format!("failed to encode PNG file ({err})"))?;
-            output
-                .write(&buf)
-                .map_err(|err| eco_format!("failed to write PNG file ({err})"))?;
-        }
-        ImageExportFormat::Svg => {
-            let svg = typst_svg::svg(page);
-            output
-                .write(svg.as_bytes())
-                .map_err(|err| eco_format!("failed to write SVG file ({err})"))?;
-        }
-    }
-    Ok(())
-}
-
-impl Output {
-    fn write(&self, buffer: &[u8]) -> StrResult<()> {
-        match self {
-            Output::Stdout => std::io::stdout().write_all(buffer),
-            Output::Path(path) => fs::write(path, buffer),
-        }
-        .map_err(|err| eco_format!("{err}"))
-    }
-}
-
-/// Caches exported files so that we can avoid re-exporting them if they haven't
-/// changed.
-///
-/// This is done by having a list of size `files.len()` that contains the hashes
-/// of the last rendered frame in each file. If a new frame is inserted, this
-/// will invalidate the rest of the cache, this is deliberate as to decrease the
-/// complexity and memory usage of such a cache.
-pub struct ExportCache {
-    /// The hashes of last compilation's frames.
-    pub cache: RwLock<Vec<u128>>,
-}
-
-impl ExportCache {
-    /// Creates a new export cache.
-    pub fn new() -> Self {
-        Self { cache: RwLock::new(Vec::with_capacity(32)) }
-    }
-
-    /// Returns true if the entry is cached and appends the new hash to the
-    /// cache (for the next compilation).
-    pub fn is_cached(&self, i: usize, frame: &Frame) -> bool {
-        let hash = typst::utils::hash128(frame);
-
-        let mut cache = self.cache.upgradable_read();
-        if i >= cache.len() {
-            cache.with_upgraded(|cache| cache.push(hash));
-            return false;
-        }
-
-        cache.with_upgraded(|cache| std::mem::replace(&mut cache[i], hash) == hash)
-    }
-}
-
-/// 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,
-    outputs: Vec<Output>,
-) -> StrResult<()> {
-    let Some(ref make_deps_path) = config.make_deps else { return Ok(()) };
-    let Ok(output_paths) = outputs
-        .into_iter()
-        .filter_map(|o| match o {
-            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.
-    fn munge(s: &str) -> String {
-        let mut res = String::with_capacity(s.len());
-        let mut slashes = 0;
-        for c in s.chars() {
-            match c {
-                '\\' => slashes += 1,
-                '$' => {
-                    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
-                    // backslashes followed by space..."
-                    for _ in 0..slashes + 1 {
-                        res.push('\\');
-                    }
-                    slashes = 0;
-                }
-                '#' => {
-                    res.push('\\');
-                    slashes = 0;
-                }
-                _ => slashes = 0,
-            };
-            res.push(c);
-        }
-        res
-    }
-
-    fn write(
-        make_deps_path: &Path,
-        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());
-
-        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 relative_dependency = match dependency.strip_prefix(&root) {
-                Ok(root_relative_dependency) => {
-                    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.
-                continue;
-            };
-
-            file.write_all(b" ")?;
-            file.write_all(munge(relative_dependency).as_bytes())?;
-        }
-        file.write_all(b"\n")?;
-
-        Ok(())
-    }
-
-    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})")
-        })
-}
-
-/// Opens the output if desired.
-fn open_output(config: &mut CompileConfig) -> StrResult<()> {
-    let Some(viewer) = config.open.take() else { return Ok(()) };
-
-//    #[cfg(feature = "http-server")]
-//    if let Some(server) = &config.server {
-//        let url = format!("http://{}", server.addr());
-//        return open_path(OsStr::new(&url), viewer.as_deref());
-//    }
-
-    // Can't open stdout.
-    let Output::Path(path) = &config.output else { return Ok(()) };
-
-    // Some resource openers require the path to be canonicalized.
-    let path = path
-        .canonicalize()
-        .map_err(|err| eco_format!("failed to canonicalize path ({err})"))?;
-
-    open_path(path.as_os_str(), viewer.as_deref())
-}
-
-/// Opens the given file using:
-///
-/// - The default file viewer if `app` is `None`.
-/// - The given viewer provided by `app` if it is `Some`.
-fn open_path(path: &OsStr, viewer: Option<&str>) -> StrResult<()> {
-    if let Some(viewer) = viewer {
-        open::with_detached(path, viewer)
-            .map_err(|err| eco_format!("failed to open file with {} ({})", viewer, err))
-    } else {
-        open::that_detached(path).map_err(|err| {
-            let openers = open::commands(path)
-                .iter()
-                .map(|command| command.get_program().to_string_lossy())
-                .collect::<Vec<_>>()
-                .join(", ");
-            eco_format!(
-                "failed to open file with any of these resource openers: {} ({})",
-                openers,
-                err,
-            )
-        })
-    }
-}
-
-/// Print diagnostic messages to the terminal.
-pub fn print_diagnostics(
-    world: &SystemWorld,
-    errors: &[SourceDiagnostic],
-    warnings: &[SourceDiagnostic],
-    diagnostic_format: DiagnosticFormat,
-) -> Result<(), codespan_reporting::files::Error> {
-    let mut config = term::Config { tab_width: 2, ..Default::default() };
-    if diagnostic_format == DiagnosticFormat::Short {
-        config.display_style = term::DisplayStyle::Short;
-    }
-
-    for diagnostic in warnings.iter().chain(errors) {
-        let diag = match diagnostic.severity {
-            Severity::Error => Diagnostic::error(),
-            Severity::Warning => Diagnostic::warning(),
-        }
-        .with_message(diagnostic.message.clone())
-        .with_notes(
-            diagnostic
-                .hints
-                .iter()
-                .map(|e| (eco_format!("hint: {e}")).into())
-                .collect(),
-        )
-        .with_labels(label(world, diagnostic.span).into_iter().collect());
-
-        term::emit(&mut terminal::out(), &config, world, &diag)?;
-
-        // Stacktrace-like helper diagnostics.
-        for point in &diagnostic.trace {
-            let message = point.v.to_string();
-            let help = Diagnostic::help()
-                .with_message(message)
-                .with_labels(label(world, point.span).into_iter().collect());
-
-            term::emit(&mut terminal::out(), &config, world, &help)?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Create a label for a span.
-fn label(world: &SystemWorld, span: Span) -> Option<Label<FileId>> {
-    Some(Label::primary(span.id()?, world.range(span)?))
-}
-
-impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
-    type FileId = FileId;
-    type Name = String;
-    type Source = Source;
-
-    fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
-        let vpath = id.vpath();
-        Ok(if let Some(package) = id.package() {
-            format!("{package}{}", vpath.as_rooted_path().display())
-        } else {
-            // Try to express the path relative to the working directory.
-            vpath
-                .resolve(self.root())
-                .and_then(|abs| pathdiff::diff_paths(abs, self.workdir()))
-                .as_deref()
-                .unwrap_or_else(|| vpath.as_rootless_path())
-                .to_string_lossy()
-                .into()
-        })
-    }
-
-    fn source(&'a self, id: FileId) -> CodespanResult<Self::Source> {
-        Ok(self.lookup(id))
-    }
-
-    fn line_index(&'a self, id: FileId, given: usize) -> CodespanResult<usize> {
-        let source = self.lookup(id);
-        source
-            .byte_to_line(given)
-            .ok_or_else(|| CodespanError::IndexTooLarge {
-                given,
-                max: source.len_bytes(),
-            })
-    }
-
-    fn line_range(
-        &'a self,
-        id: FileId,
-        given: usize,
-    ) -> CodespanResult<std::ops::Range<usize>> {
-        let source = self.lookup(id);
-        source
-            .line_to_range(given)
-            .ok_or_else(|| CodespanError::LineTooLarge { given, max: source.len_lines() })
-    }
-
-    fn column_number(
-        &'a self,
-        id: FileId,
-        _: usize,
-        given: usize,
-    ) -> CodespanResult<usize> {
-        let source = self.lookup(id);
-        source.byte_to_column(given).ok_or_else(|| {
-            let max = source.len_bytes();
-            if given <= max {
-                CodespanError::InvalidCharBoundary { given }
-            } else {
-                CodespanError::IndexTooLarge { given, max }
-            }
-        })
-    }
-}