imprimatur 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86be49aef4927f618e1ae2a92d7211f4c07239631f2b9e280d8a6d44730fbf26
-  data.tar.gz: 5ead3ff11b3ce1a0de6121138d45e049c316afd82e0e10d55c05cc7d183d2f3a
+  metadata.gz: 90d5145594d31e77fcde4acfeeecfb69156a5aa449740a54a6435e4f36d34595
+  data.tar.gz: '093e50e8ddca274d55841ee9a4b74f21b4061a6f16fc470cfd0985900eb96ec6'
 SHA512:
-  metadata.gz: 1d56f28369bd9373122a014fa597e11a948ef324a9462a8d7e231d39dd9e4472d5951cd36185af54c73686b3adc64d0fa5feae20b8b38125d239ac97da65e5e8
-  data.tar.gz: a5f77f9af0cbf86147f38af60c27a23b5674869eb480bd831538b440af88dffbaaf125071d568f590176b504104ea624458e8c2f6a571a23f6fb0cb809293fc7
+  metadata.gz: 6b9c5b392e20dc7d35c3e10de40f44af8b2664d7df6b7a152e0f3740c58354ed337ee012f675bde18c217e26c0586a3d952bc159970f29871b67a64366728610
+  data.tar.gz: bf43e139d43a48ed9910e152d9f98d5542a990da7131a61628bb320be40a7d10bee79992f11544735fddc54253c08b0031f4ab0bada9c397248f9b5c7eaf6f17

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.2.0](https://github.com/seuros/imprimatur/compare/v0.1.0...v0.2.0) (2026-10-16)
+
+
+### Features
+
+* read legacy XLS and ODS workbooks ([96b86fa](https://github.com/seuros/imprimatur/commit/96b86faab8eb04b80d33885c61b17ebad4f1f63a))
+* zip archive comments and entry listings ([a87f223](https://github.com/seuros/imprimatur/commit/a87f22330859ee4a583943ddbf107571cca9e841))
+* zip archives of any files ([d5ea579](https://github.com/seuros/imprimatur/commit/d5ea579ae1fc80a8ec6a1b213f442d490ededfba))
+
 ## 0.1.0 (2026-10-16)
 
 

data/Cargo.lock

@@ -230,7 +230,7 @@ dependencies = [
 
 [[package]]
 name = "imprimatur"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "aes",
  "crc32fast",
@@ -238,13 +238,14 @@ dependencies = [
  "miniz_oxide",
  "serde_json",
  "sha2",
+ "tempfile",
  "thiserror",
  "zip",
 ]
 
 [[package]]
 name = "imprimatur-cli"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "imprimatur",
  "regex",
@@ -256,7 +257,7 @@ dependencies = [
 
 [[package]]
 name = "imprimatur_native"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "imprimatur",
  "magnus",

data/Cargo.toml

@@ -10,7 +10,7 @@ license = "BSD-3-Clause"
 repository = "https://github.com/seuros/imprimatur"
 
 [workspace.dependencies]
-imprimatur = { path = "ext/imprimatur_native/core", version = "0.1.0" }
+imprimatur = { path = "ext/imprimatur_native/core", version = "0.2.0" }
 magnus = { version = "0.9.2", default-features = false }
 # For rb_thread_call_without_gvl2, which magnus does not wrap; magnus's own
 # rb-sys, features and all.

data/README.md

@@ -197,8 +197,8 @@ PDF, are the next step.
 
 ## Reading: documents as Markdown
 
-The other direction: a PDF, XLSX or DOCX printed as Markdown, for search
-indexes and language models.
+The other direction: a PDF, a workbook (XLSX, legacy XLS, ODS) or a DOCX
+printed as Markdown, for search indexes and language models.
 
 ```ruby
 Imprimatur.markdown("audit.pdf")              # a path
@@ -215,8 +215,8 @@ end
 - **PDF**: the text layer, placed glyph by glyph (fonts, encodings and
   ToUnicode maps, forms, rotated pages), in reading order (right-to-left
   lines too: Hebrew, Arabic, Persian, Urdu, Syriac, Dhivehi, N'Ko, Adlam,
-  their vowel marks kept on their letters), with headings by font size, hyphenated line breaks rejoined,
-  presentation forms (`fi`, Arabic contextual forms) as plain letters, and
+  their vowel marks kept on their letters), with headings by font size,
+  hyphenated line breaks rejoined, presentation forms (`fi`, Arabic contextual forms) as plain letters, and
   running headers and footers left out. Pages after the first start with
   `<!-- page N -->`. Encrypted PDFs open when the user password is empty, as
   it is for documents that only restrict printing or copying (RC4, AES-128,
@@ -224,6 +224,9 @@ end
 - **XLSX**: each sheet as a table under its name, values as Excel shows them
   (dates as dates, percentages, 15 significant digits), formulas without a
   cached result as `=FORMULA`, then the sheet's comments.
+- **XLS** (Excel 97–2003, and Excel 5.0/95 in Western European code pages)
+  and **ODS** (LibreOffice, OpenOffice): the same, sheet by sheet; an ODS
+  number keeps the text it shows. Legacy `.xls` comments are left out.
 - **DOCX**: headings (from styles and outline levels), bulleted and numbered
   lists, bold, italic, links, tables, text boxes; deleted text and field
   codes left out.
@@ -237,7 +240,7 @@ Documents are untrusted input, so reads are bounded: `max_bytes:` (512 MiB),
 `Imprimatur::LimitExceeded`. Reading runs without the GVL: other threads and
 fibers keep running, and `Timeout` or `Thread#raise` cancels it.
 `Imprimatur::PasswordRequired` and `Imprimatur::UnsupportedDocument` (legacy
-`.xls` and `.doc`, `.xlsb`, presentations) are the other errors to expect.
+`.doc`, `.xlsb`, presentations) are the other errors to expect.
 
 ### Structure and images
 
@@ -270,6 +273,25 @@ Imprimatur.images("scan.pdf") do |image|
 end
 ```
 
+## Zip archives
+
+Archives of any files, for what is not a document (an export of an order's
+files, a download to unpack). Entries keep their modification times and
+comments, files are streamed from disk, and archives past 4 GiB use ZIP64;
+reading is bounded per entry. Both run without the GVL.
+
+```ruby
+Imprimatur::Zip.write("export.zip") do |zip|
+  zip.add_file("contracts/0contract.pdf", "/tmp/contract.pdf", comment: "Contract")
+  zip.add("manifest.json", JSON.generate(manifest))
+end
+
+Imprimatur::Zip.open("geolite.zip") do |zip|
+  csv = zip.read(zip.glob("**/*-Locations-en.csv").first) # max_bytes: 1 GiB by default
+  zip.extract("README.txt", "/tmp/readme.txt")
+end
+```
+
 ## Command line
 
 The same reader as a static binary, for scripts and agents that would

data/ext/imprimatur_native/cli/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "imprimatur-cli"
-version = "0.1.0"
-description = "Read PDF, XLSX and DOCX documents as Markdown, from the command line."
+version = "0.2.0"
+description = "Read PDF, XLSX, XLS, ODS and DOCX documents as Markdown or JSON, search them, extract their images."
 keywords = ["pdf", "xlsx", "docx", "markdown", "cli"]
 categories = ["command-line-utilities", "text-processing"]
 readme = "README.md"

data/ext/imprimatur_native/cli/src/cli/grep.rs

@@ -127,7 +127,7 @@ fn lines<'c>(content: &'c Content, mut each: impl FnMut(Location<'c>, &str) -> b
                 }
             }
         }
-        Content::Xlsx(sheets) => {
+        Content::Xlsx(sheets) | Content::Ods(sheets) | Content::Xls(sheets) => {
             for sheet in sheets {
                 for cell in sheet.cells.cells() {
                     let reference = cell.reference();

data/ext/imprimatur_native/cli/src/cli/markdown.rs

@@ -16,8 +16,8 @@ use crate::app::{self, App, Out, Status};
 /// PDF: the text layer, placed glyph by glyph, with headings by font size,
 /// running headers and footers left out, and pages after the first marked
 /// `<!-- page N -->`. Encrypted PDFs open when their user password is
-/// empty. XLSX: each sheet as a table, values as Excel shows them, then its
-/// comments. DOCX: headings, lists, emphasis, links and tables.
+/// empty. XLSX, XLS and ODS: each sheet as a table, values as shown, then
+/// its comments. DOCX: headings, lists, emphasis, links and tables.
 ///
 /// With several documents, each is introduced by `<!-- file: PATH -->`. A
 /// document that fails is reported on standard error and the others are

data/ext/imprimatur_native/cli/src/cli.rs

@@ -22,11 +22,11 @@ pub const EXIT_STATUS: &str = "Exit status:
 1: a document is damaged, or a file could not be read or written
 2: the command line is wrong
 3: a PDF has no text layer: its pages are scans, which need OCR
-4: a PDF is encrypted with a password
-5: not a PDF, XLSX or DOCX (legacy .xls and .doc, .xlsb, presentations)
+4: a PDF or .xls is encrypted with a password
+5: not a PDF, XLSX, XLS, ODS or DOCX (legacy .doc, .xlsb, presentations)
 6: a limit was hit: size, decompressed size, nesting or time";
 
-/// Read PDF, XLSX and DOCX documents: as Markdown or JSON, searched, or their images
+/// Read PDF, XLSX, XLS, ODS and DOCX documents: as Markdown or JSON, searched, or their images
 ///
 /// The format is told by a document's content, not its name. Documents are
 /// untrusted input: reading is bounded in size, decompressed size, nesting
@@ -45,8 +45,8 @@ pub const EXIT_STATUS: &str = "Exit status:
     exit_code(1, "a document is damaged, or a file could not be read or written"),
     exit_code(2, "the command line is wrong"),
     exit_code(3, "a PDF has no text layer: its pages are scans, which need OCR"),
-    exit_code(4, "a PDF is encrypted with a password"),
-    exit_code(5, "not a PDF, XLSX or DOCX: legacy .xls and .doc, .xlsb, presentations"),
+    exit_code(4, "a PDF or .xls is encrypted with a password"),
+    exit_code(5, "not a PDF, XLSX, XLS, ODS or DOCX: legacy .doc, .xlsb, presentations"),
     exit_code(6, "a limit was hit: size, decompressed size, nesting or time"),
     after_long_help = EXIT_STATUS
 )]

data/ext/imprimatur_native/cli/src/main.rs

@@ -1,4 +1,4 @@
-//! `imprimatur`: documents in, Markdown out. Reads PDF, XLSX and DOCX with
+//! `imprimatur`: documents in, Markdown out. Reads PDF, XLSX, XLS, ODS and DOCX with
 //! the imprimatur crate; see `imprimatur --help`.
 
 mod app;

data/ext/imprimatur_native/core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "imprimatur"
-version = "0.1.0"
-description = "XLSX, PDF and DOCX authoring with its own XML, zip and PDF writers."
+version = "0.2.0"
+description = "XLSX, PDF and DOCX authoring, and PDF, XLSX, XLS, ODS and DOCX reading, with its own XML, zip and PDF code."
 keywords = ["xlsx", "excel", "pdf", "docx", "spreadsheet"]
 categories = ["encoding", "text-processing"]
 readme = "README.md"
@@ -23,11 +23,16 @@ miniz_oxide = "0.9.1"
 serde_json = { version = "1.0.154", optional = true }
 sha2 = "0.11.1"
 thiserror = "2.0.21"
+zip = { version = "9.0.3", default-features = false, features = ["deflate-flate2-zlib-rs"], optional = true }
 
 [features]
 # `read::json`: content and images as JSON, the schema the command line and
 # the Ruby binding share.
 json = ["dep:serde_json"]
+# `archive`: zip archives of any files (written with their times and
+# comments, ZIP64 when large; read within limits), through the `zip` crate.
+archive = ["dep:zip"]
 
 [dev-dependencies]
+tempfile = "3"
 zip = { version = "9.0.3", default-features = false, features = ["deflate-flate2-zlib-rs"] }

data/ext/imprimatur_native/core/README.md

@@ -56,7 +56,7 @@ text over 32,767 characters, formulas over 8,192, NaN and infinity, font
 sizes Excel cannot set, inline validation lists over 255 characters, and
 validations whose ranges overlap. A rejected row writes nothing.
 
-Reading goes the other way, any PDF, XLSX or DOCX to Markdown, within
+Reading goes the other way, any PDF, XLSX, XLS, ODS or DOCX to Markdown, within
 limits (input size, decompressed size, nesting, time, a cancel flag):
 
 ```rust
@@ -100,6 +100,11 @@ assert!(found.is_empty(), "no pictures in this one");
 Dependencies: `miniz_oxide`, `crc32fast` and `thiserror`; reading encrypted
 PDFs adds `md-5`, `sha2` and `aes`.
 
+Two features add what the core does not need: `json` (`read::json`, the
+schema the command line and the Ruby gem print, through `serde_json`) and
+`archive` (`archive::{Writer, Archive}`: zip archives of any files, with
+times, comments and ZIP64, through the `zip` crate).
+
 ## License
 
 BSD 3-Clause

data/ext/imprimatur_native/core/src/archive.rs

@@ -0,0 +1,292 @@
+//! Zip archives of any files, for what is not a document.
+//!
+//! Entries are written from disk (streamed) or from memory, with their
+//! modification times and comments, ZIP64 when an entry is large; they are
+//! read one by one, each within a size limit. Behind the `archive` feature,
+//! which brings in the `zip` crate; documents' own zips (XLSX, DOCX) never
+//! need it.
+//!
+//! ```
+//! use std::io::Cursor;
+//! use imprimatur::archive::{Archive, Writer};
+//!
+//! let mut writer = Writer::new(Cursor::new(Vec::new()));
+//! writer.add("notes/readme.txt", b"hello", Some("first"))?;
+//! let bytes = writer.finish()?.into_inner();
+//!
+//! let mut archive = Archive::new(Cursor::new(bytes))?;
+//! assert_eq!(archive.names(), ["notes/readme.txt"]);
+//! assert_eq!(archive.read("notes/readme.txt", 1024)?.as_deref(), Some(&b"hello"[..]));
+//! # Ok::<(), imprimatur::Error>(())
+//! ```
+
+#[cfg(test)]
+mod tests;
+
+use std::fs::File;
+use std::io::{self, Read, Seek, Write};
+use std::path::Path;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use ::zip::result::ZipError;
+use ::zip::write::FullFileOptions;
+use ::zip::{CompressionMethod, DateTime, ZipArchive, ZipWriter};
+
+use crate::{Error, Result};
+
+/// An archive being written; [`finish`](Self::finish) writes its directory.
+pub struct Writer<W: Write + Seek> {
+    zip: ZipWriter<W>,
+}
+
+impl Writer<File> {
+    /// A new archive at `path`, replacing any file there.
+    ///
+    /// # Errors
+    /// [`Error::Io`] when the file cannot be created.
+    pub fn create(path: impl AsRef<Path>) -> Result<Self> {
+        Ok(Self::new(File::create(path)?))
+    }
+}
+
+impl<W: Write + Seek> Writer<W> {
+    pub fn new(sink: W) -> Self {
+        Self { zip: ZipWriter::new(sink) }
+    }
+
+    /// Adds the file at `source` as `name`, streamed from disk, with its
+    /// modification time.
+    ///
+    /// # Errors
+    /// [`Error::Io`] when the file cannot be read or the archive written.
+    pub fn add_file(
+        &mut self,
+        name: &str,
+        source: impl AsRef<Path>,
+        comment: Option<&str>,
+    ) -> Result<()> {
+        let mut file = File::open(source)?;
+        let metadata = file.metadata()?;
+        self.zip
+            .start_file(name, options(metadata.modified().ok(), metadata.len(), comment))
+            .map_err(error)?;
+        io::copy(&mut file, &mut self.zip)?;
+        Ok(())
+    }
+
+    /// Adds `data` as `name`, dated now.
+    ///
+    /// # Errors
+    /// [`Error::Io`] when the archive cannot be written.
+    pub fn add(&mut self, name: &str, data: &[u8], comment: Option<&str>) -> Result<()> {
+        let size = u64::try_from(data.len()).unwrap_or(u64::MAX);
+        self.zip
+            .start_file(name, options(Some(SystemTime::now()), size, comment))
+            .map_err(error)?;
+        self.zip.write_all(data)?;
+        Ok(())
+    }
+
+    /// The archive's own comment, shown by most zip tools.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a comment over 65,535 bytes.
+    pub fn set_comment(&mut self, comment: &str) -> Result<()> {
+        self.zip.set_comment(comment).map_err(error)
+    }
+
+    /// Writes the central directory and gives the sink back.
+    ///
+    /// # Errors
+    /// [`Error::Io`] when it cannot be written.
+    pub fn finish(self) -> Result<W> {
+        self.zip.finish().map_err(error)
+    }
+}
+
+/// How an entry is written: deflated, dated, ZIP64 when it needs to be.
+fn options(
+    modified: Option<SystemTime>,
+    size: u64,
+    comment: Option<&str>,
+) -> FullFileOptions<'static, 'static> {
+    let options = FullFileOptions::default()
+        .compression_method(CompressionMethod::Deflated)
+        .last_modified_time(dos_time(modified))
+        .large_file(size >= u64::from(u32::MAX));
+    match comment {
+        Some(comment) => options.with_file_comment(comment),
+        None => options,
+    }
+}
+
+/// A time as a zip entry's (UTC, two-second steps, 1980 to 2107); the
+/// format's epoch outside that range.
+fn dos_time(time: Option<SystemTime>) -> DateTime {
+    let Some(seconds) =
+        time.and_then(|time| time.duration_since(UNIX_EPOCH).ok()).map(|since| since.as_secs())
+    else {
+        return DateTime::default();
+    };
+    let days = i64::try_from(seconds / 86_400).unwrap_or(i64::MAX);
+    let (year, month, day) = civil(days);
+    let clock = seconds % 86_400;
+    let part = |value: u64| u8::try_from(value).unwrap_or(0);
+    u16::try_from(year)
+        .ok()
+        .and_then(|year| {
+            DateTime::from_date_and_time(
+                year,
+                month,
+                day,
+                part(clock / 3600),
+                part(clock / 60 % 60),
+                part(clock % 60),
+            )
+            .ok()
+        })
+        .unwrap_or_default()
+}
+
+/// Days since 1970-01-01 as a proleptic Gregorian date (Howard Hinnant's
+/// `civil_from_days`).
+fn civil(days: i64) -> (i64, u8, u8) {
+    let days = days + 719_468;
+    let era = days.div_euclid(146_097);
+    let of_era = days.rem_euclid(146_097);
+    let year_of_era = (of_era - of_era / 1460 + of_era / 36_524 - of_era / 146_096) / 365;
+    let of_year = of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
+    let shifted = (5 * of_year + 2) / 153;
+    let day = u8::try_from(of_year - (153 * shifted + 2) / 5 + 1).unwrap_or(1);
+    let month = u8::try_from(if shifted < 10 { shifted + 3 } else { shifted - 9 }).unwrap_or(1);
+    let year = year_of_era + era * 400 + i64::from(month <= 2);
+    (year, month, day)
+}
+
+/// What the archive's directory says of an entry.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Entry {
+    pub name: String,
+    /// Its size once decompressed, as the directory states it.
+    pub size: u64,
+    pub compressed_size: u64,
+    pub crc32: u32,
+    pub comment: String,
+}
+
+/// An archive being read.
+pub struct Archive<R: Read + Seek> {
+    zip: ZipArchive<R>,
+}
+
+impl Archive<File> {
+    /// The archive at `path`.
+    ///
+    /// # Errors
+    /// [`Error::Io`] when it cannot be opened, [`Error::Malformed`] when it
+    /// is no zip.
+    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
+        Self::new(File::open(path)?)
+    }
+}
+
+impl<R: Read + Seek> Archive<R> {
+    /// # Errors
+    /// [`Error::Malformed`] when `source` is no zip.
+    pub fn new(source: R) -> Result<Self> {
+        Ok(Self { zip: ZipArchive::new(source).map_err(error)? })
+    }
+
+    /// The entries' names, in the archive's order.
+    #[must_use]
+    pub fn names(&self) -> Vec<String> {
+        self.zip
+            .file_names()
+            .filter_map(std::result::Result::ok)
+            .map(std::borrow::Cow::into_owned)
+            .collect()
+    }
+
+    /// Every entry's name, sizes, checksum and comment, in the archive's
+    /// order, without decompressing anything.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a damaged directory.
+    pub fn entries(&mut self) -> Result<Vec<Entry>> {
+        (0..self.zip.len())
+            .map(|index| {
+                let entry = self.zip.by_index_raw(index).map_err(error)?;
+                Ok(Entry {
+                    name: entry.name().map_err(error)?.into_owned(),
+                    size: entry.size(),
+                    compressed_size: entry.compressed_size(),
+                    crc32: entry.crc32(),
+                    comment: entry.comment().to_owned(),
+                })
+            })
+            .collect()
+    }
+
+    /// The entry `name`'s bytes, `None` when there is none.
+    ///
+    /// # Errors
+    /// [`Error::LimitExceeded`] past `limit` bytes, [`Error::PasswordRequired`]
+    /// for an encrypted entry, [`Error::Malformed`] for a damaged one.
+    pub fn read(&mut self, name: &str, limit: u64) -> Result<Option<Vec<u8>>> {
+        let mut out = Vec::new();
+        self.copy(name, &mut out, limit).map(|found| found.then_some(out))
+    }
+
+    /// Writes the entry `name` to the file at `path`; whether there was one.
+    ///
+    /// # Errors
+    /// As [`read`](Self::read), and [`Error::Io`] for the file.
+    pub fn extract(&mut self, name: &str, path: impl AsRef<Path>, limit: u64) -> Result<bool> {
+        if !self.names().iter().any(|entry| entry == name) {
+            return Ok(false);
+        }
+        let mut file = File::create(path)?;
+        self.copy(name, &mut file, limit)
+    }
+
+    /// Copies an entry's bytes to `out`, at most `limit` of them.
+    fn copy(&mut self, name: &str, out: &mut impl Write, limit: u64) -> Result<bool> {
+        let entry = match self.zip.by_name(name) {
+            Ok(entry) => entry,
+            Err(ZipError::FileNotFound) => return Ok(false),
+            Err(other) => return Err(error(other)),
+        };
+        // One byte past the limit tells a full entry from a cut one.
+        let copied = io::copy(&mut entry.take(limit.saturating_add(1)), out)?;
+        if copied > limit {
+            return Err(Error::LimitExceeded("decompressed size"));
+        }
+        Ok(true)
+    }
+}
+
+impl<W: Write + Seek> std::fmt::Debug for Writer<W> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.debug_struct("Writer").finish_non_exhaustive()
+    }
+}
+
+impl<R: Read + Seek> std::fmt::Debug for Archive<R> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.debug_struct("Archive").field("entries", &self.zip.len()).finish()
+    }
+}
+
+fn error(error: ZipError) -> Error {
+    match error {
+        ZipError::Io(error) => Error::Io(error),
+        ZipError::InvalidPassword => Error::PasswordRequired,
+        ZipError::UnsupportedArchive(reason) if reason.contains("assword") => {
+            Error::PasswordRequired
+        }
+        ZipError::UnsupportedArchive(reason) => {
+            Error::UnsupportedDocument(format!("a zip entry: {reason}"))
+        }
+        other => Error::malformed("zip", other.to_string()),
+    }
+}

data/ext/imprimatur_native/core/src/error.rs

@@ -97,7 +97,7 @@ pub enum Error {
     #[error("the PDF has no text layer: its pages are images, which need OCR")]
     NoTextLayer,
 
-    #[error("the PDF is encrypted with a password")]
+    #[error("the document is encrypted with a password")]
     PasswordRequired,
 
     #[error(transparent)]

data/ext/imprimatur_native/core/src/lib.rs

@@ -18,6 +18,8 @@
 //! # Ok::<(), imprimatur::Error>(())
 //! ```
 
+#[cfg(feature = "archive")]
+pub mod archive;
 pub mod doc;
 mod docx;
 mod error;

data/ext/imprimatur_native/core/src/read/content.rs

@@ -13,13 +13,17 @@ use super::span;
 use crate::xlsx::push_cell_reference;
 use crate::xlsx::{DateTime, cell_reference};
 
-/// A document's content, by format.
+/// A document's content, by format. Every workbook format holds sheets.
 #[derive(Debug, Clone, PartialEq)]
 #[non_exhaustive]
 pub enum Content {
     Pdf(Vec<Page>),
     Xlsx(Vec<Sheet>),
     Docx(Vec<Block>),
+    /// An `.ods` spreadsheet.
+    Ods(Vec<Sheet>),
+    /// A legacy Excel workbook (Excel 97 to 2003).
+    Xls(Vec<Sheet>),
 }
 
 impl Content {
@@ -30,6 +34,17 @@ impl Content {
             Self::Pdf(_) => super::Format::Pdf,
             Self::Xlsx(_) => super::Format::Xlsx,
             Self::Docx(_) => super::Format::Docx,
+            Self::Ods(_) => super::Format::Ods,
+            Self::Xls(_) => super::Format::Xls,
+        }
+    }
+
+    /// A workbook's sheets, whatever its format; `None` for documents.
+    #[must_use]
+    pub fn sheets(&self) -> Option<&[Sheet]> {
+        match self {
+            Self::Xlsx(sheets) | Self::Ods(sheets) | Self::Xls(sheets) => Some(sheets),
+            Self::Pdf(_) | Self::Docx(_) => None,
         }
     }
 }

data/ext/imprimatur_native/core/src/read/json.rs

@@ -18,7 +18,9 @@ pub fn content(content: &Content) -> Map<String, Json> {
     object.insert("format".into(), content.format().as_str().into());
     match content {
         Content::Pdf(pages) => object.insert("pages".into(), pages.iter().map(page).collect()),
-        Content::Xlsx(sheets) => object.insert("sheets".into(), sheets.iter().map(sheet).collect()),
+        Content::Xlsx(sheets) | Content::Ods(sheets) | Content::Xls(sheets) => {
+            object.insert("sheets".into(), sheets.iter().map(sheet).collect())
+        }
         Content::Docx(blocks) => object.insert("blocks".into(), blocks.iter().map(block).collect()),
     };
     object

data/ext/imprimatur_native/core/src/read/markdown.rs

@@ -23,7 +23,7 @@ impl Content {
         let mut out = String::new();
         match self {
             Self::Pdf(pages) => pdf(&mut out, pages),
-            Self::Xlsx(sheets) => {
+            Self::Xlsx(sheets) | Self::Ods(sheets) | Self::Xls(sheets) => {
                 for sheet in sheets {
                     write_sheet(&mut out, sheet);
                 }

data/ext/imprimatur_native/core/src/read/{xlsx/numbers.rs → numbers.rs}

@@ -1,5 +1,6 @@
-//! How XLSX number formats show numbers: which formats are dates, times
-//! or percentages, and Excel's General format.
+//! How spreadsheet number formats show numbers: which formats are dates,
+//! times or percentages, and Excel's General format. XLSX and XLS share
+//! Excel's format codes and built-in formats.
 
 use std::fmt::Write as _;
 
@@ -50,7 +51,7 @@ pub fn styles(text: &str, budget: &Budget<'_>) -> Result<Vec<Shown>> {
 
 /// Excel's built-in number formats (ECMA-376 Part 1, 18.8.30), with the
 /// East Asian date formats.
-const fn built_in(id: u32) -> Shown {
+pub const fn built_in(id: u32) -> Shown {
     match id {
         9 | 10 => Shown::Percent,
         14..=17 | 27..=31 | 34..=36 | 50..=58 => Shown::Date,