typst 0.15.1.9 → 0.15.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25f3cd4ed85940c02be05305fcc3da03f14b8072c7b7dcf35335c1219e3a06d4
-  data.tar.gz: 4e2dfce6d976a54778fc33c58fa35ce287e0ca8e1639e22c65a64d8d1b14b5d5
+  metadata.gz: 8e229c930144facc3e61ab7b615f536cb2c4a19ab1802ecd4c08e3e6e55ddb7f
+  data.tar.gz: '09873f076e39a832fba35a764beba5196083e2a580d7b0762213f3ec90397474'
 SHA512:
-  metadata.gz: ddb7635512f01d14aee423d8a90e00fef37788f095f98bee018b5c53e313e0e827477c6b2f5656e159819bdbf953467e1fd072e418fe6ba8c67574d9e56023a7
-  data.tar.gz: f0e231ce2554f83dbcf6e2f7905e9c7b37021c84360434ea18f72595a11d84b9bae02bd22143760d4f3e69c28f53e4c6ebbdc7d4e744cb85e33a17b2a11c8f48
+  metadata.gz: 83edbce843bb5d1886e50f9a2f066c854b3bad9549a3a7edb7cc471d069754e8c6eeecb33d1772bdbd676e3791c1cca6efa526cdaaf93ed77f8e0257c6c0026e
+  data.tar.gz: 21ac5af1b9d2b06931c108ea7c351b16f63a52c4b389d440624baf737e31651ce5bea3b4dd564172955dea589f577b09856f3db77b24eff7121e1df9b8c156c6

data/README.md

@@ -11,7 +11,7 @@ a new markup-based typesetting system that is powerful and easy to learn.
 
 Add the following to your gemfile and `bundle install`
 ```ruby
-gem 'typst', '>= 0.15.1.8'
+gem 'typst', '>= 0.15.1.10'
 ```
 or install from the command line:
 ```bash
@@ -92,6 +92,12 @@ doc = t.compile(:pdf)
 doc = t.compile(:pdf, pdf_standards: ["2.0"])
 ```
 
+#### Compile to PDF without tags
+Typst tags PDFs by default so that screen readers and other assistive technology can read them. The tags can make up much of a large document's size; like the CLI's `--no-pdf-tags`, `tagged: false` leaves them out. The PDF/A-1a, A-2a, A-3a and UA-1 standards require tags.
+```ruby
+doc = t.compile(:pdf, tagged: false)
+```
+
 #### Compile to SVG
 ```ruby
 doc = t.compile(:svg)
@@ -115,9 +121,10 @@ doc = t.compile(:html_experimental)
 ### Output
 
 #### Return compiled content as an array of bytes
+One array of integers per page. For large output prefer `pages` (below), which returns binary Strings: `bytes` makes a Ruby Integer of every byte.
 ```ruby
 pdf_bytes = Typst("readme.typ").compile(:pdf).bytes
-# => [37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]
+# => [[37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]]
 ```
 
 #### Write compiled output to a file
@@ -127,6 +134,7 @@ doc.write("filename.pdf")
 ```
 
 #### Return PDF, SVG, PNG or HTML content as an array of pages
+Each page is a binary (ASCII-8BIT) String; PDF and HTML output is a single page.
 ```ruby
 Typst("readme.typ").compile(:pdf).pages
 # => ["%PDF-1.7\n%\x80\x80\x80\x80\n\n1 0 obj\n<<\n  /Type /Pages\n  /Count 3\n  /Kids [160 0 R 162 ...
@@ -323,7 +331,10 @@ Defect resolutions by [adam12](https://github.com/adam12) and [walterdavis](http
 Design suggestions by [alec-c4](https://github.com/alec-c4)\
 Compiler warnings were contributed by [TheSoloHacker47](https://github.com/TheSoloHacker47) \
 Font optimization patches were contributed by [dmke](https://github.com/dmke) \
-Concurrency patches were contributed by [dmke](https://github.com/dmke)
+Concurrency patches were contributed by [dmke](https://github.com/dmke) \
+Fix for sys_inputs in query by [vitaliiorlov](https://github.com/vitaliiorlov) \
+Ability to optionally disable PDF tags by [vitaliiorlov](https://github.com/vitaliiorlov) \
+Reducing memory of typst compiled output from rust to ruby by [vitaliiorlov](https://github.com/vitaliiorlov)
 
 ## License
 

data/README.typ

@@ -19,7 +19,7 @@ Ruby language binding to #link("https://github.com/typst/typst")[typst], a new m
 
 Add the following to your gemfile and `bundle install`
 ```ruby
-gem 'typst', '>= 0.15.1.5'
+gem 'typst', '>= 0.15.1.10'
 ```
 or install from the command line:
 ```bash
@@ -99,6 +99,12 @@ doc = t.compile(:pdf)
 doc = t.compile(:pdf, pdf_standards: ["2.0"])
 ```
 
+==== Compile to PDF without tags
+Typst tags PDFs by default so that screen readers and other assistive technology can read them. The tags can make up much of a large document's size; like the CLI's `--no-pdf-tags`, `tagged: false` leaves them out. The PDF/A-1a, A-2a, A-3a and UA-1 standards require tags.
+```ruby
+doc = t.compile(:pdf, tagged: false)
+```
+
 ==== Compile to SVG
 ```ruby
 doc = t.compile(:svg)
@@ -122,9 +128,10 @@ doc = t.compile(:html_experimental)
 === Output
 
 ==== Return compiled content as an array of bytes
+One array of integers per page. For large output prefer `pages` (below), which returns binary Strings: `bytes` makes a Ruby Integer of every byte.
 ```ruby
 pdf_bytes = Typst("readme.typ").compile(:pdf).bytes
-# => [37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]
+# => [[37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]]
 ```
 
 ==== Write compiled output to a file
@@ -134,6 +141,7 @@ doc.write("filename.pdf")
 ```
 
 ==== Return PDF, SVG, PNG or HTML content as an array of pages
+Each page is a binary (ASCII-8BIT) String; PDF and HTML output is a single page.
 ```ruby
 Typst("readme.typ").compile(:pdf).pages
 # => ["%PDF-1.7\n%\x80\x80\x80\x80\n\n1 0 obj\n<<\n  /Type /Pages\n  /Count 3\n  /Kids [160 0 R 162 ...
@@ -331,8 +339,12 @@ clear_cache was contributed by #link("https://github.com/NRicciVestmark")[NRicci
 CI improvements were contributed by #link("https://github.com/am1006")[am1006]\
 Defect resolutions by #link("https://github.com/adam12")[adam12] and #link("https://github.com/walterdavis")[walterdavis]\
 Design suggestions by #link("https://github.com/alec-c4")[alec-c4]\
-Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47]
-Concurrency patches were contributed by #link("https://github.com/dmke")[dmke]
+Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47] \
+Font optimization patches were contributed by #link("https://github.com/dmke")[dmke] \
+Concurrency patches were contributed by #link("https://github.com/dmke")[dmke] \
+Fix for sys_inputs in query by #link("https://github.com/vitaliiorlov")[vitaliiorlov] \
+Ability to optionally disable PDF tags by #link("https://github.com/vitaliiorlov")[vitaliiorlov] \
+Reducing memory of typst compiled output from rust to ruby by #link("https://github.com/vitaliiorlov")
 
 == License
 

data/ext/typst/src/compiler.rs

@@ -20,6 +20,7 @@ impl SystemWorld {
         format: Option<&str>,
         ppi: Option<f32>,
         pdf_standards: &[typst_pdf::PdfStandard],
+        tagged: bool,
         pretty: bool,
         render_bleed: bool,
     ) -> StrResult<(Vec<Vec<u8>>, Vec<String>)> {
@@ -50,6 +51,7 @@ impl SystemWorld {
                                 typst_pdf::PdfStandards::new(pdf_standards)
                                     .map_err(|e| eco_format!("PDF standards error: {:?}", e))
                                     .at(Span::detached()).unwrap(),
+                                tagged,
                                 pretty,
                             )?],
                             "png" => export_image(&document, ImageExportFormat::Png, ppi, pretty, render_bleed)?,
@@ -106,6 +108,7 @@ fn export_pdf(
     document: &PagedDocument,
     world: &SystemWorld,
     standards: typst_pdf::PdfStandards,
+    tagged: bool,
     pretty: bool,
 ) -> StrResult<Vec<u8>> {
     let buffer = typst_pdf::pdf(
@@ -114,6 +117,7 @@ fn export_pdf(
             ident: typst::foundations::Smart::Auto,
             timestamp: now().map(typst_pdf::Timestamp::new_utc),
             standards,
+            tagged,
             pretty,
             ..Default::default()
         },

data/ext/typst/src/lib.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use magnus::{function, prelude::*, Error, Ruby};
+use magnus::{function, prelude::*, Error, RArray, Ruby};
 
 use std::collections::HashMap;
 use query::{query as typst_query, QueryCommand, SerializationFormat};
@@ -16,6 +16,13 @@ mod nogvl;
 mod query;
 mod world;
 
+/// Hands the compiled pages to Ruby as binary (ASCII-8BIT) Strings, one per
+/// page. Returned as they are, each `Vec<u8>` would become an Array holding
+/// an Integer per byte.
+fn binary_pages(ruby: &Ruby, pages: Vec<Vec<u8>>) -> RArray {
+    ruby.ary_from_iter(pages.into_iter().map(|page| ruby.str_from_slice(&page)))
+}
+
 fn to_html(
     input: PathBuf,
     root: Option<PathBuf>,
@@ -63,11 +70,11 @@ fn to_html(
         .build()
         .map_err(|msg| msg.to_string())?;
 
-    let compiled = world
-        .compile(Some("html"), None, &Vec::new(), pretty, render_bleed)
+    let (pages, warnings) = world
+        .compile(Some("html"), None, &Vec::new(), true, pretty, render_bleed)
         .map_err(|msg| msg.to_string())?;
 
-    Ok(compiled)
+    Ok((pages, warnings))
 }
 
 fn route_to_html(
@@ -81,15 +88,20 @@ fn route_to_html(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
-    if concurrent {
+) -> Result<(RArray, Vec<String>), Error> {
+    let result = if concurrent {
         without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
             to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
         })
     } else {
         to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
     }
-    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg));
+
+    match result {
+        Ok((pages, warnings)) => Ok((binary_pages(ruby, pages), warnings)),
+        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))
+    }
 }
 
 fn to_svg(
@@ -126,11 +138,11 @@ fn to_svg(
         .build()
         .map_err(|msg| msg.to_string())?;
 
-    let compiled = world
-        .compile(Some("svg"), None, &Vec::new(), pretty, render_bleed)
+    let (pages, warnings) = world
+        .compile(Some("svg"), None, &Vec::new(), true, pretty, render_bleed)
         .map_err(|msg| msg.to_string())?;
 
-    Ok(compiled)
+    Ok((pages, warnings))
 }
 
 fn route_to_svg(
@@ -144,15 +156,20 @@ fn route_to_svg(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
-    if concurrent {
+) -> Result<(RArray, Vec<String>), Error> {
+    let result = if concurrent {
         without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
             to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
         })
     } else {
         to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
     }
-    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg));
+
+    match result {
+        Ok((pages, warnings)) => Ok((binary_pages(ruby, pages), warnings)),
+        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))
+    }
 }
 
 fn to_png(
@@ -189,11 +206,11 @@ fn to_png(
         .build()
         .map_err(|msg| msg.to_string())?;
 
-    let compiled = world
-        .compile(Some("png"), ppi, &Vec::new(), false, render_bleed)
+    let (pages, warnings) = world
+        .compile(Some("png"), ppi, &Vec::new(), true, false, render_bleed)
         .map_err(|msg| msg.to_string())?;
 
-    Ok(compiled)
+    Ok((pages, warnings))
 }
 
 fn route_to_png(
@@ -207,15 +224,20 @@ fn route_to_png(
     render_bleed: bool,
     sys_inputs: HashMap<String, String>,
     ppi: Option<f32>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
-    if concurrent {
+) -> Result<(RArray, Vec<String>), Error> {
+    let result = if concurrent {
         without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
             to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
         })
     } else {
         to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
     }
-    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg));
+
+    match result {
+        Ok((pages, warnings)) => Ok((binary_pages(ruby, pages), warnings)),
+        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))
+    }
 }
 
 fn to_pdf(
@@ -227,6 +249,7 @@ fn to_pdf(
     pretty: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
+    tagged: bool,
 ) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
         .map_err(|msg| msg.to_string())?;
@@ -281,11 +304,29 @@ fn to_pdf(
         }
     }
 
-    let compiled = world
-        .compile(Some("pdf"), None, &pdf_standards_vec, pretty, true)
+    // These standards require a tagged PDF. Typst would still write one that
+    // claims the standard, with none of its content tagged, so refuse as the
+    // CLI does for --no-pdf-tags.
+    if !tagged {
+        const ACCESSIBLE: &[(PdfStandard, &str)] = &[
+            (PdfStandard::A_1a, "PDF/A-1a"),
+            (PdfStandard::A_2a, "PDF/A-2a"),
+            (PdfStandard::A_3a, "PDF/A-3a"),
+            (PdfStandard::Ua_1, "PDF/UA-1"),
+        ];
+
+        for (standard, name) in ACCESSIBLE {
+            if pdf_standards_vec.contains(standard) {
+                return Err(format!("cannot disable PDF tags when exporting a {name} document").to_string());
+            }
+        }
+    }
+
+    let (pages, warnings) = world
+        .compile(Some("pdf"), None, &pdf_standards_vec, tagged, pretty, true)
         .map_err(|msg| msg.to_string())?;
 
-    Ok(compiled)
+    Ok((pages, warnings))
 }
 
 fn route_to_pdf(
@@ -299,15 +340,21 @@ fn route_to_pdf(
     pretty: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
-    if concurrent {
+    tagged: bool,
+) -> Result<(RArray, Vec<String>), Error> {
+    let result = if concurrent {
         without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
-            to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+            to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards, tagged)
         })
     } else {
-        to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+        to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards, tagged)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg));
+
+    match result {
+        Ok((pages, warnings)) => Ok((binary_pages(ruby, pages), warnings)),
+        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))
     }
-    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
 }
 
 fn query(
@@ -405,7 +452,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     env_logger::init();
 
     let module = ruby.define_module("Typst")?;
-    module.define_singleton_method("_to_pdf", function!(route_to_pdf, 9))?;
+    module.define_singleton_method("_to_pdf", function!(route_to_pdf, 10))?;
     module.define_singleton_method("_to_svg", function!(route_to_svg, 9))?;
     module.define_singleton_method("_to_png", function!(route_to_png, 9))?;
     module.define_singleton_method("_to_html", function!(route_to_html, 9))?;

data/lib/base.rb

@@ -48,7 +48,13 @@ module Typst
     end
 
     def typst_args(opts)
-      options.values_at(*opts).append(options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h)
+      options.values_at(*opts).append(typst_sys_inputs(options[:sys_inputs]))
+    end
+
+    # sys.inputs holds only strings, as the CLI's --input key=value does, so
+    # keys and values are converted.
+    def typst_sys_inputs(sys_inputs)
+      sys_inputs.map{ |k,v| [k.to_s,v.to_s] }.to_h
     end
 
     def typst_pretty_args
@@ -57,9 +63,10 @@ module Typst
 
     def typst_pdf_args
       options[:pdf_standards] ||= []
+      options[:tagged] = true if options[:tagged].nil?
       opts = typst_options - [:render_bleed] + [:pretty]
       args = typst_args(opts)
-      [*args, options[:pdf_standards]]
+      [*args, options[:pdf_standards], options[:tagged]]
     end
 
     def typst_png_args

data/lib/document.rb

@@ -1,14 +1,14 @@
 module Typst
   class Document
-    attr_accessor :bytes
-
     # Diagnostics the compiler emitted while *succeeding*. An unknown font
     # family is the common one: Typst substitutes another face, the document
     # generates, and nothing tells you unless you look here.
     attr_accessor :warnings
 
-    def initialize(bytes, warnings = [])
-      @bytes = bytes
+    # One binary String per page, as the extension returns them. An Array of
+    # Integers per page, what it returned before, is still accepted.
+    def initialize(pages, warnings = [])
+      @pages = binary_pages(pages)
       @warnings = warnings
     end
 
@@ -36,12 +36,34 @@ module Typst
       end
     end
 
+    # One binary (ASCII-8BIT) String per page; PDF and HTML output is a
+    # single page. Each call returns new Strings, as it did when it packed
+    # them every time. They share their bytes with the document until
+    # changed, so changing one (force_encoding, say) leaves the document as
+    # it was compiled.
     def pages
-      bytes.collect{ |page| page.pack("C*").to_s }
+      @pages.collect(&:dup)
+    end
+
+    # The pages as arrays of Integers. Prefer #pages: this makes a Ruby
+    # Integer of every byte.
+    def bytes
+      @pages.collect(&:bytes)
+    end
+
+    # Replaces the pages, given as #bytes returns them or as Strings.
+    def bytes=(pages)
+      @pages = binary_pages(pages)
     end
 
     def document
       pages.size == 1 ? pages.first : pages
     end
+
+    private
+
+    def binary_pages(pages)
+      pages.collect { |page| page.is_a?(Array) ? page.pack("C*") : page }
+    end
   end
 end

data/lib/query.rb

@@ -4,7 +4,7 @@ module Typst
 
     def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, concurrent: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, concurrent, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, concurrent, typst_sys_inputs(sys_inputs))
     end
 
     def result(raw: false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.15.1.9
+  version: 0.15.1.10
 platform: ruby
 authors:
 - Flinn
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.23
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.