bare-x-to-pdf 0.5.2 → 0.6.0

package/README.md

@@ -131,10 +131,14 @@ Documents are often untrusted, so the engine caps what a small file can make it
 lay out. A document past a hard limit is rejected with an error. One past a soft limit still
 converts, with the value clamped.
 
-Rejected:
+Rejected, with `err.code` set to `'LIMIT'` so an app can tell these apart from a damaged
+file:
 
 - An archive part larger than 128 MB uncompressed.
 - XML nested more than 512 elements deep.
+- An XML part with more than 1,000,000 elements.
+- A document whose content needs more than 64 MB of Typst source to lay out, about 8,000
+  pages of dense text.
 - A spreadsheet that would print more than 30,000 cells.
 
 Clamped:
@@ -152,6 +156,19 @@ Clamped:
 
 Spreadsheet pages with no content are not printed, as in LibreOffice Calc.
 
+## Long documents
+
+Typst keeps every page in memory until a document is laid out, about 1 MB per page of dense
+text. A document whose content needs more than 2 MB of Typst source, about 270 pages, is
+laid out in chunks of that size instead, each ending where a page starts with a new
+paragraph or table, and the chunks are joined into one PDF. Pages, page numbers, totals,
+headers, footers and footnote numbers come out as in a single pass, and memory stays near
+what one chunk needs: a 5,900-page document peaks at about 510 MB instead of 6 GB.
+
+A chunked PDF is not tagged, since the tags of separate chunks cannot be joined, so it
+carries no structure for screen readers. Presentations with speaker notes are always laid
+out in a single pass.
+
 ## Development
 
 The platform packages in `npm/` are npm workspaces, and each declares its own `os` and `cpu`

package/binding.c

@@ -196,8 +196,14 @@ simple_converter__error(js_env_t *env, simple_converter_job_t *job) {
   }
   assert(err == 0);
 
+  js_value_t *code = NULL;
+  if (job->status == SC_STATUS_LIMIT) {
+    err = js_create_string_utf8(env, (utf8_t *) "LIMIT", (size_t) -1, &code);
+    assert(err == 0);
+  }
+
   js_value_t *error;
-  err = js_create_error(env, NULL, message, &error);
+  err = js_create_error(env, code, message, &error);
   assert(err == 0);
 
   return error;

package/core/include/simple_converter.h

@@ -8,6 +8,14 @@
 extern "C" {
 #endif
 
+enum {
+  SC_STATUS_OK = 0,
+  SC_STATUS_ERROR = 1,
+  SC_STATUS_PANIC = 2,
+  SC_STATUS_INVALID = 3,
+  SC_STATUS_LIMIT = 4,
+};
+
 typedef struct {
   uint8_t *data;
   size_t len;

package/core/src/error.rs

@@ -1,21 +1,38 @@
 use std::fmt;
 
 #[derive(Debug, Clone)]
-pub struct Error(String);
+pub struct Error {
+    message: String,
+    limit: bool,
+}
 
 impl Error {
     pub fn new(message: impl Into<String>) -> Self {
-        Error(message.into())
+        Error {
+            message: message.into(),
+            limit: false,
+        }
+    }
+
+    pub fn limit(message: impl Into<String>) -> Self {
+        Error {
+            message: message.into(),
+            limit: true,
+        }
     }
 
     pub fn message(&self) -> &str {
-        &self.0
+        &self.message
+    }
+
+    pub fn is_limit(&self) -> bool {
+        self.limit
     }
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.0)
+        f.write_str(&self.message)
     }
 }
 
@@ -23,18 +40,18 @@ impl std::error::Error for Error {}
 
 impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
-        Error(format!("io: {e}"))
+        Error::new(format!("io: {e}"))
     }
 }
 
 impl From<zip::result::ZipError> for Error {
     fn from(e: zip::result::ZipError) -> Self {
-        Error(format!("zip: {e}"))
+        Error::new(format!("zip: {e}"))
     }
 }
 
 impl From<quick_xml::Error> for Error {
     fn from(e: quick_xml::Error) -> Self {
-        Error(format!("xml: {e}"))
+        Error::new(format!("xml: {e}"))
     }
 }

package/core/src/lib.rs

@@ -157,7 +157,11 @@ pub unsafe extern "C" fn sc_convert(
         }
         Ok(Err(e)) => {
             *error = Buffer::from_vec(e.message().as_bytes().to_vec());
-            1
+            if e.is_limit() {
+                4
+            } else {
+                1
+            }
         }
         Err(payload) => {
             let message = payload

package/core/src/limits.rs

@@ -2,6 +2,7 @@ use crate::error::Error;
 use std::io::Read;
 
 pub const MAX_XML_DEPTH: usize = 512;
+pub const MAX_XML_ELEMENTS: usize = 1_000_000;
 pub const MAX_FORMULA_DEPTH: usize = 256;
 pub const MAX_ZIP_ENTRY_BYTES: u64 = 128 * 1024 * 1024;
 pub const MAX_TABLE_SPAN: usize = 1000;
@@ -19,6 +20,19 @@ pub const MAX_SHEET_CELLS: u64 = 30_000;
 pub const MIN_PAGE_SIDE: f64 = 72.0;
 pub const MAX_PAGE_SIDE: f64 = 14_400.0;
 pub const MAX_LENGTH: f64 = 1_000_000.0;
+pub const MAX_LAYOUT_SOURCE_BYTES: usize = 64 * 1024 * 1024;
+
+pub fn check_layout_source(bytes: usize) -> Result<(), Error> {
+    if bytes > MAX_LAYOUT_SOURCE_BYTES {
+        let mb = |n: usize| n.div_ceil(1024 * 1024);
+        return Err(Error::limit(format!(
+            "document is too large to convert: its content needs {} MB of layout source, more than the {} MB limit",
+            mb(bytes),
+            mb(MAX_LAYOUT_SOURCE_BYTES)
+        )));
+    }
+    Ok(())
+}
 
 pub fn span(value: usize) -> usize {
     value.clamp(1, MAX_TABLE_SPAN)
@@ -36,7 +50,7 @@ pub fn read_entry(reader: impl Read) -> Result<Vec<u8>, Error> {
     let mut data = Vec::new();
     reader.take(MAX_ZIP_ENTRY_BYTES + 1).read_to_end(&mut data)?;
     if data.len() as u64 > MAX_ZIP_ENTRY_BYTES {
-        return Err(Error::new(format!("a part of the document is larger than {} MB uncompressed", MAX_ZIP_ENTRY_BYTES / (1024 * 1024))));
+        return Err(Error::limit(format!("a part of the document is larger than {} MB uncompressed", MAX_ZIP_ENTRY_BYTES / (1024 * 1024))));
     }
     Ok(data)
 }

package/core/src/typst_backend/chunks.rs

@@ -0,0 +1,275 @@
+use super::emit::{self, Chunk};
+use super::fonts::FontSet;
+use super::{export, layout, merge};
+use crate::error::Error;
+use crate::model::Document;
+use std::num::NonZeroUsize;
+use std::ops::Range;
+use typst::foundations::{Label, NativeElement, Selector, Value};
+use typst::introspection::{Introspector, MetadataElem};
+use typst::layout::PageRanges;
+use typst::model::FootnoteElem;
+use typst::utils::PicoStr;
+use typst_layout::PagedDocument;
+use typst_pdf::PdfOptions;
+
+pub const CHUNK_SOURCE_BYTES: usize = 2 * 1024 * 1024;
+const TOP_TOLERANCE: f64 = 0.5;
+
+type Cursor = (usize, usize);
+
+type Sink<'a> = dyn FnMut(&PagedDocument, usize) -> Result<(), Error> + 'a;
+
+pub fn render(doc: &Document, fonts: &FontSet, sizes: &[Vec<usize>], uses_total_pages: bool) -> Result<Vec<u8>, Error> {
+    render_in_chunks(doc, fonts, sizes, uses_total_pages, CHUNK_SOURCE_BYTES)
+}
+
+fn render_in_chunks(doc: &Document, fonts: &FontSet, sizes: &[Vec<usize>], uses_total_pages: bool, budget: usize) -> Result<Vec<u8>, Error> {
+    let mut pdfs = Vec::new();
+    paginate(doc, fonts, sizes, uses_total_pages, budget, &mut |paged, keep| {
+        let options = PdfOptions {
+            tagged: false,
+            page_ranges: Some(PageRanges::new(vec![NonZeroUsize::new(1)..=NonZeroUsize::new(keep)])),
+            ..PdfOptions::default()
+        };
+        pdfs.push(export(paged, &options)?);
+        Ok(())
+    })?;
+    merge::merge(&pdfs)
+}
+
+fn paginate(doc: &Document, fonts: &FontSet, sizes: &[Vec<usize>], uses_total_pages: bool, budget: usize, sink: &mut Sink) -> Result<(), Error> {
+    let total_pages = if uses_total_pages {
+        Some(run(doc, fonts, sizes, None, budget, &mut |_, _| Ok(()))?)
+    } else {
+        None
+    };
+    run(doc, fonts, sizes, total_pages, budget, sink)?;
+    Ok(())
+}
+
+fn run(doc: &Document, fonts: &FontSet, sizes: &[Vec<usize>], total_pages: Option<u64>, budget: usize, sink: &mut Sink) -> Result<u64, Error> {
+    let mut last_number = 0;
+    let mut chunk = Chunk {
+        total_pages,
+        ..Chunk::default()
+    };
+    let mut cursor: Cursor = (0, 0);
+    while cursor.0 < sizes.len() {
+        let mut span = budget;
+        let (paged, keep, resume) = loop {
+            let (parts, next) = take(sizes, cursor, span);
+            chunk.parts = parts;
+            let paged = layout(emit::emit_chunk(doc, fonts, &chunk), fonts.clone())?;
+            let count = paged.pages().len();
+            if next.0 >= sizes.len() {
+                break (paged, count, next);
+            }
+            if let Some((keep, resume)) = find_cut(&paged, doc, cursor) {
+                break (paged, keep, resume);
+            }
+            drop(paged);
+            typst::comemo::evict(0);
+            span = span.saturating_mul(2);
+        };
+        if keep > 0 {
+            sink(&paged, keep)?;
+            last_number = paged.pages()[keep - 1].number;
+            chunk.page_number = Some(last_number + 1);
+        }
+        chunk.footnotes += footnotes_on(&paged, keep);
+        chunk.page_offset += keep;
+        chunk.resumed = true;
+        drop(paged);
+        typst::comemo::evict(0);
+        cursor = resume;
+    }
+    Ok(last_number)
+}
+
+fn take(sizes: &[Vec<usize>], cursor: Cursor, budget: usize) -> (Vec<(usize, Range<usize>)>, Cursor) {
+    let (mut section, mut block) = cursor;
+    let mut parts = Vec::new();
+    let mut used = 0;
+    while section < sizes.len() {
+        let start = block;
+        let blocks = &sizes[section];
+        while block < blocks.len() && (used < budget || (parts.is_empty() && block == start)) {
+            used += blocks[block];
+            block += 1;
+        }
+        parts.push((section, start..block));
+        if block < blocks.len() {
+            return (parts, (section, block));
+        }
+        section += 1;
+        block = 0;
+        if used >= budget {
+            break;
+        }
+    }
+    (parts, (section, 0))
+}
+
+fn find_cut(paged: &PagedDocument, doc: &Document, start: Cursor) -> Option<(usize, Cursor)> {
+    let label = Label::new(PicoStr::intern(emit::CUT_LABEL))?;
+    let introspector = paged.introspector();
+    let mut best: Option<(usize, Cursor)> = None;
+    for content in introspector.query(&Selector::Label(label)) {
+        let Some(meta) = content.to_packed::<MetadataElem>() else {
+            continue;
+        };
+        let Value::Int(id) = meta.value else {
+            continue;
+        };
+        let at = emit::cut_position(id);
+        if at <= start {
+            continue;
+        }
+        let Some(position) = content.location().and_then(|l| introspector.position(l)) else {
+            continue;
+        };
+        let page = position.page.get();
+        let Some(section) = doc.sections.get(at.0) else {
+            continue;
+        };
+        let scaled = section.content_scale > 0.0 && (section.content_scale - 1.0).abs() > 0.001;
+        if page < 2 || section.columns > 1 || scaled {
+            continue;
+        }
+        if (position.point.y.to_pt() - section.page.margin.top).abs() > TOP_TOLERANCE {
+            continue;
+        }
+        let better = match best {
+            None => true,
+            Some((best_page, best_at)) => page > best_page || (page == best_page && at < best_at),
+        };
+        if better {
+            best = Some((page, at));
+        }
+    }
+    best.map(|(page, at)| (page - 1, at))
+}
+
+fn footnotes_on(paged: &PagedDocument, pages: usize) -> usize {
+    let introspector = paged.introspector();
+    introspector
+        .query(&Selector::Elem(FootnoteElem::ELEM, None))
+        .iter()
+        .filter(|content| {
+            content
+                .location()
+                .and_then(|l| introspector.position(l))
+                .is_some_and(|p| p.page.get() <= pages)
+        })
+        .count()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fmt::Write;
+    use std::path::Path;
+    use typst::layout::{Frame, FrameItem};
+
+    const BUDGET: usize = 16 * 1024;
+
+    fn fixture(name: &str) -> (Document, FontSet) {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap();
+        let bytes = std::fs::read(root.join("test/fixtures").join(name)).unwrap();
+        let mut doc = crate::docx::read(&bytes).unwrap();
+        super::super::sanitize_pages(&mut doc);
+        (doc, FontSet::load(&root.join("fonts")).unwrap())
+    }
+
+    fn page_text(page: &typst_layout::Page) -> String {
+        fn walk(frame: &Frame, out: &mut String) {
+            for (point, item) in frame.items() {
+                match item {
+                    FrameItem::Group(group) => walk(&group.frame, out),
+                    FrameItem::Text(text) => {
+                        let _ = write!(out, "{:.2},{:.2} {}|", point.x.to_pt(), point.y.to_pt(), text.text);
+                    }
+                    _ => {}
+                }
+            }
+        }
+        let mut out = format!("#{} ", page.number);
+        walk(&page.frame, &mut out);
+        out
+    }
+
+    fn chunked_pages(name: &str) -> (Vec<String>, Vec<Vec<String>>) {
+        let (doc, fonts) = fixture(name);
+        let full = emit::emit(&doc, &fonts);
+        let sizes = full.block_sizes.clone();
+        let uses_total_pages = full.uses_total_pages;
+        let single = layout(full, fonts.clone()).unwrap().pages().iter().map(page_text).collect();
+        let mut chunks = Vec::new();
+        paginate(&doc, &fonts, &sizes, uses_total_pages, BUDGET, &mut |paged, keep| {
+            chunks.push(paged.pages()[..keep].iter().map(page_text).collect());
+            Ok(())
+        })
+        .unwrap();
+        (single, chunks)
+    }
+
+    fn assert_same_pages(single: &[String], chunks: &[Vec<String>]) {
+        let chunked: Vec<&String> = chunks.iter().flatten().collect();
+        assert_eq!(chunked.len(), single.len());
+        for (index, (a, b)) in chunked.iter().zip(single).enumerate() {
+            assert_eq!(*a, b, "page {}", index + 1);
+        }
+    }
+
+    #[test]
+    fn chunked_layout_matches_a_single_pass() {
+        let (doc, fonts) = fixture("chunked-sections.docx");
+        assert!(emit::emit(&doc, &fonts).uses_total_pages);
+        let (single, chunks) = chunked_pages("chunked-sections.docx");
+        assert!(chunks.len() >= 8, "only {} chunks", chunks.len());
+        assert_same_pages(&single, &chunks);
+    }
+
+    #[test]
+    fn chunks_never_end_inside_columns_or_a_table() {
+        let (single, chunks) = chunked_pages("chunked-no-cut.docx");
+        assert!(chunks.len() >= 3, "only {} chunks", chunks.len());
+        assert_same_pages(&single, &chunks);
+        let block_starts = ["Opening paragraph", "End of", "Columns paragraph 0:", "row 0 cell 0", "Closing paragraph"];
+        for chunk in &chunks[1..] {
+            let first = chunk[0].split_once('|').map_or("", |(text, _)| text);
+            assert!(block_starts.iter().any(|start| first.contains(start)), "a chunk starts inside a block: {first}");
+        }
+        let longest = chunks.iter().map(Vec::len).max().unwrap();
+        let table_pages = single.iter().filter(|page| page.contains("row ")).count();
+        assert!(longest >= table_pages, "the table was split across chunks");
+    }
+
+    #[test]
+    fn merged_pdf_is_well_formed() {
+        for name in ["chunked-sections.docx", "chunked-no-cut.docx"] {
+            let (doc, fonts) = fixture(name);
+            let full = emit::emit(&doc, &fonts);
+            let pages = layout(emit::emit(&doc, &fonts), fonts.clone()).unwrap().pages().len();
+            let pdf = render_in_chunks(&doc, &fonts, &full.block_sizes, full.uses_total_pages, BUDGET).unwrap();
+            assert_eq!(merge::check(&pdf).unwrap(), pages, "{name}");
+        }
+    }
+
+    #[test]
+    fn typst_pdfs_have_the_structure_merge_expects() {
+        let (doc, fonts) = fixture("chunked-sections.docx");
+        let paged = layout(emit::emit(&doc, &fonts), fonts).unwrap();
+        for tagged in [true, false] {
+            let options = PdfOptions {
+                tagged,
+                ..PdfOptions::default()
+            };
+            let pdf = export(&paged, &options).unwrap();
+            assert_eq!(merge::check(&pdf).unwrap(), paged.pages().len());
+            let doubled = merge::merge(&[pdf.clone(), pdf]).unwrap();
+            assert_eq!(merge::check(&doubled).unwrap(), 2 * paged.pages().len());
+        }
+    }
+}

package/core/src/typst_backend/emit.rs

@@ -9,12 +9,43 @@ const DEFAULT_SIZE: f64 = 11.0;
 const DEFAULT_CELL_MARGIN_X: f64 = 5.4;
 const TEXT_SHIFT: f64 = 0.1;
 
+pub const CUT_LABEL: &str = "sc-cut";
+
 pub struct Emitted {
     pub source: String,
     pub files: Vec<(String, Vec<u8>)>,
+    pub block_sizes: Vec<Vec<usize>>,
+    pub uses_total_pages: bool,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Chunk {
+    pub parts: Vec<(usize, std::ops::Range<usize>)>,
+    pub page_offset: usize,
+    pub page_number: Option<u64>,
+    pub footnotes: usize,
+    pub total_pages: Option<u64>,
+    pub resumed: bool,
+}
+
+pub fn cut_id(section: usize, block: usize) -> i64 {
+    ((section as i64) << 32) | block as i64
+}
+
+pub fn cut_position(id: i64) -> (usize, usize) {
+    ((id >> 32) as usize, (id & 0xffff_ffff) as usize)
 }
 
 pub fn emit(doc: &Document, fonts: &FontSet) -> Emitted {
+    let parts: Vec<(usize, std::ops::Range<usize>)> = doc.sections.iter().enumerate().map(|(i, s)| (i, 0..s.blocks.len())).collect();
+    run(doc, fonts, &parts, None)
+}
+
+pub fn emit_chunk(doc: &Document, fonts: &FontSet, chunk: &Chunk) -> Emitted {
+    run(doc, fonts, &chunk.parts, Some(chunk))
+}
+
+fn run(doc: &Document, fonts: &FontSet, parts: &[(usize, std::ops::Range<usize>)], chunk: Option<&Chunk>) -> Emitted {
     let mut emitter = Emitter {
         doc,
         fonts,
@@ -23,14 +54,23 @@ pub fn emit(doc: &Document, fonts: &FontSet) -> Emitted {
         page: RefCell::new(PageSetup::default()),
         para_line: Cell::new(None),
         table_depth: Cell::new(0),
+        chunk,
+        block_sizes: RefCell::new(Vec::new()),
+        uses_total_pages: Cell::new(false),
+        drop_leading_gap: Cell::new(chunk.is_some_and(|c| c.resumed)),
+        multi_column: false,
     };
     emitter.preamble();
-    for (index, section) in doc.sections.iter().enumerate() {
-        emitter.section(index, section);
+    for (position, (index, range)) in parts.iter().enumerate() {
+        if let Some(section) = doc.sections.get(*index) {
+            emitter.section(*index, section, range, position == 0);
+        }
     }
     Emitted {
         source: emitter.out,
         files: emitter.files.into_inner(),
+        block_sizes: emitter.block_sizes.into_inner(),
+        uses_total_pages: emitter.uses_total_pages.get(),
     }
 }
 
@@ -42,6 +82,11 @@ struct Emitter<'a> {
     page: RefCell<PageSetup>,
     para_line: Cell<Option<f64>>,
     table_depth: Cell<u32>,
+    chunk: Option<&'a Chunk>,
+    block_sizes: RefCell<Vec<Vec<usize>>>,
+    uses_total_pages: Cell<bool>,
+    drop_leading_gap: Cell<bool>,
+    multi_column: bool,
 }
 
 struct CellOut {
@@ -59,7 +104,7 @@ impl Emitter<'_> {
 
         let _ = writeln!(
             self.out,
-            "#set text(font: {}, size: {}, top-edge: \"ascender\", bottom-edge: \"descender\", hyphenate: false, fallback: true, kerning: false, lang: \"en\")",
+            "#set text(font: {}, size: {}, top-edge: \"ascender\", bottom-edge: \"descender\", hyphenate: false, fallback: true, kerning: true, lang: \"en\")",
             typst_str(&family),
             pt(size)
         );
@@ -79,18 +124,20 @@ impl Emitter<'_> {
         );
     }
 
-    fn section(&mut self, index: usize, section: &Section) {
+    fn section(&mut self, index: usize, section: &Section, range: &std::ops::Range<usize>, first_in_chunk: bool) {
         *self.page.borrow_mut() = section.page.clone();
         let page = &section.page;
+        let continued = range.start > 0;
 
-        let header = self.margin_slot(section, true, index);
-        let footer = self.margin_slot(section, false, index);
+        let header = self.margin_slot(section, true, index, continued);
+        let footer = self.margin_slot(section, false, index, continued);
         let section_columns = section.columns.min(crate::limits::MAX_TEXT_COLUMNS);
-        let columns = if section_columns > 1 {
+        let columns = if section_columns > 1 || self.multi_column {
             format!(", columns: {section_columns}")
         } else {
             String::new()
         };
+        self.multi_column = section_columns > 1;
         let _ = writeln!(
             self.out,
             "#set page(width: {}, height: {}, margin: (top: {}, bottom: {}, left: {}, right: {}){columns}, header: {header}, footer: {footer}, header-ascent: 0pt, footer-descent: 0pt)",
@@ -104,17 +151,27 @@ impl Emitter<'_> {
         if section_columns > 1 {
             let _ = writeln!(self.out, "#set columns(gutter: {})", pt(section.column_gap));
         }
-        if let Some(start) = section.page_start {
+        if let Some(chunk) = self.chunk.filter(|_| first_in_chunk) {
+            if let Some(number) = chunk.page_number {
+                let _ = writeln!(self.out, "#counter(page).update({number})");
+            }
+            if chunk.footnotes > 0 {
+                let _ = writeln!(self.out, "#counter(footnote).update({})", chunk.footnotes);
+            }
+        }
+        if let Some(start) = section.page_start.filter(|_| !continued) {
             let _ = writeln!(self.out, "#counter(page).update({})", start.clamp(0, i64::from(u32::MAX)));
         }
         let _ = writeln!(self.out, "#metadata(none) <section-{index}>");
-        for anchor in &section.anchors {
-            let mut placed = String::new();
-            self.anchor(anchor, &mut placed);
-            self.out.push_str(&placed);
+        if !continued {
+            for anchor in &section.anchors {
+                let mut placed = String::new();
+                self.anchor(anchor, &mut placed);
+                self.out.push_str(&placed);
+            }
         }
 
-        let blocks = self.blocks(&section.blocks, false);
+        let blocks = self.blocks_in(&section.blocks, false, Some((index, range)));
         if section.content_scale > 0.0 && (section.content_scale - 1.0).abs() > 0.001 {
             let percent = trim_num(section.content_scale * 100.0);
             let _ = writeln!(self.out, "#scale(x: {percent}%, y: {percent}%, reflow: true)[{blocks}]");
@@ -123,14 +180,14 @@ impl Emitter<'_> {
         }
     }
 
-    fn margin_slot(&self, section: &Section, header: bool, index: usize) -> String {
+    fn margin_slot(&self, section: &Section, header: bool, index: usize, continued: bool) -> String {
         let (default, first, even) = if header {
             (&section.header_default, &section.header_first, &section.header_even)
         } else {
             (&section.footer_default, &section.footer_first, &section.footer_even)
         };
         let empty: Vec<Block> = Vec::new();
-        let first = if section.title_page { Some(first.as_ref().unwrap_or(&empty)) } else { None };
+        let first = if section.title_page && !continued { Some(first.as_ref().unwrap_or(&empty)) } else { None };
         let even = if self.doc.even_odd_headers { Some(even.as_ref().unwrap_or(&empty)) } else { None };
         if default.is_none() && first.is_none() && even.is_none() {
             return "none".to_string();
@@ -159,7 +216,11 @@ impl Emitter<'_> {
         let even_expr = even.map(|e| render(Some(e)));
 
         let mut body = String::new();
-        let _ = write!(body, "context {{ let n = here().page(); let first = locate(<section-{index}>).page(); ");
+        let offset = match self.chunk.map_or(0, |c| c.page_offset) {
+            0 => String::new(),
+            pages => format!(" + {pages}"),
+        };
+        let _ = write!(body, "context {{ let n = here().page(){offset}; let first = locate(<section-{index}>).page(){offset}; ");
         if let Some(first_expr) = first_expr {
             let _ = write!(body, "if n == first {{ {first_expr} }} else ");
         }
@@ -171,6 +232,13 @@ impl Emitter<'_> {
     }
 
     fn blocks(&self, blocks: &[Block], trailing: bool) -> String {
+        self.blocks_in(blocks, trailing, None)
+    }
+
+    fn blocks_in(&self, blocks: &[Block], trailing: bool, top: Option<(usize, &std::ops::Range<usize>)>) -> String {
+        if top.is_some() && self.chunk.is_none() {
+            self.block_sizes.borrow_mut().push(Vec::with_capacity(blocks.len()));
+        }
         let mut out = String::new();
         let mut prev_after = 0.0;
         let mut prev_style: Option<&str> = None;
@@ -200,48 +268,74 @@ impl Emitter<'_> {
             .collect();
 
         for (index, block) in blocks.iter().enumerate() {
+            let emit = top.is_none_or(|(_, range)| range.contains(&index));
+            let leading = emit && top.is_some() && self.drop_leading_gap.replace(false);
+            let start = out.len();
+            let first_in_group = match block {
+                Block::Paragraph(_) => keys[index].is_none() || index == 0 || keys[index - 1] != keys[index],
+                _ => true,
+            };
+            let breaks_first = match block {
+                Block::Paragraph(p) => p.props.page_break_before == Some(true) || matches!(p.inlines.first(), Some(Inline::PageBreak)),
+                _ => false,
+            };
+            if let (Some((section, _)), Some(_), true, true, false) = (top, self.chunk, emit, first_in_group, breaks_first) {
+                let _ = writeln!(out, "#metadata({}) <{CUT_LABEL}>", cut_id(section, index));
+            }
             match block {
                 Block::Paragraph(p) => {
                     let key = &keys[index];
-                    let first_in_group = key.is_none() || index == 0 || keys[index - 1] != *key;
                     let last_in_group = key.is_none() || index + 1 == keys.len() || keys[index + 1] != *key;
                     let before = p.props.space_before.unwrap_or(0.0);
                     let same_style = prev_paragraph && p.props.style_id.as_deref() == prev_style;
                     let contextual = p.props.contextual_spacing.unwrap_or(false);
                     let lower = if same_style && prev_contextual { 0.0 } else { prev_after };
                     let upper = if same_style && contextual { 0.0 } else { before };
-                    let gap = if self.doc.additive_spacing {
+                    let gap = if leading {
+                        0.0
+                    } else if self.doc.additive_spacing {
                         lower + upper
                     } else {
                         lower.max(upper)
                     };
-                    self.paragraph(p, gap, first_in_group, last_in_group, &mut out);
+                    if emit {
+                        self.paragraph(p, gap, first_in_group, last_in_group, &mut out);
+                    }
                     prev_after = p.props.space_after.unwrap_or(0.0);
                     prev_style = p.props.style_id.as_deref();
                     prev_paragraph = true;
                     prev_contextual = contextual;
                 }
                 Block::Table(t) => {
-                    if prev_after > 0.01 {
-                        let _ = writeln!(out, "#v({})", pt(prev_after));
+                    if emit {
+                        if prev_after > 0.01 && !leading {
+                            let _ = writeln!(out, "#v({})", pt(prev_after));
+                        }
+                        self.table(t, &mut out);
                     }
-                    self.table(t, &mut out);
                     prev_after = 0.0;
                     prev_style = None;
                     prev_paragraph = false;
                     prev_contextual = false;
                 }
                 Block::Columns(c) => {
-                    if prev_after > 0.01 {
-                        let _ = writeln!(out, "#v({})", pt(prev_after));
+                    if emit {
+                        if prev_after > 0.01 && !leading {
+                            let _ = writeln!(out, "#v({})", pt(prev_after));
+                        }
+                        self.columns_block(c, &mut out);
                     }
-                    self.columns_block(c, &mut out);
                     prev_after = 0.0;
                     prev_style = None;
                     prev_paragraph = false;
                     prev_contextual = false;
                 }
             }
+            if top.is_some() && self.chunk.is_none() {
+                if let Some(sizes) = self.block_sizes.borrow_mut().last_mut() {
+                    sizes.push(out.len() - start);
+                }
+            }
         }
         if trailing && prev_after > 0.01 {
             let _ = writeln!(out, "#v({})", pt(prev_after));
@@ -431,7 +525,13 @@ impl Emitter<'_> {
                     any_text = true;
                     let value = match kind {
                         FieldKind::Page => format!("context counter(page).display({})", typst_str(self.page_pattern())),
-                        FieldKind::NumPages => "context counter(page).final().first()".to_string(),
+                        FieldKind::NumPages => {
+                            self.uses_total_pages.set(true);
+                            match self.chunk.and_then(|c| c.total_pages) {
+                                Some(total) => typst_str(&total.to_string()),
+                                None => "context counter(page).final().first()".to_string(),
+                            }
+                        }
                     };
                     items.push(self.text_expr_content(&value, props, spacing).to_string());
                     x = None;
@@ -1010,9 +1110,10 @@ impl Emitter<'_> {
     }
 
     fn register(&self, image: &ImageData) -> String {
+        let (format, data) = super::images::sanitize(image.format, &image.data);
         let mut files = self.files.borrow_mut();
-        let path = format!("media/img{}.{}", files.len() + 1, image.format.extension());
-        files.push((path.clone(), image.data.clone()));
+        let path = format!("media/img{}.{}", files.len() + 1, format.extension());
+        files.push((path.clone(), data));
         format!("/{path}")
     }
 

package/core/src/typst_backend/fonts.rs

@@ -10,6 +10,7 @@ const SANS: &str = "Liberation Sans";
 const SERIF: &str = "Liberation Serif";
 const MONO: &str = "Liberation Mono";
 
+#[derive(Clone)]
 pub struct FontSet {
     pub fonts: Vec<Font>,
     pub book: LazyHash<FontBook>,

package/core/src/typst_backend/images.rs

@@ -1,4 +1,5 @@
 use crate::limits::MAX_IMAGE_PIXELS;
+use crate::model::ImageFormat;
 use typst::foundations::Bytes;
 use typst::visualize::{ExchangeFormat, RasterImage};
 
@@ -8,24 +9,28 @@ const PLACEHOLDER: [u8; 68] = [
     0x02, 0x00, 0x00, 0x05, 0x00, 0x01, 0x7a, 0x5e, 0xab, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
 ];
 
-pub fn sanitize(path: &str, data: Vec<u8>) -> Vec<u8> {
-    let format = match path.rsplit('.').next() {
-        Some("png") => ExchangeFormat::Png,
-        Some("jpg") => ExchangeFormat::Jpg,
-        Some("gif") => ExchangeFormat::Gif,
-        _ => return data,
+pub fn sanitize(format: ImageFormat, data: &[u8]) -> (ImageFormat, Vec<u8>) {
+    let exchange = match format {
+        ImageFormat::Png => ExchangeFormat::Png,
+        ImageFormat::Jpeg => ExchangeFormat::Jpg,
+        ImageFormat::Gif => ExchangeFormat::Gif,
+        ImageFormat::Svg => return (format, data.to_vec()),
     };
-    let within_limit = dimensions(format, &data).is_some_and(|(w, h)| w > 0 && h > 0 && u64::from(w) * u64::from(h) <= MAX_IMAGE_PIXELS);
+    let within_limit = dimensions(exchange, data).is_some_and(|(w, h)| w > 0 && h > 0 && u64::from(w) * u64::from(h) <= MAX_IMAGE_PIXELS);
     if !within_limit {
-        return PLACEHOLDER.to_vec();
+        return placeholder();
     }
-    let bytes = Bytes::new(data);
-    match RasterImage::plain(bytes.clone(), format) {
-        Ok(_) => bytes.to_vec(),
-        Err(_) => PLACEHOLDER.to_vec(),
+    let bytes = Bytes::new(data.to_vec());
+    match RasterImage::plain(bytes.clone(), exchange) {
+        Ok(_) => (format, bytes.to_vec()),
+        Err(_) => placeholder(),
     }
 }
 
+fn placeholder() -> (ImageFormat, Vec<u8>) {
+    (ImageFormat::Png, PLACEHOLDER.to_vec())
+}
+
 fn dimensions(format: ExchangeFormat, data: &[u8]) -> Option<(u32, u32)> {
     match format {
         ExchangeFormat::Png => {

package/core/src/typst_backend/merge.rs

@@ -0,0 +1,286 @@
+use crate::error::Error;
+use std::io::Write;
+
+struct Parsed<'a> {
+    data: &'a [u8],
+    spans: Vec<Option<(usize, usize)>>,
+    header_end: usize,
+    root: usize,
+    info: Option<usize>,
+    id: Option<&'a [u8]>,
+    pages: usize,
+    kids: Vec<usize>,
+}
+
+pub fn merge(pdfs: &[Vec<u8>]) -> Result<Vec<u8>, Error> {
+    match pdfs {
+        [] => return Err(Error::new("cannot merge: no pages")),
+        [single] => return Ok(single.clone()),
+        _ => {}
+    }
+    let parsed = pdfs.iter().map(|pdf| parse(pdf)).collect::<Result<Vec<_>, _>>()?;
+    let objects: usize = parsed.iter().map(|p| p.spans.len() - 1).sum();
+    let pages_id = objects + 1;
+    let size = pages_id + 1;
+
+    let mut out = Vec::with_capacity(pdfs.iter().map(Vec::len).sum::<usize>() + size * 24);
+    out.extend_from_slice(&parsed[0].data[..parsed[0].header_end]);
+    let mut offsets: Vec<Option<usize>> = vec![None; size];
+    let mut kids = Vec::new();
+    let mut base = 0;
+    for (index, part) in parsed.iter().enumerate() {
+        let renumber = |id: usize| if id == part.pages { pages_id } else { base + id };
+        for (id, span) in part.spans.iter().enumerate() {
+            let Some((start, end)) = *span else {
+                continue;
+            };
+            let foreign_root = index > 0 && (id == part.root || Some(id) == part.info);
+            if id == part.pages || foreign_root {
+                continue;
+            }
+            let object = &part.data[start..end];
+            let body_at = find(object, b"obj").ok_or_else(broken)? + 3;
+            offsets[base + id] = Some(out.len());
+            let _ = write!(out, "{} 0 obj", base + id);
+            rewrite(&object[body_at..], &renumber, &mut out);
+        }
+        kids.extend(part.kids.iter().map(|&kid| base + kid));
+        base += part.spans.len() - 1;
+    }
+
+    offsets[pages_id] = Some(out.len());
+    let _ = write!(out, "{pages_id} 0 obj\n<</Type/Pages/Count {}/Kids[", kids.len());
+    for (i, kid) in kids.iter().enumerate() {
+        let _ = write!(out, "{}{kid} 0 R", if i > 0 { " " } else { "" });
+    }
+    out.extend_from_slice(b"]>>\nendobj\n");
+
+    let xref = out.len();
+    let _ = write!(out, "xref\n0 {size}\n");
+    for offset in &offsets {
+        match offset {
+            Some(at) => {
+                let _ = write!(out, "{at:010} 00000 n \n");
+            }
+            None => out.extend_from_slice(b"0000000000 65535 f \n"),
+        }
+    }
+    let first = &parsed[0];
+    let _ = write!(out, "trailer\n<</Size {size}/Root {} 0 R", first.root);
+    if let Some(info) = first.info {
+        let _ = write!(out, "/Info {info} 0 R");
+    }
+    if let Some(id) = first.id {
+        out.extend_from_slice(b"/ID");
+        out.extend_from_slice(id);
+    }
+    let _ = write!(out, ">>\nstartxref\n{xref}\n%%EOF\n");
+    Ok(out)
+}
+
+#[cfg(test)]
+pub fn check(pdf: &[u8]) -> Result<usize, Error> {
+    let parsed = parse(pdf)?;
+    let referenced = std::cell::RefCell::new(Vec::new());
+    for (start, end) in parsed.spans.iter().flatten().copied() {
+        let object = &pdf[start..end];
+        let body_at = find(object, b"obj").ok_or_else(broken)? + 3;
+        rewrite(
+            &object[body_at..],
+            &|id| {
+                referenced.borrow_mut().push(id);
+                id
+            },
+            &mut Vec::new(),
+        );
+    }
+    for id in referenced.into_inner() {
+        if parsed.spans.get(id).copied().flatten().is_none() {
+            return Err(Error::new(format!("dangling reference to object {id}")));
+        }
+    }
+    let parent = format!("/Parent {} 0 R", parsed.pages);
+    for &kid in &parsed.kids {
+        let (start, end) = parsed.spans.get(kid).copied().flatten().ok_or_else(broken)?;
+        let page = &pdf[start..end];
+        if find(page, b"/Type/Page").is_none() || find(page, parent.as_bytes()).is_none() {
+            return Err(Error::new(format!("page object {kid} is not a child of the page tree")));
+        }
+    }
+    Ok(parsed.kids.len())
+}
+
+fn broken() -> Error {
+    Error::new("cannot merge: unexpected PDF structure")
+}
+
+fn parse(data: &[u8]) -> Result<Parsed<'_>, Error> {
+    let startxref = rfind(data, b"startxref").ok_or_else(broken)?;
+    let xref = number_after(data, startxref + 9).ok_or_else(broken)?;
+    if !data.get(xref..).is_some_and(|rest| rest.starts_with(b"xref")) {
+        return Err(broken());
+    }
+    let trailer_at = xref + find(&data[xref..], b"trailer").ok_or_else(broken)?;
+    let table = std::str::from_utf8(&data[xref + 4..trailer_at]).map_err(|_| broken())?;
+    let mut tokens = table.split_ascii_whitespace();
+    let mut entries: Vec<(usize, usize)> = Vec::new();
+    let mut size = 0;
+    while let (Some(first), Some(count)) = (tokens.next(), tokens.next()) {
+        let first: usize = first.parse().map_err(|_| broken())?;
+        let count: usize = count.parse().map_err(|_| broken())?;
+        for id in first..first + count {
+            let (Some(offset), Some(_), Some(kind)) = (tokens.next(), tokens.next(), tokens.next()) else {
+                return Err(broken());
+            };
+            if kind == "n" {
+                entries.push((offset.parse().map_err(|_| broken())?, id));
+            }
+            size = size.max(id + 1);
+        }
+    }
+    entries.sort_unstable();
+    let mut spans = vec![None; size];
+    for (i, &(offset, id)) in entries.iter().enumerate() {
+        let end = entries.get(i + 1).map_or(xref, |&(next, _)| next);
+        if offset >= end || !data[offset..].starts_with(format!("{id} 0 obj").as_bytes()) {
+            return Err(broken());
+        }
+        spans[id] = Some((offset, end));
+    }
+    let header_end = entries.first().map(|&(offset, _)| offset).ok_or_else(broken)?;
+
+    let trailer = &data[trailer_at..startxref];
+    let root = reference_after(trailer, b"/Root").ok_or_else(broken)?;
+    let info = reference_after(trailer, b"/Info");
+    let id = find(trailer, b"/ID").and_then(|at| {
+        let rest = &trailer[at + 3..];
+        let open = rest.iter().position(|&c| c == b'[')?;
+        let close = rest.iter().position(|&c| c == b']')?;
+        (open < close).then(|| &rest[open..=close])
+    });
+
+    let object = |id: usize| spans.get(id).copied().flatten().map(|(start, end)| &data[start..end]);
+    let catalog = object(root).ok_or_else(broken)?;
+    let pages = reference_after(catalog, b"/Pages").ok_or_else(broken)?;
+    let tree = object(pages).ok_or_else(broken)?;
+    let kids_at = find(tree, b"/Kids").ok_or_else(broken)?;
+    let kids_end = kids_at + find(&tree[kids_at..], b"]").ok_or_else(broken)?;
+    let kids: Vec<usize> = std::str::from_utf8(&tree[kids_at + 5..kids_end])
+        .map_err(|_| broken())?
+        .trim_start_matches(|c: char| c == '[' || c.is_ascii_whitespace())
+        .split('R')
+        .filter_map(|r| r.split_ascii_whitespace().next().and_then(|n| n.parse().ok()))
+        .collect();
+    for &kid in &kids {
+        let page = object(kid).ok_or_else(broken)?;
+        if find(page, b"/Type/Pages").is_some() {
+            return Err(broken());
+        }
+    }
+
+    Ok(Parsed {
+        data,
+        spans,
+        header_end,
+        root,
+        info,
+        id,
+        pages,
+        kids,
+    })
+}
+
+fn rewrite(src: &[u8], renumber: &impl Fn(usize) -> usize, out: &mut Vec<u8>) {
+    let mut i = 0;
+    let mut nesting = 0usize;
+    while i < src.len() {
+        let c = src[i];
+        if nesting > 0 {
+            out.push(c);
+            match c {
+                b'\\' if i + 1 < src.len() => {
+                    out.push(src[i + 1]);
+                    i += 1;
+                }
+                b'(' => nesting += 1,
+                b')' => nesting -= 1,
+                _ => {}
+            }
+            i += 1;
+            continue;
+        }
+        let boundary = i == 0 || !is_regular(src[i - 1]);
+        if c == b'(' {
+            nesting = 1;
+        } else if boundary && src[i..].starts_with(b"stream") && src.get(i + 6).is_some_and(|&n| n == b'\r' || n == b'\n') {
+            out.extend_from_slice(&src[i..]);
+            return;
+        } else if boundary && c.is_ascii_digit() {
+            if let Some((id, len)) = reference(&src[i..]) {
+                let _ = write!(out, "{} 0 R", renumber(id));
+                i += len;
+                continue;
+            }
+            while i < src.len() && is_regular(src[i]) {
+                out.push(src[i]);
+                i += 1;
+            }
+            continue;
+        }
+        out.push(c);
+        i += 1;
+    }
+}
+
+fn reference(src: &[u8]) -> Option<(usize, usize)> {
+    let digits = |from: usize| src[from..].iter().take_while(|c| c.is_ascii_digit()).count();
+    let spaces = |from: usize| src[from..].iter().take_while(|c| c.is_ascii_whitespace()).count();
+    let id_len = digits(0);
+    let mut at = id_len;
+    let gap = spaces(at);
+    if gap == 0 {
+        return None;
+    }
+    at += gap;
+    let generation = digits(at);
+    if generation == 0 {
+        return None;
+    }
+    at += generation;
+    let gap = spaces(at);
+    if gap == 0 {
+        return None;
+    }
+    at += gap;
+    if src.get(at) != Some(&b'R') || src.get(at + 1).is_some_and(|&c| is_regular(c)) {
+        return None;
+    }
+    let id = std::str::from_utf8(&src[..id_len]).ok()?.parse().ok()?;
+    Some((id, at + 1))
+}
+
+fn is_regular(c: u8) -> bool {
+    !c.is_ascii_whitespace() && !b"()<>[]{}/%".contains(&c)
+}
+
+fn find(haystack: &[u8], needle: &[u8]) -> Option<usize> {
+    haystack.windows(needle.len()).position(|w| w == needle)
+}
+
+fn rfind(haystack: &[u8], needle: &[u8]) -> Option<usize> {
+    haystack.windows(needle.len()).rposition(|w| w == needle)
+}
+
+fn number_after(data: &[u8], from: usize) -> Option<usize> {
+    let rest = data.get(from..)?;
+    let start = rest.iter().position(|c| c.is_ascii_digit())?;
+    let len = rest[start..].iter().take_while(|c| c.is_ascii_digit()).count();
+    std::str::from_utf8(&rest[start..start + len]).ok()?.parse().ok()
+}
+
+fn reference_after(data: &[u8], key: &[u8]) -> Option<usize> {
+    let at = find(data, key)? + key.len();
+    let rest = &data[at..];
+    let start = rest.iter().position(|c| !c.is_ascii_whitespace())?;
+    reference(&rest[start..]).map(|(id, _)| id)
+}

package/core/src/typst_backend/mod.rs

@@ -1,6 +1,8 @@
+mod chunks;
 pub mod emit;
 pub mod fonts;
 mod images;
+mod merge;
 mod notes;
 pub mod world;
 
@@ -22,24 +24,23 @@ pub fn render_pdf(mut document: Document, fonts_dir: &Path) -> Result<Vec<u8>, E
     if let Ok(path) = std::env::var("SIMPLE_CONVERTER_DUMP_TYPST") {
         let _ = std::fs::write(path, &emitted.source);
     }
-    if let Ok(path) = std::env::var("SIMPLE_CONVERTER_LOAD_TYPST") {
+    let loaded = std::env::var("SIMPLE_CONVERTER_LOAD_TYPST").ok();
+    if let Some(path) = &loaded {
         emitted.source = std::fs::read_to_string(path).map_err(|e| Error::new(format!("cannot read typst source: {e}")))?;
     }
+    crate::limits::check_layout_source(emitted.source.len())?;
 
-    let mut world = ConverterWorld::new(emitted.source, fonts);
-    for (path, data) in emitted.files {
-        let data = images::sanitize(&path, data);
-        world.add_file(&path, data)?;
+    let has_notes = doc.sections.iter().any(|s| !s.notes.is_empty());
+    if loaded.is_none() && !has_notes && emitted.source.len() > chunks::CHUNK_SOURCE_BYTES {
+        let block_sizes = std::mem::take(&mut emitted.block_sizes);
+        let uses_total_pages = emitted.uses_total_pages;
+        drop(emitted);
+        return chunks::render(doc, &fonts, &block_sizes, uses_total_pages);
     }
-    let compiled = typst::compile::<PagedDocument>(&world);
-    let paged = compiled
-        .output
-        .map_err(|errors| Error::new(format!("layout failed: {}", diagnostics(&errors))))?;
 
-    let mut pdf = typst_pdf::pdf(&paged, &PdfOptions::default())
-        .map_err(|errors| Error::new(format!("pdf export failed: {}", diagnostics(&errors))))?;
+    let paged = layout(emitted, fonts)?;
+    let mut pdf = export(&paged, &PdfOptions::default())?;
 
-    let has_notes = doc.sections.iter().any(|s| !s.notes.is_empty());
     if has_notes && paged.pages().len() == doc.sections.len() {
         let pages: Vec<(f64, &[crate::model::PageNote])> =
             doc.sections.iter().map(|s| (s.page.height, s.notes.as_slice())).collect();
@@ -50,6 +51,20 @@ pub fn render_pdf(mut document: Document, fonts_dir: &Path) -> Result<Vec<u8>, E
     Ok(pdf)
 }
 
+fn layout(emitted: emit::Emitted, fonts: FontSet) -> Result<PagedDocument, Error> {
+    let mut world = ConverterWorld::new(emitted.source, fonts);
+    for (path, data) in emitted.files {
+        world.add_file(&path, data)?;
+    }
+    typst::compile::<PagedDocument>(&world)
+        .output
+        .map_err(|errors| Error::new(format!("layout failed: {}", diagnostics(&errors))))
+}
+
+fn export(paged: &PagedDocument, options: &PdfOptions) -> Result<Vec<u8>, Error> {
+    typst_pdf::pdf(paged, options).map_err(|errors| Error::new(format!("pdf export failed: {}", diagnostics(&errors))))
+}
+
 fn diagnostics(errors: &[SourceDiagnostic]) -> String {
     let mut messages: Vec<String> = Vec::new();
     for error in errors {

package/core/src/xlsx/mod.rs

@@ -1186,7 +1186,7 @@ fn paginate(sheet: &Sheet, name: &str, styles: &Styles, cells: &mut u64) -> Resu
     for (rg, cg) in &order {
         *cells += (rg.len() * cg.len()) as u64;
         if *cells > crate::limits::MAX_SHEET_CELLS {
-            return Err(Error::new(format!("the spreadsheet is too large to convert: more than {} cells to print", crate::limits::MAX_SHEET_CELLS)));
+            return Err(Error::limit(format!("the spreadsheet is too large to convert: more than {} cells to print", crate::limits::MAX_SHEET_CELLS)));
         }
     }
 

package/core/src/xlsx/ods.rs

@@ -389,7 +389,7 @@ fn read_table(table: &Element, odf: &OdfStyles, formats: &mut Formats, pkg: &Pac
         let repeats = if has_content || !template.cells.is_empty() { count.min(4096) } else { count };
         materialised += template.cells.len() as u64 * u64::from(repeats);
         if materialised > crate::limits::MAX_SHEET_CELLS {
-            return Err(Error::new(format!("the spreadsheet is too large to convert: more than {} cells", crate::limits::MAX_SHEET_CELLS)));
+            return Err(Error::limit(format!("the spreadsheet is too large to convert: more than {} cells", crate::limits::MAX_SHEET_CELLS)));
         }
         if !template.cells.is_empty() || height.is_some() || hidden {
             for k in 0..repeats.min(if template.cells.is_empty() { 1 } else { repeats }) {

package/core/src/xml.rs

@@ -64,12 +64,23 @@ pub fn parse(bytes: &[u8]) -> Result<Element, Error> {
         name: String::from("#document"),
         ..Element::default()
     }];
+    let mut elements: usize = 0;
 
     loop {
-        match reader.read_event()? {
+        let event = reader.read_event()?;
+        if matches!(event, Event::Start(_) | Event::Empty(_)) {
+            elements += 1;
+            if elements > crate::limits::MAX_XML_ELEMENTS {
+                return Err(Error::limit(format!(
+                    "document is too large to convert: a part has more than {} XML elements",
+                    crate::limits::MAX_XML_ELEMENTS
+                )));
+            }
+        }
+        match event {
             Event::Start(start) => {
                 if stack.len() > crate::limits::MAX_XML_DEPTH {
-                    return Err(Error::new(format!("xml: elements are nested more than {} levels deep", crate::limits::MAX_XML_DEPTH)));
+                    return Err(Error::limit(format!("xml: elements are nested more than {} levels deep", crate::limits::MAX_XML_DEPTH)));
                 }
                 stack.push(element(&start)?)
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-x-to-pdf",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Convert Word, PowerPoint, Excel and OpenDocument files to PDF for Bare: a Rust engine on Typst",
   "main": "index.js",
   "exports": {
@@ -118,16 +118,16 @@
     }
   },
   "optionalDependencies": {
-    "bare-x-to-pdf-android-arm": "0.5.2",
-    "bare-x-to-pdf-android-arm64": "0.5.2",
-    "bare-x-to-pdf-android-x64": "0.5.2",
-    "bare-x-to-pdf-darwin-arm64": "0.5.2",
-    "bare-x-to-pdf-darwin-x64": "0.5.2",
-    "bare-x-to-pdf-ios-arm64": "0.5.2",
-    "bare-x-to-pdf-ios-arm64-simulator": "0.5.2",
-    "bare-x-to-pdf-ios-x64-simulator": "0.5.2",
-    "bare-x-to-pdf-linux-arm64": "0.5.2",
-    "bare-x-to-pdf-linux-x64": "0.5.2",
-    "bare-x-to-pdf-win32-x64": "0.5.2"
+    "bare-x-to-pdf-android-arm": "0.6.0",
+    "bare-x-to-pdf-android-arm64": "0.6.0",
+    "bare-x-to-pdf-android-x64": "0.6.0",
+    "bare-x-to-pdf-darwin-arm64": "0.6.0",
+    "bare-x-to-pdf-darwin-x64": "0.6.0",
+    "bare-x-to-pdf-ios-arm64": "0.6.0",
+    "bare-x-to-pdf-ios-arm64-simulator": "0.6.0",
+    "bare-x-to-pdf-ios-x64-simulator": "0.6.0",
+    "bare-x-to-pdf-linux-arm64": "0.6.0",
+    "bare-x-to-pdf-linux-x64": "0.6.0",
+    "bare-x-to-pdf-win32-x64": "0.6.0"
   }
 }