imprimatur 0.1.0 → 0.2.0

data/ext/imprimatur_native/core/src/read/xls/strings.rs

@@ -0,0 +1,156 @@
+//! Workbook strings: BIFF8's Latin-1 or UTF-16, BIFF5's Windows-1252
+//! bytes, and BIFF8's shared string table, whose strings may be split
+//! across `CONTINUE` records.
+
+use crate::Result;
+use crate::pdf::metrics::WIN_ANSI_HIGH;
+use crate::read::Budget;
+
+/// How a workbook's strings are stored.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Encoding {
+    /// BIFF8: each string says whether it is Latin-1 or UTF-16.
+    Unicode,
+    /// BIFF5: bytes in the workbook's code page.
+    Windows1252,
+}
+
+/// A string with a 1-byte or 2-byte character count at `at`; `None` past
+/// the end.
+pub fn string(bytes: &[u8], at: usize, wide_count: bool, encoding: Encoding) -> Option<String> {
+    let (count, at) = if wide_count {
+        (usize::from(u16::from_le_bytes(bytes.get(at..at + 2)?.try_into().ok()?)), at + 2)
+    } else {
+        (usize::from(*bytes.get(at)?), at + 1)
+    };
+    if encoding == Encoding::Windows1252 {
+        let chars = bytes.get(at..at + count).or_else(|| bytes.get(at..))?;
+        return Some(chars.iter().map(|&byte| windows_1252(byte)).collect());
+    }
+    let high = bytes.get(at)? & 1 != 0;
+    let mut out = String::with_capacity(count);
+    let mut units = Vec::new();
+    let width = if high { 2 } else { 1 };
+    let chars = bytes.get(at + 1..at + 1 + count * width).or_else(|| bytes.get(at + 1..))?;
+    decode(chars, high, &mut units, &mut out);
+    flush(&mut units, &mut out);
+    Some(out)
+}
+
+/// A Windows-1252 byte: Latin-1, but for the typographic characters at
+/// 0x80 to 0x9F.
+fn windows_1252(byte: u8) -> char {
+    match byte {
+        0x80..=0x9F => WIN_ANSI_HIGH[usize::from(byte - 0x80)].unwrap_or_else(|| char::from(byte)),
+        _ => char::from(byte),
+    }
+}
+
+/// Appends characters: Latin-1 bytes at once, UTF-16 units to `units`
+/// (a surrogate pair may span two pieces), decoded by [`flush`].
+fn decode(chars: &[u8], high: bool, units: &mut Vec<u16>, out: &mut String) {
+    if high {
+        units.extend(chars.as_chunks::<2>().0.iter().map(|unit| u16::from_le_bytes(*unit)));
+    } else {
+        flush(units, out);
+        out.extend(chars.iter().map(|&byte| char::from(byte)));
+    }
+}
+
+fn flush(units: &mut Vec<u16>, out: &mut String) {
+    out.extend(
+        char::decode_utf16(units.drain(..)).map(|ch| ch.unwrap_or(char::REPLACEMENT_CHARACTER)),
+    );
+}
+
+/// The shared string table (`SST`): its record's body, then each
+/// `CONTINUE` body after it.
+pub fn shared(parts: &[&[u8]], budget: &Budget<'_>) -> Result<Vec<String>> {
+    let mut reader = Cursor { parts, part: 0, at: 8 };
+    let Some(unique) = parts.first().and_then(|first| first.get(4..8)) else {
+        return Ok(Vec::new());
+    };
+    let unique = u32::from_le_bytes(unique.try_into().unwrap_or([0; 4])) as usize;
+    let mut strings = Vec::with_capacity(unique.min(1 << 20));
+    let mut units = Vec::new();
+    while strings.len() < unique {
+        budget.tick()?;
+        let Some(string) = reader.string(&mut units) else { break };
+        strings.push(string);
+    }
+    Ok(strings)
+}
+
+/// A cursor over record bodies read as one stream.
+struct Cursor<'p, 'a> {
+    parts: &'p [&'a [u8]],
+    part: usize,
+    at: usize,
+}
+
+impl Cursor<'_, '_> {
+    fn byte(&mut self) -> Option<u8> {
+        while self.at >= self.parts.get(self.part)?.len() {
+            self.part += 1;
+            self.at = 0;
+        }
+        let byte = self.parts[self.part][self.at];
+        self.at += 1;
+        Some(byte)
+    }
+
+    fn u16(&mut self) -> Option<u16> {
+        Some(u16::from_le_bytes([self.byte()?, self.byte()?]))
+    }
+
+    fn u32(&mut self) -> Option<u32> {
+        Some(u32::from_le_bytes([self.byte()?, self.byte()?, self.byte()?, self.byte()?]))
+    }
+
+    fn skip(&mut self, mut count: usize) -> Option<()> {
+        while count > 0 {
+            let left = self.parts.get(self.part)?.len().saturating_sub(self.at);
+            if left == 0 {
+                self.part += 1;
+                self.at = 0;
+                continue;
+            }
+            let step = left.min(count);
+            self.at += step;
+            count -= step;
+        }
+        Some(())
+    }
+
+    /// An `XLUnicodeRichExtendedString`: where its characters cross into the
+    /// next record, that record starts with their width again.
+    fn string(&mut self, units: &mut Vec<u16>) -> Option<String> {
+        let count = usize::from(self.u16()?);
+        let flags = self.byte()?;
+        let runs = if flags & 0x08 != 0 { usize::from(self.u16()?) } else { 0 };
+        let extended = if flags & 0x04 != 0 { self.u32()? as usize } else { 0 };
+        let mut high = flags & 1 != 0;
+        let mut out = String::with_capacity(count);
+        let mut left = count;
+        while left > 0 {
+            let part = self.parts.get(self.part)?;
+            if self.at >= part.len() {
+                self.part += 1;
+                self.at = 1;
+                high = self.parts.get(self.part)?.first()? & 1 != 0;
+                continue;
+            }
+            let width = if high { 2 } else { 1 };
+            let take = ((part.len() - self.at) / width).min(left);
+            if take == 0 {
+                return None;
+            }
+            decode(&part[self.at..self.at + take * width], high, units, &mut out);
+            self.at += take * width;
+            left -= take;
+        }
+        flush(units, &mut out);
+        self.skip(runs * 4 + extended)?;
+        Some(out)
+    }
+}

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

@@ -0,0 +1,342 @@
+//! Legacy Excel workbooks (`.xls`): BIFF8 (Excel 97 to 2003) and BIFF5
+//! (Excel 5.0 and 95), the `Workbook` or `Book` stream of a compound file,
+//! a sequence of records. Cell values come from the cells' records (shared
+//! or inline strings, numbers, RK numbers, booleans, errors, formula
+//! results) and show through their number formats as in XLSX. Comments,
+//! charts and macro sheets are left out.
+
+mod strings;
+#[cfg(test)]
+mod tests;
+
+use super::Budget;
+use super::content::{Grid, Sheet, Value};
+use super::numbers::{Shown, built_in, classify, push_number};
+use super::ole::Ole;
+use crate::{Error, Result};
+use strings::Encoding;
+
+const BOF: u16 = 0x0809;
+const EOF: u16 = 0x000A;
+const CONTINUE: u16 = 0x003C;
+/// BIFF8, the version of Excel 97 and later; BIFF5, of Excel 5.0 and 95.
+const BIFF8: u16 = 0x0600;
+const BIFF5: u16 = 0x0500;
+
+fn malformed(reason: &str) -> Error {
+    Error::malformed("XLS", reason)
+}
+
+/// The workbook's sheets, in order, its chart and macro sheets left out.
+///
+/// # Errors
+/// [`Error::UnsupportedDocument`] for a compound file that is no workbook,
+/// one older than Excel 5.0 or in a code page other than Western European,
+/// [`Error::PasswordRequired`] for an encrypted one, [`Error::Malformed`]
+/// for a damaged one.
+pub fn content(ole: &Ole<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
+    let stream = match ole.stream("Workbook", budget)? {
+        Some(stream) => stream,
+        None => ole.stream("Book", budget)?.ok_or_else(|| {
+            Error::UnsupportedDocument(
+                "an Office file that is not a workbook (a legacy .doc?)".to_owned(),
+            )
+        })?,
+    };
+    let book = globals(&stream, budget)?;
+    let mut scratch = String::new();
+    let mut sheets = Vec::with_capacity(book.sheets.len());
+    for listed in &book.sheets {
+        let cells = cells(&stream, listed.offset, &book, &mut scratch, budget)?;
+        sheets.push(Sheet {
+            name: listed.name.clone(),
+            hidden: listed.hidden,
+            cells,
+            comments: Vec::new(),
+        });
+    }
+    Ok(sheets)
+}
+
+/// One record: its type and its body, `CONTINUE` records left apart.
+fn records(data: &[u8], mut at: usize) -> impl Iterator<Item = (u16, &[u8])> {
+    std::iter::from_fn(move || {
+        let header = data.get(at..at + 4)?;
+        let kind = u16::from_le_bytes([header[0], header[1]]);
+        let length = usize::from(u16::from_le_bytes([header[2], header[3]]));
+        let body = data.get(at + 4..at + 4 + length)?;
+        at += 4 + length;
+        Some((kind, body))
+    })
+}
+
+fn u16_at(body: &[u8], at: usize) -> Option<u16> {
+    Some(u16::from_le_bytes(body.get(at..at + 2)?.try_into().ok()?))
+}
+
+fn u32_at(body: &[u8], at: usize) -> Option<u32> {
+    Some(u32::from_le_bytes(body.get(at..at + 4)?.try_into().ok()?))
+}
+
+/// A worksheet the workbook lists.
+struct Listed {
+    name: String,
+    hidden: bool,
+    offset: usize,
+}
+
+/// What the workbook's global records say: its sheets, its shared strings,
+/// how each cell format shows numbers, and its date system.
+struct Book {
+    sheets: Vec<Listed>,
+    strings: Vec<String>,
+    shown: Vec<Shown>,
+    date1904: bool,
+    encoding: Encoding,
+}
+
+impl Book {
+    /// How the cell format `xf` shows numbers.
+    fn shown(&self, xf: Option<u16>) -> Shown {
+        xf.and_then(|xf| self.shown.get(usize::from(xf))).copied().unwrap_or(Shown::General)
+    }
+
+    /// A string in the workbook's encoding.
+    fn string(&self, bytes: &[u8], at: usize, wide_count: bool) -> String {
+        strings::string(bytes, at, wide_count, self.encoding).unwrap_or_default()
+    }
+}
+
+fn globals(stream: &[u8], budget: &Budget<'_>) -> Result<Book> {
+    let mut all = records(stream, 0).peekable();
+    let encoding = match all.next() {
+        Some((BOF, body)) if u16_at(body, 0) == Some(BIFF8) => Encoding::Unicode,
+        Some((BOF, body)) if u16_at(body, 0) == Some(BIFF5) => Encoding::Windows1252,
+        Some((BOF, _)) => {
+            return Err(Error::UnsupportedDocument(
+                "a workbook older than Excel 5.0 (.xls); save it as .xlsx".into(),
+            ));
+        }
+        _ => return Err(malformed("the workbook stream does not start with BOF")),
+    };
+    let mut book = Book {
+        sheets: Vec::new(),
+        strings: Vec::new(),
+        shown: Vec::new(),
+        date1904: false,
+        encoding,
+    };
+    let mut formats: Vec<(u16, Shown)> = Vec::new();
+    let mut format_ids = Vec::new();
+    while let Some((kind, body)) = all.next() {
+        budget.tick()?;
+        match kind {
+            EOF => break,
+            // FILEPASS: the rest is encrypted.
+            0x002F => return Err(Error::PasswordRequired),
+            0x0022 => book.date1904 = u16_at(body, 0) == Some(1),
+            // CODEPAGE: BIFF5's strings are bytes of it; Western European
+            // (or ASCII) only, rather than misread text.
+            0x0042 if encoding == Encoding::Windows1252 => {
+                let page = u16_at(body, 0).unwrap_or(1252);
+                if !matches!(page, 1252 | 367 | 0x8001) {
+                    return Err(Error::UnsupportedDocument(format!(
+                        "an Excel 5.0/95 workbook in code page {page} (.xls); save it as .xlsx"
+                    )));
+                }
+            }
+            0x041E => {
+                if let Some(id) = u16_at(body, 0) {
+                    let code = book.string(body, 2, encoding == Encoding::Unicode);
+                    formats.push((id, classify(&code)));
+                }
+            }
+            0x00E0 => format_ids.push(u16_at(body, 2).unwrap_or(0)),
+            0x0085 => {
+                let (Some(offset), Some(&state), Some(&kind)) =
+                    (u32_at(body, 0), body.get(4), body.get(5))
+                else {
+                    continue;
+                };
+                // Worksheets only: macro sheets, charts and modules hold no table.
+                if kind == 0 {
+                    let name = book.string(body, 6, false);
+                    book.sheets.push(Listed {
+                        name,
+                        hidden: state & 3 != 0,
+                        offset: offset as usize,
+                    });
+                }
+            }
+            0x00FC => {
+                let mut parts = vec![body];
+                while let Some(&(CONTINUE, more)) = all.peek() {
+                    parts.push(more);
+                    all.next();
+                }
+                book.strings = strings::shared(&parts, budget)?;
+            }
+            _ => {}
+        }
+    }
+    book.shown = format_ids
+        .iter()
+        .map(|&id| {
+            formats
+                .iter()
+                .find(|&&(custom, _)| custom == id)
+                .map_or_else(|| built_in(u32::from(id)), |&(_, shown)| shown)
+        })
+        .collect();
+    Ok(book)
+}
+
+/// An `RK` number: a 30-bit integer or the high bits of a double, either
+/// perhaps divided by 100.
+fn rk(value: u32) -> f64 {
+    #[expect(clippy::cast_possible_wrap, reason = "the bits are a signed integer")]
+    let number = if value & 2 != 0 {
+        f64::from((value as i32) >> 2)
+    } else {
+        f64::from_bits(u64::from(value & 0xFFFF_FFFC) << 32)
+    };
+    if value & 1 != 0 { number / 100.0 } else { number }
+}
+
+/// An error code as Excel shows it.
+const fn error_text(code: u8) -> &'static str {
+    match code {
+        0x00 => "#NULL!",
+        0x07 => "#DIV/0!",
+        0x0F => "#VALUE!",
+        0x17 => "#REF!",
+        0x1D => "#NAME?",
+        0x24 => "#NUM!",
+        _ => "#N/A",
+    }
+}
+
+/// A worksheet's cells, from its BOF at `offset` to its EOF.
+fn cells(
+    stream: &[u8],
+    offset: usize,
+    book: &Book,
+    scratch: &mut String,
+    budget: &Budget<'_>,
+) -> Result<Grid> {
+    let mut grid = Grid::default();
+    let mut all = records(stream, offset);
+    if !matches!(all.next(), Some((BOF, _))) {
+        return Err(malformed("a sheet that does not start with BOF"));
+    }
+    // A formula's string result follows it in a STRING record.
+    let mut pending: Option<(u32, u32)> = None;
+    for (kind, body) in all {
+        budget.tick()?;
+        let (Some(row), Some(column)) = (u16_at(body, 0), u16_at(body, 2)) else {
+            if kind == EOF {
+                break;
+            }
+            continue;
+        };
+        let (row, column) = (u32::from(row), u32::from(column));
+        // NUMBER, RK and numeric FORMULA results, written after the match.
+        let number = match kind {
+            EOF => break,
+            // LABELSST
+            0x00FD => {
+                let text = u32_at(body, 6).and_then(|index| book.strings.get(index as usize));
+                text_cell(&mut grid, (row, column), text.map_or("", String::as_str));
+                None
+            }
+            // LABEL, RSTRING
+            0x0204 | 0x00D6 => {
+                text_cell(&mut grid, (row, column), &book.string(body, 6, true));
+                None
+            }
+            0x0203 => {
+                body.get(6..14).map(|bits| f64::from_le_bytes(bits.try_into().unwrap_or([0; 8])))
+            }
+            0x027E => u32_at(body, 6).map(rk),
+            // MULRK: (format, RK) pairs from the first column on.
+            0x00BD => {
+                let pairs = body.get(4..body.len().saturating_sub(2)).unwrap_or_default();
+                for (index, pair) in (0..).zip(pairs.as_chunks::<6>().0) {
+                    let value = rk(u32::from_le_bytes([pair[2], pair[3], pair[4], pair[5]]));
+                    let shown = book.shown(Some(u16::from_le_bytes([pair[0], pair[1]])));
+                    number_cell(
+                        &mut grid,
+                        (row, column + index),
+                        value,
+                        shown,
+                        book.date1904,
+                        scratch,
+                    );
+                }
+                None
+            }
+            // BOOLERR
+            0x0205 => {
+                let (Some(&value), Some(&error)) = (body.get(6), body.get(7)) else { continue };
+                flag_cell(&mut grid, (row, column), value, error != 0);
+                None
+            }
+            // FORMULA: its cached result.
+            0x0006 => {
+                let Some(result) = body.get(6..14) else { continue };
+                if result[6..8] == [0xFF, 0xFF] {
+                    match result[0] {
+                        0 => pending = Some((row, column)),
+                        1 => flag_cell(&mut grid, (row, column), result[2], false),
+                        2 => flag_cell(&mut grid, (row, column), result[2], true),
+                        _ => {}
+                    }
+                    None
+                } else {
+                    Some(f64::from_le_bytes(result.try_into().unwrap_or([0; 8])))
+                }
+            }
+            // STRING: the string result of the formula before it.
+            0x0207 => {
+                if let Some(at) = pending.take() {
+                    text_cell(&mut grid, at, &book.string(body, 0, true));
+                }
+                None
+            }
+            _ => None,
+        };
+        if let Some(number) = number {
+            let shown = book.shown(u16_at(body, 4));
+            number_cell(&mut grid, (row, column), number, shown, book.date1904, scratch);
+        }
+    }
+    Ok(grid.finish())
+}
+
+fn number_cell(
+    grid: &mut Grid,
+    (row, column): (u32, u32),
+    number: f64,
+    shown: Shown,
+    date1904: bool,
+    scratch: &mut String,
+) {
+    let value = push_number(grid.buffer(), number, shown, date1904, scratch);
+    grid.end_cell(row, column, value);
+}
+
+fn text_cell(grid: &mut Grid, (row, column): (u32, u32), text: &str) {
+    grid.buffer().push_str(text);
+    grid.end_cell(row, column, Value::Text);
+}
+
+/// A boolean, or an error code.
+fn flag_cell(grid: &mut Grid, (row, column): (u32, u32), value: u8, error: bool) {
+    let (text, value) = match (error, value) {
+        (true, code) => (error_text(code), Value::Error),
+        (false, 0) => ("FALSE", Value::Bool(false)),
+        (false, _) => ("TRUE", Value::Bool(true)),
+    };
+    grid.buffer().push_str(text);
+    grid.end_cell(row, column, value);
+}

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

@@ -3,7 +3,6 @@
 //! digits), formulas without a cached result as `=FORMULA`, then the sheet's
 //! comments.
 
-mod numbers;
 #[cfg(test)]
 mod tests;
 
@@ -11,12 +10,12 @@ use std::sync::Arc;
 
 use super::Budget;
 use super::content::{Grid, Note, Sheet, Value};
+use super::numbers::{Shown, push_number, styles};
 use super::package::Package;
 use crate::Result;
 use crate::xlsx::parse_cell_reference;
 use crate::xlsx::text::unescape as unescape_xstring;
 use crate::xml::reader::{Event, XmlReader};
-use numbers::{Shown, push_number, styles};
 
 /// A cell's `t` attribute.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

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

@@ -21,11 +21,15 @@ pub(crate) mod inflate;
 #[cfg(feature = "json")]
 pub mod json;
 mod markdown;
+mod numbers;
+mod ods;
+mod ole;
 mod package;
 mod pdf;
 mod span;
 #[cfg(test)]
 mod tests;
+mod xls;
 mod xlsx;
 
 pub(crate) use budget::Budget;
@@ -46,41 +50,62 @@ pub enum Format {
     Pdf,
     Xlsx,
     Docx,
+    Ods,
+    Xls,
 }
 
 impl Format {
-    /// `pdf`, `xlsx` or `docx`.
+    /// `pdf`, `xlsx`, `docx`, `ods` or `xls`.
     #[must_use]
     pub const fn as_str(self) -> &'static str {
         match self {
             Self::Pdf => "pdf",
             Self::Xlsx => "xlsx",
             Self::Docx => "docx",
+            Self::Ods => "ods",
+            Self::Xls => "xls",
         }
     }
 }
 
-/// Reads a document, its format told by its content: `%PDF-` in the first
-/// kilobyte, or a zip whose main part is a workbook or a Word document
-/// (macro-enabled ones and templates included).
+/// Reads a document, its format told by its content.
+///
+/// That is `%PDF-` in the first kilobyte; a compound file holding a legacy
+/// Excel workbook (`.xls`); a
+/// zip that is an ODF spreadsheet (`.ods`), or whose main part is
+/// a workbook or a Word document (macro-enabled ones and templates
+/// included).
 ///
 /// # Errors
-/// [`Error::UnsupportedDocument`] for other formats (legacy `.xls` and
-/// `.doc`, binary `.xlsb`, presentations), [`Error::NoTextLayer`] for a PDF
-/// of scanned pages, [`Error::PasswordRequired`] for a PDF that needs one,
-/// [`Error::LimitExceeded`] and [`Error::Cancelled`] when the [`Limits`]
-/// stop the read, and [`Error::Malformed`] for a corrupt document.
+/// [`Error::UnsupportedDocument`] for other formats (legacy `.doc`, binary
+/// `.xlsb`, presentations, ODF text), [`Error::NoTextLayer`] for a
+/// PDF of scanned pages, [`Error::PasswordRequired`] for a document that
+/// needs one, [`Error::LimitExceeded`] and [`Error::Cancelled`] when the
+/// [`Limits`] stop the read, and [`Error::Malformed`] for a corrupt document.
 pub fn content(document: &[u8], limits: &Limits) -> Result<Content> {
     let budget = Budget::new(limits, document.len())?;
     if pdf::is_pdf(document) {
         return pdf::content(document, &budget).map(Content::Pdf);
     }
+    if document.starts_with(&ole::SIGNATURE) {
+        let ole = ole::Ole::open(document, &budget)?;
+        return xls::content(&ole, &budget).map(Content::Xls);
+    }
     let zip = zip(document)?;
+    match ods::spreadsheet(&zip, &budget)? {
+        Some(true) => return ods::content(&zip, &budget).map(Content::Ods),
+        Some(false) => {
+            return Err(Error::UnsupportedDocument(
+                "an OpenDocument file that is not a spreadsheet".to_owned(),
+            ));
+        }
+        None => {}
+    }
     let package = Package::open(&zip, &budget)?;
     match package.format()? {
         Format::Xlsx => xlsx::content(&package, &budget).map(Content::Xlsx),
         Format::Docx => docx::content(&package, &budget).map(Content::Docx),
-        Format::Pdf => Err(Error::UnsupportedDocument("a PDF inside a zip".to_owned())),
+        other => Err(Error::UnsupportedDocument(format!("a {} inside a zip", other.as_str()))),
     }
 }
 
@@ -96,12 +121,13 @@ pub fn markdown(document: &[u8], limits: &Limits) -> Result<String> {
 /// Calls `each` with every image in a document, as a file.
 ///
 /// A PDF's images come once each, from the first page that draws them; a
-/// Word or Excel package gives its media. A JPEG stays a JPEG; pixels a PDF
-/// stores raw become PNG. Stops at the first error `each` returns.
+/// Word, Excel or ODF package gives its media. A JPEG stays a
+/// JPEG; pixels a PDF stores raw become PNG. Stops at the first error
+/// `each` returns.
 ///
 /// # Errors
-/// As [`content`] (but a PDF without text is no error here), and what
-/// `each` returns.
+/// As [`content`] (but a PDF without text is no error here, and a legacy
+/// `.xls` is one), and what `each` returns.
 pub fn images(
     document: &[u8],
     limits: &Limits,
@@ -111,19 +137,35 @@ pub fn images(
     if pdf::is_pdf(document) {
         return pdf::images(document, &budget, &mut each);
     }
+    if document.starts_with(&ole::SIGNATURE) {
+        return Err(Error::UnsupportedDocument("the images of a legacy Office file".to_owned()));
+    }
     let zip = zip(document)?;
+    if ods::spreadsheet(&zip, &budget)?.is_some() {
+        return media(&zip, "Pictures/", &[], &budget, &mut each);
+    }
     let package = Package::open(&zip, &budget)?;
-    let format = package.format()?;
-    let sheets = match format {
+    let sheets = match package.format()? {
         Format::Xlsx => xlsx::image_sheets(&package, &budget)?,
         _ => Vec::new(),
     };
     let folder = package.main().rsplit_once('/').map_or("", |(folder, _)| folder);
-    let media = format!("{folder}/media/");
-    let names: Vec<&str> = package.parts().filter(|name| name.starts_with(&media)).collect();
+    media(&zip, &format!("{folder}/media/"), &sheets, &budget, &mut each)
+}
+
+/// The package's parts under `folder`, as images; `sheets` says which
+/// sheet shows each, by part.
+fn media(
+    zip: &ZipReader<'_>,
+    folder: &str,
+    sheets: &[(String, String)],
+    budget: &Budget<'_>,
+    each: &mut impl FnMut(Image) -> Result<()>,
+) -> Result<()> {
+    let names: Vec<&str> = zip.names().filter(|name| name.starts_with(folder)).collect();
     for name in names {
         budget.check()?;
-        let Some(data) = package.part(name)? else { continue };
+        let Some(data) = zip.read(name, budget)? else { continue };
         let format = ImageFormat::sniff(&data, name);
         let (width, height) = format.dimensions(&data).unzip();
         let sheet = sheets
@@ -139,7 +181,9 @@ pub fn images(
 /// A document that is not a PDF, as the zip an Office document is.
 fn zip(document: &[u8]) -> Result<ZipReader<'_>> {
     if !document.starts_with(b"PK") {
-        return Err(Error::UnsupportedDocument("not a PDF, XLSX or DOCX file".to_owned()));
+        return Err(Error::UnsupportedDocument(
+            "not a PDF, XLSX, XLS, ODS or DOCX file".to_owned(),
+        ));
     }
     ZipReader::new(document)
 }