typst 0.14.2.2 → 0.15.0.0

data/ext/typst/src/lib.rs

@@ -19,8 +19,8 @@ fn to_html(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
     let input = input.canonicalize()
@@ -35,22 +35,6 @@ fn to_html(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut features = Vec::new();
     features.push(Feature::Html);
 
@@ -72,6 +56,7 @@ fn to_html(
         .features(feat)
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -87,8 +72,8 @@ fn to_svg(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
     let input = input.canonicalize()
@@ -103,22 +88,6 @@ fn to_svg(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -127,6 +96,7 @@ fn to_svg(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -142,8 +112,8 @@ fn to_png(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
     ppi: Option<f32>,
 ) -> Result<Vec<Vec<u8>>, Error> {
@@ -159,22 +129,6 @@ fn to_png(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -183,6 +137,7 @@ fn to_png(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -198,8 +153,8 @@ fn to_pdf(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
@@ -215,22 +170,6 @@ fn to_pdf(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -239,6 +178,7 @@ fn to_pdf(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -287,8 +227,8 @@ fn query(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<String, Error> {
     let format = match format.unwrap().to_ascii_lowercase().as_str() {
@@ -309,22 +249,6 @@ fn query(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
     .inputs(Dict::from_iter(
         sys_inputs
@@ -333,6 +257,7 @@ fn query(
     ))
     .font_paths(font_paths)
     .ignore_system_fonts(ignore_system_fonts)
+    .ignore_embedded_fonts(ignore_embedded_fonts)
     .build()
     .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 

data/ext/typst/src/query.rs

@@ -3,8 +3,10 @@ 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::foundations::{Content, Context, IntoValue, LocatableSelector, Scope};
+use typst::introspection::{EmptyIntrospector, Introspector};
+use typst::routines::SpanMode;
+use typst_layout::PagedDocument;
 use typst::syntax::Span;
 use typst::syntax::SyntaxMode;
 use typst::World;
@@ -73,13 +75,15 @@ fn retrieve(
     document: &PagedDocument,
 ) -> StrResult<Vec<Content>> {
     let selector = eval_string(
-        &typst::ROUTINES,
         world.track(),
+        world.library(),
         Sink::new().track_mut(),
+        EmptyIntrospector.track(),
+        Context::none().track(),
         &command.selector,
-        Span::detached(),
+        SpanMode::Uniform(Span::detached()),
         SyntaxMode::Code,
-        Scope::default(),
+        Scope::default()
     )
     .map_err(|errors| {
         let mut message = EcoString::from("failed to evaluate selector");
@@ -93,7 +97,7 @@ fn retrieve(
     .map_err(|e| e.message().clone())?;
 
     Ok(document
-        .introspector
+        .introspector()
         .query(&selector.0)
         .into_iter()
         .collect::<Vec<_>>())

data/ext/typst/src/world.rs

@@ -1,44 +1,34 @@
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::sync::{Mutex, OnceLock};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::collections::HashMap;
 
-use chrono::{DateTime, Datelike, Local};
-use ecow::eco_format;
+use chrono::{DateTime, Datelike, FixedOffset, Local};
 use typst::diag::{FileError, FileResult, StrResult};
-use typst::foundations::{Bytes, Datetime, Dict};
-use typst::syntax::{FileId, Lines, Source, VirtualPath};
+use typst::foundations::{Bytes, Datetime, Dict, Duration};
+use typst::syntax::{FileId, Lines, Source, VirtualPath, VirtualRoot, RootedPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
 use typst::{Features, Library, LibraryExt, World};
-use typst_kit::{
-    fonts::{FontSearcher, FontSlot},
-    package::PackageStorage,
-};
-
-use std::collections::HashMap;
-
-use crate::download::SlientDownload;
+use typst_kit::fonts::{self, FontStore};
+use typst_kit::packages::{FsPackages, SystemPackages, UniversePackages};
 
 /// 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>,
+    fonts: Arc<FontStore>,
     /// Maps file ids to source files and buffers.
     slots: Mutex<HashMap<FileId, FileSlot>>,
     /// Holds information about where packages are stored.
-    package_storage: PackageStorage,
+    package_storage: SystemPackages,
     /// 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>>,
@@ -50,7 +40,7 @@ impl World for SystemWorld {
     }
 
     fn book(&self) -> &LazyHash<FontBook> {
-        &self.book
+        &self.fonts.book()
     }
 
     fn main(&self) -> FileId {
@@ -66,21 +56,30 @@ impl World for SystemWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        self.fonts[index].get()
+        self.fonts.font(index)
     }
 
-    fn today(&self, offset: Option<i64>) -> Option<Datetime> {
+    fn today(&self, offset: Option<Duration>) -> 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),
+        let now = match offset {
+            None => now.fixed_offset(),
+            Some(offset) => {
+                let seconds = offset.seconds().trunc();
+                if !seconds.is_finite()
+                    || seconds < f64::from(i32::MIN)
+                    || seconds > f64::from(i32::MAX)
+                {
+                    return None;
+                }
+                now.with_timezone(&FixedOffset::east_opt(seconds as i32)?)
+            }
         };
 
         Datetime::from_ymd(
-            naive.year(),
-            naive.month().try_into().ok()?,
-            naive.day().try_into().ok()?,
+            now.year(),
+            now.month().try_into().ok()?,
+            now.day().try_into().ok()?,
         )
     }
 }
@@ -122,23 +121,20 @@ impl SystemWorld {
         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) -> 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")
+                Lines::new(
+                    decode_utf8(bytes.as_slice())
+                        .expect("file is not valid utf-8")
+                        .to_string(),
+                )
             } else {
                 panic!("file id does not point to any source file");
             }
@@ -151,8 +147,11 @@ pub struct SystemWorldBuilder {
     main: PathBuf,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     inputs: Dict,
     features: Features,
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
 }
 
 impl SystemWorldBuilder {
@@ -162,8 +161,11 @@ impl SystemWorldBuilder {
             main,
             font_paths: Vec::new(),
             ignore_system_fonts: false,
+            ignore_embedded_fonts: false,
             inputs: Dict::default(),
             features: Features::default(),
+            package_path: None,
+            package_cache_path: None,
         }
     }
 
@@ -177,6 +179,11 @@ impl SystemWorldBuilder {
         self
     }
 
+    pub fn ignore_embedded_fonts(mut self, ignore: bool) -> Self {
+        self.ignore_embedded_fonts = ignore;
+        self
+    }
+
     pub fn inputs(mut self, inputs: Dict) -> Self {
         self.inputs = inputs;
         self
@@ -188,33 +195,57 @@ impl SystemWorldBuilder {
     }
 
     pub fn build(self) -> StrResult<SystemWorld> {
-        let fonts = FontSearcher::new()
-            .include_system_fonts(!self.ignore_system_fonts)
-            .search_with(&self.font_paths);
+        let fonts = Arc::new(build_font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths));
+
+        let package_storage = system_packages(self.package_path, self.package_cache_path);
 
-        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 main_path = VirtualPath::virtualize(&self.root, &self.main)
+            .map_err(|_| "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),
+            main: RootedPath::new(VirtualRoot::Project, main_path).intern(),
             library: LazyHash::new(Library::builder().with_inputs(self.inputs).with_features(self.features).build()),
-            book: LazyHash::new(fonts.book),
-            fonts: fonts.fonts,
+            fonts,
             slots: Mutex::default(),
-            package_storage: PackageStorage::new(None, None, crate::download::downloader()),
+            package_storage,
             now: OnceLock::new(),
         };
         Ok(world)
     }
 }
 
+fn build_font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> FontStore {
+    let mut fonts = FontStore::new();
+    if !ignore_system_fonts {
+        fonts.extend(fonts::system());
+    }
+    if !ignore_embedded_fonts {
+        fonts.extend(fonts::embedded());
+    }
+    for path in font_paths {
+        fonts.extend(fonts::scan(&path));
+    }
+    fonts
+}
+
+fn system_packages(
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
+) -> SystemPackages {
+    SystemPackages::from_parts(
+        package_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_data),
+        package_cache_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_cache),
+        UniversePackages::new(crate::download::downloader()),
+    )
+}
+
 /// Holds canonical data for all paths pointing to the same entity.
 ///
 /// Both fields can be populated if the file is both imported and read().
@@ -244,7 +275,7 @@ impl FileSlot {
         self.file.reset();
     }
 
-    fn source(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Source> {
+    fn source(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Source> {
         let id = self.id;
         self.source.get_or_init(
             || system_path(root, id, package_storage),
@@ -260,7 +291,7 @@ impl FileSlot {
         )
     }
 
-    fn file(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Bytes> {
+    fn file(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Bytes> {
         let id = self.id;
         self.file.get_or_init(
             || system_path(root, id, package_storage),
@@ -270,19 +301,21 @@ impl FileSlot {
 }
 
 /// The path of the slot on the system.
-fn system_path(root: &Path, id: FileId, package_storage: &PackageStorage) -> FileResult<PathBuf> {
+fn system_path(root: &Path, id: FileId, package_storage: &SystemPackages) -> 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;
-    }
+    let package_root;
+    let root = match id.root() {
+        VirtualRoot::Project => root,
+        VirtualRoot::Package(spec) => {
+            package_root = package_storage.obtain(spec)?;
+            package_root.path()
+        }
+    };
 
     // 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)
+    id.vpath().realize(root).map_err(Into::into)
 }
 
 /// Lazily processes data for a file.

data/lib/base.rb

@@ -34,14 +34,14 @@ module Typst
       options[:dependencies] ||= {}
       options[:fonts] ||= {}
       options[:sys_inputs] ||= {}
-      options[:resource_path] ||= File.dirname(__FILE__)
       options[:ignore_system_fonts] ||= false
+      options[:ignore_embedded_fonts] ||= false
     
       self.options = options
     end
 
     def typst_args
-      [options[:file], options[:root], options[:font_paths], options[:resource_path], options[:ignore_system_fonts], options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
+      [options[:file], options[:root], options[:font_paths], options[:ignore_system_fonts], options[:ignore_embedded_fonts], options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
     end
 
     def typst_pdf_args
@@ -125,14 +125,14 @@ module Typst
       query_options = { field: field, one: one, format: format }
 
       if self.options.has_key?(:file)
-        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
       elsif self.options.has_key?(:body)
         Typst::build_world_from_s(self.options[:body], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       elsif self.options.has_key?(:zip)
         Typst::build_world_from_zip(self.options[:zip], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       else
         raise "No input given"

data/lib/query.rb

@@ -2,9 +2,9 @@ module Typst
   class Query < Base
     attr_accessor :format
 
-    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], resource_path: ".", ignore_system_fonts: false, sys_inputs: {})
+    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, resource_path, ignore_system_fonts, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
     end
 
     def result(raw: false)

data/lib/typst.rb

@@ -8,7 +8,7 @@ module Typst
   def self.register_format(**format)
     @@formats.merge!(format)
   end
-  
+
   def self.formats
     @@formats
   end
@@ -27,14 +27,14 @@ module Typst
 
       dependencies.each do |dep_name, dep_source|
         tmp_dep_file = Pathname.new(tmp_dir).join(dep_name)
-        File.write(tmp_dep_file, dep_source)
+        File.binwrite(tmp_dep_file, dep_source)
       end
 
       relative_font_path = Pathname.new(tmp_dir).join("fonts")
       relative_font_path.mkpath
       fonts.each do |font_name, font_bytes|
         tmp_font_file = relative_font_path.join(font_name)
-        File.write(tmp_font_file, font_bytes)
+        File.binwrite(tmp_font_file, font_bytes)
       end
 
       options[:file] = tmp_main_file

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.14.2.2
+  version: 0.15.0.0
 platform: ruby
 authors:
 - Flinn
@@ -18,7 +18,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -113,27 +113,12 @@ files:
 - ext/typst/extconf.rb
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
-- ext/typst/src/fonts.rs
 - ext/typst/src/lib.rs
 - ext/typst/src/package.rs
 - ext/typst/src/query.rs
 - ext/typst/src/world.rs
 - lib/base.rb
 - lib/document.rb
-- lib/fonts/DejaVuSansMono-Bold.ttf
-- lib/fonts/DejaVuSansMono-BoldOblique.ttf
-- lib/fonts/DejaVuSansMono-Oblique.ttf
-- lib/fonts/DejaVuSansMono.ttf
-- lib/fonts/LinLibertine_R.ttf
-- lib/fonts/LinLibertine_RB.ttf
-- lib/fonts/LinLibertine_RBI.ttf
-- lib/fonts/LinLibertine_RI.ttf
-- lib/fonts/NewCM10-Bold.otf
-- lib/fonts/NewCM10-BoldItalic.otf
-- lib/fonts/NewCM10-Italic.otf
-- lib/fonts/NewCM10-Regular.otf
-- lib/fonts/NewCMMath-Book.otf
-- lib/fonts/NewCMMath-Regular.otf
 - lib/formats/html_experimental.rb
 - lib/formats/pdf.rb
 - lib/formats/png.rb
@@ -158,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.