typst 0.13.3-aarch64-linux

data/ext/typst/src/package.rs

@@ -0,0 +1,64 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use ecow::eco_format;
+use typst::diag::{PackageError, PackageResult};
+use typst::syntax::PackageSpec;
+
+use crate::download::download;
+
+/// Make a package available in the on-disk cache.
+pub fn prepare_package(spec: &PackageSpec) -> PackageResult<PathBuf> {
+    let subdir = format!(
+        "typst/packages/{}/{}/{}",
+        spec.namespace, spec.name, spec.version
+    );
+
+    if let Some(data_dir) = dirs::data_dir() {
+        let dir = data_dir.join(&subdir);
+        if dir.exists() {
+            return Ok(dir);
+        }
+    }
+
+    if let Some(cache_dir) = dirs::cache_dir() {
+        let dir = cache_dir.join(&subdir);
+
+        // Download from network if it doesn't exist yet.
+        if spec.namespace == "preview" && !dir.exists() {
+            download_package(spec, &dir)?;
+        }
+
+        if dir.exists() {
+            return Ok(dir);
+        }
+    }
+
+    Err(PackageError::NotFound(spec.clone()))
+}
+
+/// Download a package over the network.
+fn download_package(spec: &PackageSpec, package_dir: &Path) -> PackageResult<()> {
+    // The `@preview` namespace is the only namespace that supports on-demand
+    // fetching.
+    assert_eq!(spec.namespace, "preview");
+
+    let url = format!(
+        "https://packages.typst.org/preview/{}-{}.tar.gz",
+        spec.name, spec.version
+    );
+
+    let data = match download(&url) {
+        Ok(data) => data,
+        Err(ureq::Error::Status(404, _)) => return Err(PackageError::NotFound(spec.clone())),
+        Err(err) => return Err(PackageError::NetworkFailed(Some(eco_format!("{err}")))),
+    };
+
+    let decompressed = flate2::read::GzDecoder::new(data.as_slice());
+    tar::Archive::new(decompressed)
+        .unpack(package_dir)
+        .map_err(|err| {
+            fs::remove_dir_all(package_dir).ok();
+            PackageError::MalformedArchive(Some(eco_format!("{err}")))
+        })
+}

data/ext/typst/src/query.rs

@@ -0,0 +1,131 @@
+use comemo::Track;
+use ecow::{eco_format, EcoString};
+use serde::Serialize;
+use typst::diag::{bail, StrResult, Warned};
+use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
+use typst::layout::PagedDocument;
+use typst::syntax::Span;
+use typst::World;
+use typst_eval::{eval_string, EvalMode};
+
+use crate::world::SystemWorld;
+
+/// Processes an input file to extract provided metadata
+#[derive(Debug, Clone)]
+pub struct QueryCommand {
+    /// Defines which elements to retrieve
+    pub selector: String,
+
+    /// Extracts just one field from all retrieved elements
+    pub field: Option<String>,
+
+    /// Expects and retrieves exactly one element
+    pub one: bool,
+
+    /// The format to serialize in
+    pub format: SerializationFormat,
+}
+
+// Output file format for query command
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum SerializationFormat {
+    Json,
+    Yaml,
+}
+
+/// Execute a query command.
+pub fn query(world: &mut SystemWorld, command: &QueryCommand) -> StrResult<String> {
+    // Reset everything and ensure that the main file is present.
+    world.reset();
+    world.source(world.main()).map_err(|err| err.to_string())?;
+
+    let Warned { output, warnings } = typst::compile(world);
+
+    match output {
+        // Retrieve and print query results.
+        Ok(document) => {
+            let data = retrieve(world, command, &document)?;
+            let serialized = format(data, command)?;
+            Ok(serialized)
+        }
+        // Print errors and warnings.
+        Err(errors) => {
+            let mut message = EcoString::from("failed to compile document");
+            for (i, error) in errors.into_iter().enumerate() {
+                message.push_str(if i == 0 { ": " } else { ", " });
+                message.push_str(&error.message);
+            }
+            for warning in warnings {
+                message.push_str(": ");
+                message.push_str(&warning.message);
+            }
+            Err(message)
+        }
+    }
+}
+
+/// Retrieve the matches for the selector.
+fn retrieve(
+    world: &dyn World,
+    command: &QueryCommand,
+    document: &PagedDocument,
+) -> StrResult<Vec<Content>> {
+    let selector = eval_string(
+        &typst::ROUTINES,
+        world.track(),
+        &command.selector,
+        Span::detached(),
+        EvalMode::Code,
+        Scope::default(),
+    )
+    .map_err(|errors| {
+        let mut message = EcoString::from("failed to evaluate selector");
+        for (i, error) in errors.into_iter().enumerate() {
+            message.push_str(if i == 0 { ": " } else { ", " });
+            message.push_str(&error.message);
+        }
+        message
+    })?
+    .cast::<LocatableSelector>()
+    .map_err(|e| e.message().clone())?;
+
+    Ok(document
+        .introspector
+        .query(&selector.0)
+        .into_iter()
+        .collect::<Vec<_>>())
+}
+
+/// Format the query result in the output format.
+fn format(elements: Vec<Content>, command: &QueryCommand) -> StrResult<String> {
+    if command.one && elements.len() != 1 {
+        bail!("expected exactly one element, found {}", elements.len());
+    }
+
+    let mapped: Vec<_> = elements
+        .into_iter()
+        .filter_map(|c| match &command.field {
+            Some(field) => c.get_by_name(field).ok(),
+            _ => Some(c.into_value()),
+        })
+        .collect();
+
+    if command.one {
+        let Some(value) = mapped.first() else {
+            bail!("no such field found for element");
+        };
+        serialize(value, command.format)
+    } else {
+        serialize(&mapped, command.format)
+    }
+}
+
+/// Serialize data to the output format.
+fn serialize(data: &impl Serialize, format: SerializationFormat) -> StrResult<String> {
+    match format {
+        SerializationFormat::Json => {
+            serde_json::to_string_pretty(data).map_err(|e| eco_format!("{e}"))
+        }
+        SerializationFormat::Yaml => serde_yaml::to_string(&data).map_err(|e| eco_format!("{e}")),
+    }
+}

data/ext/typst/src/world.rs

@@ -0,0 +1,351 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, OnceLock};
+
+use chrono::{DateTime, Datelike, Local};
+use ecow::eco_format;
+use typst::diag::{FileError, FileResult, StrResult};
+use typst::foundations::{Bytes, Datetime, Dict};
+use typst::syntax::{FileId, Source, VirtualPath};
+use typst::text::{Font, FontBook};
+use typst::utils::LazyHash;
+use typst::{Features, Library, LibraryBuilder, World};
+use typst_kit::{
+    fonts::{FontSearcher, FontSlot},
+    package::PackageStorage,
+};
+
+use std::collections::HashMap;
+
+use crate::download::SlientDownload;
+
+/// A world that provides access to the operating system.
+pub struct SystemWorld {
+    /// The working directory.
+    workdir: Option<PathBuf>,
+    /// The canonical path to the input file.
+    input: PathBuf,
+    /// The root relative to which absolute paths are resolved.
+    root: PathBuf,
+    /// The input path.
+    main: FileId,
+    /// Typst's standard library.
+    library: LazyHash<Library>,
+    /// Metadata about discovered fonts.
+    book: LazyHash<FontBook>,
+    /// Locations of and storage for lazily loaded fonts.
+    fonts: Vec<FontSlot>,
+    /// Maps file ids to source files and buffers.
+    slots: Mutex<HashMap<FileId, FileSlot>>,
+    /// Holds information about where packages are stored.
+    package_storage: PackageStorage,
+    /// The current datetime if requested. This is stored here to ensure it is
+    /// always the same within one compilation. Reset between compilations.
+    now: OnceLock<DateTime<Local>>,
+}
+
+impl World for SystemWorld {
+    fn library(&self) -> &LazyHash<Library> {
+        &self.library
+    }
+
+    fn book(&self) -> &LazyHash<FontBook> {
+        &self.book
+    }
+
+    fn main(&self) -> FileId {
+        self.main
+    }
+
+    fn source(&self, id: FileId) -> FileResult<Source> {
+        self.slot(id, |slot| slot.source(&self.root, &self.package_storage))
+    }
+
+    fn file(&self, id: FileId) -> FileResult<Bytes> {
+        self.slot(id, |slot| slot.file(&self.root, &self.package_storage))
+    }
+
+    fn font(&self, index: usize) -> Option<Font> {
+        self.fonts[index].get()
+    }
+
+    fn today(&self, offset: Option<i64>) -> Option<Datetime> {
+        let now = self.now.get_or_init(chrono::Local::now);
+
+        let naive = match offset {
+            None => now.naive_local(),
+            Some(o) => now.naive_utc() + chrono::Duration::hours(o),
+        };
+
+        Datetime::from_ymd(
+            naive.year(),
+            naive.month().try_into().ok()?,
+            naive.day().try_into().ok()?,
+        )
+    }
+}
+
+impl SystemWorld {
+    pub fn builder(root: PathBuf, main: PathBuf) -> SystemWorldBuilder {
+        SystemWorldBuilder::new(root, main)
+    }
+
+    /// Access the canonical slot for the given file id.
+    fn slot<F, T>(&self, id: FileId, f: F) -> T
+    where
+        F: FnOnce(&mut FileSlot) -> T,
+    {
+        let mut map = self.slots.lock().unwrap();
+        f(map.entry(id).or_insert_with(|| FileSlot::new(id)))
+    }
+
+    /// The id of the main source file.
+    pub fn main(&self) -> FileId {
+        self.main
+    }
+
+    /// The root relative to which absolute paths are resolved.
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+
+    /// The current working directory.
+    pub fn workdir(&self) -> &Path {
+        self.workdir.as_deref().unwrap_or(Path::new("."))
+    }
+
+    /// Reset the compilation state in preparation of a new compilation.
+    pub fn reset(&mut self) {
+        for slot in self.slots.lock().unwrap().values_mut() {
+            slot.reset();
+        }
+        self.now.take();
+    }
+
+    /// Return the canonical path to the input file.
+    pub fn input(&self) -> &PathBuf {
+        &self.input
+    }
+
+    /// 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 struct SystemWorldBuilder {
+    root: PathBuf,
+    main: PathBuf,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    inputs: Dict,
+    features: Features,
+}
+
+impl SystemWorldBuilder {
+    pub fn new(root: PathBuf, main: PathBuf) -> Self {
+        Self {
+            root,
+            main,
+            font_paths: Vec::new(),
+            ignore_system_fonts: false,
+            inputs: Dict::default(),
+            features: Features::default(),
+        }
+    }
+
+    pub fn font_paths(mut self, font_paths: Vec<PathBuf>) -> Self {
+        self.font_paths = font_paths;
+        self
+    }
+
+    pub fn ignore_system_fonts(mut self, ignore: bool) -> Self {
+        self.ignore_system_fonts = ignore;
+        self
+    }
+
+    pub fn inputs(mut self, inputs: Dict) -> Self {
+        self.inputs = inputs;
+        self
+    }
+
+    pub fn features(mut self, features: Features) -> Self {
+        self.features = features;
+        self
+    }
+
+    pub fn build(self) -> StrResult<SystemWorld> {
+        let fonts = FontSearcher::new()
+            .include_system_fonts(!self.ignore_system_fonts)
+            .search_with(&self.font_paths);
+
+        let input = self.main.canonicalize().map_err(|_| {
+            eco_format!("input file not found (searched at {})", self.main.display())
+        })?;
+        // Resolve the virtual path of the main file within the project root.
+        let main_path = VirtualPath::within_root(&self.main, &self.root)
+            .ok_or("input file must be contained in project root")?;
+
+        let world = SystemWorld {
+            workdir: std::env::current_dir().ok(),
+            input,
+            root: self.root,
+            main: FileId::new(None, main_path),
+            library: LazyHash::new(LibraryBuilder::default().with_inputs(self.inputs).with_features(self.features).build()),
+            book: LazyHash::new(fonts.book),
+            fonts: fonts.fonts,
+            slots: Mutex::default(),
+            package_storage: PackageStorage::new(None, None, crate::download::downloader()),
+            now: OnceLock::new(),
+        };
+        Ok(world)
+    }
+}
+
+/// Holds canonical data for all paths pointing to the same entity.
+///
+/// Both fields can be populated if the file is both imported and read().
+struct FileSlot {
+    /// The slot's canonical file id.
+    id: FileId,
+    /// The lazily loaded and incrementally updated source file.
+    source: SlotCell<Source>,
+    /// The lazily loaded raw byte buffer.
+    file: SlotCell<Bytes>,
+}
+
+impl FileSlot {
+    /// Create a new path slot.
+    fn new(id: FileId) -> Self {
+        Self {
+            id,
+            file: SlotCell::new(),
+            source: SlotCell::new(),
+        }
+    }
+
+    /// Marks the file as not yet accessed in preparation of the next
+    /// compilation.
+    fn reset(&mut self) {
+        self.source.reset();
+        self.file.reset();
+    }
+
+    fn source(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Source> {
+        let id = self.id;
+        self.source.get_or_init(
+            || system_path(root, id, package_storage),
+            |data, prev| {
+                let text = decode_utf8(&data)?;
+                if let Some(mut prev) = prev {
+                    prev.replace(text);
+                    Ok(prev)
+                } else {
+                    Ok(Source::new(self.id, text.into()))
+                }
+            },
+        )
+    }
+
+    fn file(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Bytes> {
+        let id = self.id;
+        self.file.get_or_init(
+            || system_path(root, id, package_storage),
+            |data, _| Ok(Bytes::new(data)),
+        )
+    }
+}
+
+/// The path of the slot on the system.
+fn system_path(root: &Path, id: FileId, package_storage: &PackageStorage) -> FileResult<PathBuf> {
+    // Determine the root path relative to which the file path
+    // will be resolved.
+    let buf;
+    let mut root = root;
+    if let Some(spec) = id.package() {
+        buf = package_storage.prepare_package(spec, &mut SlientDownload(&spec))?;
+        root = &buf;
+    }
+
+    // Join the path to the root. If it tries to escape, deny
+    // access. Note: It can still escape via symlinks.
+    id.vpath().resolve(root).ok_or(FileError::AccessDenied)
+}
+
+/// Lazily processes data for a file.
+struct SlotCell<T> {
+    /// The processed data.
+    data: Option<FileResult<T>>,
+    /// A hash of the raw file contents / access error.
+    fingerprint: u128,
+    /// Whether the slot has been accessed in the current compilation.
+    accessed: bool,
+}
+
+impl<T: Clone> SlotCell<T> {
+    /// Creates a new, empty cell.
+    fn new() -> Self {
+        Self {
+            data: None,
+            fingerprint: 0,
+            accessed: false,
+        }
+    }
+
+    /// Marks the cell as not yet accessed in preparation of the next
+    /// compilation.
+    fn reset(&mut self) {
+        self.accessed = false;
+    }
+
+    /// Gets the contents of the cell or initialize them.
+    fn get_or_init(
+        &mut self,
+        path: impl FnOnce() -> FileResult<PathBuf>,
+        f: impl FnOnce(Vec<u8>, Option<T>) -> FileResult<T>,
+    ) -> FileResult<T> {
+        // If we accessed the file already in this compilation, retrieve it.
+        if std::mem::replace(&mut self.accessed, true) {
+            if let Some(data) = &self.data {
+                return data.clone();
+            }
+        }
+
+        // Read and hash the file.
+        let result = path().and_then(|p| read(&p));
+        let fingerprint = typst::utils::hash128(&result);
+
+        // If the file contents didn't change, yield the old processed data.
+        if std::mem::replace(&mut self.fingerprint, fingerprint) == fingerprint {
+            if let Some(data) = &self.data {
+                return data.clone();
+            }
+        }
+
+        let prev = self.data.take().and_then(Result::ok);
+        let value = result.and_then(|data| f(data, prev));
+        self.data = Some(value.clone());
+
+        value
+    }
+}
+
+/// Read a file.
+fn read(path: &Path) -> FileResult<Vec<u8>> {
+    let f = |e| FileError::from_io(e, path);
+    if fs::metadata(path).map_err(f)?.is_dir() {
+        Err(FileError::IsDirectory)
+    } else {
+        fs::read(path).map_err(f)
+    }
+}
+
+/// Decode UTF-8 with an optional BOM.
+fn decode_utf8(buf: &[u8]) -> FileResult<&str> {
+    // Remove UTF-8 BOM.
+    Ok(std::str::from_utf8(
+        buf.strip_prefix(b"\xef\xbb\xbf").unwrap_or(buf),
+    )?)
+}

data/lib/base.rb

@@ -0,0 +1,169 @@
+module Typst
+  class Base
+    attr_accessor :options
+    attr_accessor :compiled
+
+    def initialize(*options)
+      if options.size.zero?
+        raise "No options given"
+      elsif options.first.is_a?(String)
+        file, options = options
+        options ||= {}
+        options[:file] = file
+      elsif options.first.is_a?(Hash)
+        options = options.first
+      end
+
+      if options.has_key?(:file)
+        raise "Can't find file" unless File.exist?(options[:file])
+      elsif options.has_key?(:body)
+        raise "Empty body" if options[:body].to_s.empty?
+      elsif options.has_key?(:zip)
+        raise "Can't find zip" unless File.exist?(options[:zip])
+      else
+        raise "No input given"
+      end
+
+      root = Pathname.new(options[:root] || ".").expand_path
+      raise "Invalid path for root" unless root.exist?
+      options[:root] = root.to_s
+
+      font_paths = (options[:font_paths] || []).collect{ |fp| Pathname.new(fp).expand_path }
+      options[:font_paths] = font_paths.collect(&:to_s)
+
+      options[:dependencies] ||= {}
+      options[:fonts] ||= {}
+      options[:sys_inputs] ||= {}
+    
+      self.options = options
+    end
+
+    def typst_args
+      [options[:file], options[:root], options[:font_paths], File.dirname(__FILE__), false, options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
+    end
+
+    def self.from_s(main_source, **options)
+      dependencies = options[:dependencies] ||= {}
+      fonts = options[:fonts] ||= {}
+
+      Dir.mktmpdir do |tmp_dir|
+        tmp_main_file = Pathname.new(tmp_dir).join("main.typ")
+        File.write(tmp_main_file, main_source)
+
+        dependencies.each do |dep_name, dep_source|
+          tmp_dep_file = Pathname.new(tmp_dir).join(dep_name)
+          File.write(tmp_dep_file, dep_source)
+        end
+
+        relative_font_path = Pathname.new(tmp_dir).join("fonts")
+        fonts.each do |font_name, font_bytes|
+          Pathname.new(relative_font_path).mkpath
+          tmp_font_file = relative_font_path.join(font_name)
+          File.write(tmp_font_file, font_bytes)
+        end
+
+        options[:file] = tmp_main_file
+        options[:root] = tmp_dir
+        options[:font_paths] = [relative_font_path]
+
+        if options[:format]
+          Typst::formats[options[:format]].new(**options)
+        else
+          new(**options)
+        end
+      end
+    end
+
+    def self.from_zip(zip_file_path, main_file = nil, **options)
+      options[:dependencies] ||= {}
+      options[:fonts] ||= {}
+
+      Zip::File.open(zip_file_path) do |zipfile|
+        file_names = zipfile.dir.glob("*").collect{ |f| f.name }
+        case
+          when file_names.include?(main_file) then tmp_main_file = main_file
+          when file_names.include?("main.typ") then tmp_main_file = "main.typ"
+          when file_names.size == 1 then tmp_main_file = file_names.first
+          else raise "no main file found"
+        end
+        main_source = zipfile.file.read(tmp_main_file)
+        file_names.delete(tmp_main_file)
+        file_names.delete("fonts/")
+
+        file_names.each do |dep_name|
+          options[:dependencies][dep_name] = zipfile.file.read(dep_name)
+        end
+
+        font_file_names = zipfile.dir.glob("fonts/*").collect{ |f| f.name }
+        font_file_names.each do |font_name|
+          options[:fonts][Pathname.new(font_name).basename.to_s] = zipfile.file.read(font_name)
+        end
+
+        options[:main_file] = tmp_main_file
+
+        from_s(main_source, **options)
+      end
+    end
+
+    def with_dependencies(dependencies)
+      self.options[:dependencies] = self.options[:dependencies].merge(dependencies)
+      self
+    end
+
+    def with_fonts(fonts)
+      self.options[:fonts] = self.options[:fonts].merge(fonts)
+      self
+    end
+
+    def with_inputs(inputs)
+      self.options[:sys_inputs] = self.options[:sys_inputs].merge(inputs)
+      self
+    end
+
+    def with_font_paths(font_paths)
+      self.options[:font_paths] = self.options[:font_paths] + font_paths
+      self
+    end
+
+    def with_root(root)
+      self.options[:root] = root
+      self
+    end
+
+    def compile(format, **options)
+      raise "Invalid format" if Typst::formats[format].nil?
+
+      options = self.options.merge(options)
+
+      if options.has_key?(:file)
+        Typst::formats[format].new(**options).compiled
+      elsif options.has_key?(:body)
+        Typst::formats[format].from_s(options[:body], **options).compiled
+      elsif options.has_key?(:zip)
+        Typst::formats[format].from_zip(options[:zip], options[:main_file], **options).compiled
+      else
+        raise "No input given"
+      end
+    end
+
+    def write(output)
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.write(output)
+    end
+
+    def document
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.document
+    end
+
+    def bytes
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.bytes
+    end
+
+    def pages
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.pages
+    end
+  end
+end