imprimatur 0.1.0 → 0.2.0

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

@@ -0,0 +1,357 @@
+//! `.ods` spreadsheets: a zip whose `mimetype` entry names the format and
+//! whose `content.xml` holds the tables. Cells carry their
+//! value (`office:value-type` and its attributes) and the text they show;
+//! repeated rows and columns are expanded only where they hold something.
+
+#[cfg(test)]
+mod tests;
+
+use std::fmt::Write as _;
+use std::ops::Range;
+
+use super::Budget;
+use super::content::{Grid, Note, Sheet, Value};
+use super::numbers::push_general;
+use crate::xlsx::DateTime;
+use crate::xml::reader::{Event, Tag, XmlReader};
+use crate::zip::reader::ZipReader;
+use crate::{Error, Result};
+
+const SPREADSHEET: &str = "application/vnd.oasis.opendocument.spreadsheet";
+/// Excel's grid, which repeated rows and columns are cut to.
+const MAX_ROWS: u32 = 1_048_576;
+const MAX_COLUMNS: u32 = 16_384;
+
+/// Whether a zip is an ODF file, by its `mimetype` entry: `None` when it is
+/// not one, `Some(true)` for a spreadsheet (or its template).
+///
+/// # Errors
+/// As reading the entry.
+pub fn spreadsheet(zip: &ZipReader<'_>, budget: &Budget<'_>) -> Result<Option<bool>> {
+    let Some(kind) = zip.read("mimetype", budget)? else { return Ok(None) };
+    let kind = String::from_utf8_lossy(&kind);
+    let kind = kind.trim();
+    if !kind.starts_with("application/vnd.oasis.opendocument.") {
+        return Ok(None);
+    }
+    Ok(Some(kind.strip_suffix("-template").unwrap_or(kind) == SPREADSHEET))
+}
+
+/// The spreadsheet's tables, in order, with their comments.
+///
+/// # Errors
+/// [`Error::Malformed`] for a missing or broken `content.xml`, and the
+/// limits' errors.
+pub fn content(zip: &ZipReader<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
+    let content = zip
+        .read("content.xml", budget)?
+        .ok_or_else(|| Error::malformed("ODS", "no content.xml"))?;
+    let text = String::from_utf8(content)
+        .map_err(|_| Error::malformed("ODS", "content.xml is not UTF-8"))?;
+    let mut reader = Reader::default();
+    let mut xml = XmlReader::new(&text, budget.max_depth());
+    while let Some(event) = xml.next()? {
+        budget.tick()?;
+        reader.event(event, budget)?;
+    }
+    Ok(reader.sheets)
+}
+
+/// A cell being read: its value attributes, its repeat, and where its text
+/// starts in the row's buffer.
+#[derive(Default)]
+struct Cell {
+    kind: String,
+    value: String,
+    formula: String,
+    repeat: u32,
+    paragraphs: usize,
+    start: usize,
+}
+
+#[derive(Default)]
+struct Reader {
+    sheets: Vec<Sheet>,
+    hidden_styles: Vec<String>,
+    style: Option<String>,
+    grid: Grid,
+    comments: Vec<Note>,
+    row: u32,
+    column: u32,
+    row_repeat: u32,
+    /// The row's cells, their text in one buffer: column, text, value.
+    row_text: String,
+    row_cells: Vec<(u32, Range<usize>, Value)>,
+    cell: Option<Cell>,
+    note: Option<(String, String)>,
+    in_creator: bool,
+    /// Text counts inside paragraphs only, outside drawings and dates of
+    /// annotations.
+    paragraphs: usize,
+    skipping: usize,
+    scratch: String,
+}
+
+impl Reader {
+    fn event(&mut self, event: Event<'_>, budget: &Budget<'_>) -> Result<()> {
+        match event {
+            Event::Start(tag) => self.start(&tag),
+            Event::End(name) => self.end(name, budget)?,
+            Event::Text(text) => self.text(&text),
+        }
+        Ok(())
+    }
+
+    fn start(&mut self, tag: &Tag<'_>) {
+        let repeat = |name| tag.attr(name).and_then(|n| n.parse::<u32>().ok()).unwrap_or(1).max(1);
+        match tag.name() {
+            "style" if tag.attr("family").as_deref() == Some("table") => {
+                self.style = tag.attr("name").map(std::borrow::Cow::into_owned);
+            }
+            "table-properties" if tag.attr("display").as_deref() == Some("false") => {
+                if let Some(style) = self.style.take() {
+                    self.hidden_styles.push(style);
+                }
+            }
+            "table" => {
+                let hidden = tag
+                    .attr("style-name")
+                    .is_some_and(|style| self.hidden_styles.iter().any(|h| *h == style));
+                self.sheets.push(Sheet {
+                    name: tag.attr("name").map(std::borrow::Cow::into_owned).unwrap_or_default(),
+                    hidden,
+                    cells: Grid::default(),
+                    comments: Vec::new(),
+                });
+                self.row = 0;
+            }
+            "table-row" => {
+                self.column = 0;
+                self.row_repeat = repeat("number-rows-repeated");
+            }
+            "table-cell" | "covered-table-cell" => {
+                let attr =
+                    |name| tag.attr(name).map(std::borrow::Cow::into_owned).unwrap_or_default();
+                let kind = attr("value-type");
+                let value = match kind.as_str() {
+                    "date" => attr("date-value"),
+                    "time" => attr("time-value"),
+                    "boolean" => attr("boolean-value"),
+                    _ => attr("value"),
+                };
+                let repeat = repeat("number-columns-repeated");
+                let start = self.row_text.len();
+                self.cell = Some(Cell {
+                    kind,
+                    value,
+                    formula: attr("formula"),
+                    repeat,
+                    paragraphs: 0,
+                    start,
+                });
+            }
+            "annotation" => self.note = Some((String::new(), String::new())),
+            "creator" if self.note.is_some() => self.in_creator = true,
+            "date" if self.note.is_some() => self.skipping += 1,
+            "frame" | "custom-shape" | "g" => self.skipping += 1,
+            "p" | "h" => {
+                // A second paragraph starts on a line of its own.
+                let separate = match (&mut self.note, &mut self.cell) {
+                    (Some((_, text)), _) => !text.is_empty(),
+                    (None, Some(cell)) => {
+                        cell.paragraphs += 1;
+                        cell.paragraphs > 1
+                    }
+                    (None, None) => false,
+                };
+                self.paragraphs += 1;
+                if separate {
+                    self.text("\n");
+                }
+            }
+            "s" => {
+                let count = tag
+                    .attr("c")
+                    .and_then(|count| count.parse::<usize>().ok())
+                    .unwrap_or(1)
+                    .min(1024);
+                self.text(&" ".repeat(count));
+            }
+            "tab" => self.text("\t"),
+            "line-break" => self.text("\n"),
+            _ => {}
+        }
+    }
+
+    fn text(&mut self, text: &str) {
+        if self.skipping > 0 {
+            return;
+        }
+        match &mut self.note {
+            Some((author, _)) if self.in_creator => author.push_str(text),
+            Some((_, note)) if self.paragraphs > 0 => note.push_str(text),
+            None if self.cell.is_some() && self.paragraphs > 0 => self.row_text.push_str(text),
+            _ => {}
+        }
+    }
+
+    fn end(&mut self, name: &str, budget: &Budget<'_>) -> Result<()> {
+        match name {
+            "style" => self.style = None,
+            "creator" => self.in_creator = false,
+            "date" if self.note.is_some() => self.skipping = self.skipping.saturating_sub(1),
+            "frame" | "custom-shape" | "g" => self.skipping = self.skipping.saturating_sub(1),
+            "p" | "h" => self.paragraphs = self.paragraphs.saturating_sub(1),
+            "annotation" => {
+                if let Some((author, text)) = self.note.take() {
+                    let author = (!author.trim().is_empty()).then(|| author.trim().into());
+                    self.comments.push(Note { row: self.row, column: self.column, author, text });
+                }
+            }
+            "table-cell" | "covered-table-cell" => self.end_cell(),
+            "table-row" => self.end_row(budget)?,
+            "table" => {
+                let grid = std::mem::take(&mut self.grid).finish();
+                if let Some(sheet) = self.sheets.last_mut() {
+                    sheet.cells = grid;
+                    sheet.comments = std::mem::take(&mut self.comments);
+                }
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    /// The cell's text, typed by its value; repeated across its columns.
+    fn end_cell(&mut self) {
+        let Some(cell) = self.cell.take() else { return };
+        let start = cell.start;
+        let shown = self.row_text.split_off(start);
+        let value = self.typed(&cell, &shown);
+        let end = self.row_text.len();
+        if end > start {
+            let repeat = cell.repeat.min(MAX_COLUMNS.saturating_sub(self.column));
+            for offset in 0..repeat {
+                self.row_cells.push((self.column + offset, start..end, value));
+            }
+        }
+        self.column = self.column.saturating_add(cell.repeat);
+    }
+
+    /// Writes the cell's text as shown into the row buffer, returning its
+    /// value: numbers keep the text they show, dates and times read as in
+    /// XLSX, a formula without a result shows itself.
+    fn typed(&mut self, cell: &Cell, shown: &str) -> Value {
+        let out = &mut self.row_text;
+        match cell.kind.as_str() {
+            "float" | "percentage" | "currency" if let Ok(number) = cell.value.parse::<f64>() => {
+                if shown.trim().is_empty() {
+                    push_general(out, number, &mut self.scratch);
+                } else {
+                    out.push_str(shown);
+                }
+                Value::Number(number)
+            }
+            "date" if let Some(date) = date(&cell.value) => {
+                // Writing to a String cannot fail.
+                let _ = write!(out, "{date}");
+                Value::Date(date)
+            }
+            "time" if let Some(seconds) = duration(&cell.value) => {
+                let clock = seconds.rem_euclid(86_400);
+                // Writing to a String cannot fail.
+                let _ = write!(out, "{:02}:{:02}:{:02}", clock / 3600, clock / 60 % 60, clock % 60);
+                #[expect(clippy::cast_precision_loss, reason = "seconds of a day")]
+                Value::Number(seconds as f64 / 86_400.0)
+            }
+            "boolean" => {
+                let on = cell.value == "true" || cell.value == "1";
+                out.push_str(if on { "TRUE" } else { "FALSE" });
+                Value::Bool(on)
+            }
+            "" if !cell.formula.is_empty() && shown.trim().is_empty() => {
+                let formula =
+                    cell.formula.split_once(':').map_or(cell.formula.as_str(), |(_, rest)| rest);
+                out.push('=');
+                out.push_str(formula.strip_prefix('=').unwrap_or(formula));
+                Value::Formula
+            }
+            _ => {
+                out.push_str(shown);
+                Value::Text
+            }
+        }
+    }
+
+    /// Writes the row's cells, once per repeat, and moves past it.
+    fn end_row(&mut self, budget: &Budget<'_>) -> Result<()> {
+        let repeat = if self.row_cells.is_empty() {
+            0
+        } else {
+            self.row_repeat.min(MAX_ROWS.saturating_sub(self.row))
+        };
+        for offset in 0..repeat {
+            budget.tick()?;
+            budget.inflate(self.row_text.len())?;
+            for (column, text, value) in &self.row_cells {
+                if text.end > text.start {
+                    self.grid.buffer().push_str(&self.row_text[text.clone()]);
+                    self.grid.end_cell(self.row + offset, *column, *value);
+                }
+            }
+        }
+        self.row_cells.clear();
+        self.row_text.clear();
+        self.row = self.row.saturating_add(self.row_repeat);
+        Ok(())
+    }
+}
+
+/// `2023-03-15` or `2023-03-15T09:30:00.5`.
+fn date(value: &str) -> Option<DateTime> {
+    let (day, time) = value.split_once('T').unwrap_or((value, ""));
+    let mut parts = day.splitn(3, '-').map(str::parse::<u16>);
+    let (year, month, day) = (parts.next()?.ok()?, parts.next()?.ok()?, parts.next()?.ok()?);
+    let date = DateTime::date(year, u8::try_from(month).ok()?, u8::try_from(day).ok()?).ok()?;
+    if time.is_empty() {
+        return Some(date);
+    }
+    let mut parts = time.splitn(3, ':');
+    let (hour, minute, second) = (parts.next()?, parts.next()?, parts.next().unwrap_or("0"));
+    let seconds: f64 = second.parse().ok()?;
+    #[expect(
+        clippy::cast_possible_truncation,
+        clippy::cast_sign_loss,
+        reason = "under 60, checked by `at`"
+    )]
+    let (whole, nanosecond) = (seconds.trunc() as u8, (seconds.fract() * 1e9).round() as u32);
+    date.at(hour.parse().ok()?, minute.parse().ok()?, whole, nanosecond).ok()
+}
+
+/// An ISO 8601 duration such as `PT12H30M00S` (or with days), in seconds.
+fn duration(value: &str) -> Option<i64> {
+    let (negative, value) = value.strip_prefix('-').map_or((false, value), |rest| (true, rest));
+    let value = value.strip_prefix('P')?;
+    let (mut seconds, mut number, mut in_time) = (0_f64, String::new(), false);
+    for ch in value.chars() {
+        match ch {
+            'T' => in_time = true,
+            '0'..='9' | '.' => number.push(ch),
+            unit => {
+                let amount: f64 = number.parse().ok()?;
+                number.clear();
+                let scale = match (unit, in_time) {
+                    ('D', false) => 86_400.0,
+                    ('H', true) => 3_600.0,
+                    ('M', true) => 60.0,
+                    ('S', true) => 1.0,
+                    _ => return None,
+                };
+                seconds = amount.mul_add(scale, seconds);
+            }
+        }
+    }
+    #[expect(clippy::cast_possible_truncation, reason = "rounded seconds")]
+    let seconds = seconds.round() as i64;
+    Some(if negative { -seconds } else { seconds })
+}

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

@@ -0,0 +1,244 @@
+//! Compound files (MS-CFB): the container legacy Office documents are, a
+//! small FAT file system inside one file. Reading a stream of the root
+//! storage by name is all the readers need.
+
+#[cfg(test)]
+mod tests;
+
+use crate::read::Budget;
+use crate::{Error, Result};
+
+/// The first eight bytes of every compound file.
+pub const SIGNATURE: [u8; 8] = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+/// Sector numbers above this are markers: end of chain, free, FAT, DIFAT.
+const MAX_SECTOR: u32 = 0xFFFF_FFFA;
+/// No sibling or child in the directory tree.
+const NO_STREAM: u32 = 0xFFFF_FFFF;
+const MINI_SECTOR: usize = 64;
+const ENTRY: usize = 128;
+
+/// A compound file's allocation tables and the root storage's entries.
+pub struct Ole<'a> {
+    data: &'a [u8],
+    sector: usize,
+    fat: Vec<u32>,
+    mini_fat: Vec<u32>,
+    mini_stream: Vec<u8>,
+    mini_cutoff: u64,
+    /// The root storage's children: name, whether a stream, start, size.
+    entries: Vec<(String, bool, u32, u64)>,
+}
+
+fn malformed(reason: &str) -> Error {
+    Error::malformed("compound file", reason)
+}
+
+/// An allocation table's sector numbers.
+fn words(bytes: &[u8]) -> impl Iterator<Item = u32> + '_ {
+    bytes.as_chunks::<4>().0.iter().map(|word| u32::from_le_bytes(*word))
+}
+
+fn u16_at(bytes: &[u8], at: usize) -> Option<u16> {
+    Some(u16::from_le_bytes(bytes.get(at..at.checked_add(2)?)?.try_into().ok()?))
+}
+
+fn u32_at(bytes: &[u8], at: usize) -> Option<u32> {
+    Some(u32::from_le_bytes(bytes.get(at..at.checked_add(4)?)?.try_into().ok()?))
+}
+
+impl<'a> Ole<'a> {
+    /// Reads the header, the allocation tables and the directory.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a file that is not a compound file or whose
+    /// tables point outside it or in circles.
+    pub fn open(data: &'a [u8], budget: &Budget<'_>) -> Result<Self> {
+        if !data.starts_with(&SIGNATURE) || data.len() < 512 {
+            return Err(malformed("no compound file header"));
+        }
+        let header = |at| u32_at(data, at).ok_or_else(|| malformed("a short header"));
+        let sector = match u16_at(data, 0x1E) {
+            Some(9) => 512,
+            Some(12) => 4096,
+            _ => return Err(malformed("an unknown sector size")),
+        };
+        let mut ole = Self {
+            data,
+            sector,
+            fat: Vec::new(),
+            mini_fat: Vec::new(),
+            mini_stream: Vec::new(),
+            mini_cutoff: u64::from(header(0x38)?),
+            entries: Vec::new(),
+        };
+        // The FAT's own sectors: 109 listed in the header, the rest in a
+        // chain of DIFAT sectors, each ending with the next one's number.
+        let mut fat_sectors: Vec<u32> = (0..109)
+            .filter_map(|index| u32_at(data, 0x4C + index * 4))
+            .filter(|&s| s <= MAX_SECTOR)
+            .collect();
+        let mut next = header(0x44)?;
+        let per_sector = sector / 4;
+        for _ in 0..=data.len() / sector {
+            if next > MAX_SECTOR {
+                break;
+            }
+            let bytes = ole.sector_bytes(next)?;
+            fat_sectors.extend(
+                (0..per_sector - 1)
+                    .filter_map(|index| u32_at(bytes, index * 4))
+                    .filter(|&s| s <= MAX_SECTOR),
+            );
+            next = u32_at(bytes, (per_sector - 1) * 4).unwrap_or(NO_STREAM);
+        }
+        budget.inflate(fat_sectors.len().saturating_mul(sector))?;
+        for number in fat_sectors {
+            budget.tick()?;
+            let bytes = ole.sector_bytes(number)?;
+            ole.fat.extend(words(bytes));
+        }
+        let directory = ole.chain(header(0x30)?, None, budget)?;
+        let first_mini_fat = header(0x3C)?;
+        if first_mini_fat <= MAX_SECTOR {
+            let table = ole.chain(first_mini_fat, None, budget)?;
+            ole.mini_fat = words(&table).collect();
+        }
+        let root = directory.get(..ENTRY).ok_or_else(|| malformed("no root entry"))?;
+        if root[0x42] != 5 {
+            return Err(malformed("the first entry is not the root"));
+        }
+        // The whole chain: some writers give the root the size of the one
+        // stream in it, short of the last mini sector it fills.
+        let (start, _) = location(root, sector);
+        ole.mini_stream =
+            if start <= MAX_SECTOR { ole.chain(start, None, budget)? } else { Vec::new() };
+        ole.entries = children(&directory, sector, budget)?;
+        Ok(ole)
+    }
+
+    /// The bytes of the stream `name` in the root storage, its name
+    /// compared regardless of case; `None` when there is none.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a stream whose sectors are missing or loop.
+    pub fn stream(&self, name: &str, budget: &Budget<'_>) -> Result<Option<Vec<u8>>> {
+        let Some(&(_, _, start, size)) = self
+            .entries
+            .iter()
+            .find(|(entry, stream, ..)| *stream && entry.eq_ignore_ascii_case(name))
+        else {
+            return Ok(None);
+        };
+        if size < self.mini_cutoff {
+            return self.mini_chain(start, size, budget).map(Some);
+        }
+        self.chain(start, Some(size), budget).map(Some)
+    }
+
+    fn sector_bytes(&self, number: u32) -> Result<&'a [u8]> {
+        let start = (number as usize + 1)
+            .checked_mul(self.sector)
+            .ok_or_else(|| malformed("a sector out of range"))?;
+        self.data
+            .get(start..start + self.sector)
+            .ok_or_else(|| malformed("a sector past the end of the file"))
+    }
+
+    /// The sectors chained from `start`, cut to `size` when given.
+    fn chain(&self, start: u32, size: Option<u64>, budget: &Budget<'_>) -> Result<Vec<u8>> {
+        let limit = size.map_or(usize::MAX, |size| usize::try_from(size).unwrap_or(usize::MAX));
+        if limit != usize::MAX && limit > self.data.len() {
+            return Err(malformed("a stream larger than the file"));
+        }
+        let mut out = Vec::with_capacity(limit.min(self.data.len()));
+        let mut seen = vec![false; self.fat.len()];
+        let mut next = start;
+        while next <= MAX_SECTOR && out.len() < limit {
+            budget.tick()?;
+            let visited =
+                seen.get_mut(next as usize).ok_or_else(|| malformed("a sector beyond the FAT"))?;
+            if std::mem::replace(visited, true) {
+                return Err(malformed("a sector chain that loops"));
+            }
+            out.extend_from_slice(self.sector_bytes(next)?);
+            next = self.fat[next as usize];
+        }
+        out.truncate(limit);
+        budget.inflate(out.len())?;
+        Ok(out)
+    }
+
+    /// A small stream, kept in the root's mini stream in 64-byte sectors.
+    fn mini_chain(&self, start: u32, size: u64, budget: &Budget<'_>) -> Result<Vec<u8>> {
+        let limit = usize::try_from(size).unwrap_or(usize::MAX);
+        let mut out = Vec::with_capacity(limit.min(self.mini_stream.len()));
+        let mut seen = vec![false; self.mini_fat.len()];
+        let mut next = start;
+        while next <= MAX_SECTOR && out.len() < limit {
+            budget.tick()?;
+            let visited = seen
+                .get_mut(next as usize)
+                .ok_or_else(|| malformed("a sector beyond the mini FAT"))?;
+            if std::mem::replace(visited, true) {
+                return Err(malformed("a mini sector chain that loops"));
+            }
+            let at = next as usize * MINI_SECTOR;
+            let bytes = self
+                .mini_stream
+                .get(at..at + MINI_SECTOR)
+                .ok_or_else(|| malformed("a mini sector past the mini stream"))?;
+            out.extend_from_slice(bytes);
+            next = self.mini_fat[next as usize];
+        }
+        out.truncate(limit);
+        budget.inflate(out.len())?;
+        Ok(out)
+    }
+}
+
+/// An entry's first sector and size; files of 512-byte sectors (version 3)
+/// leave the size's high half undefined.
+fn location(entry: &[u8], sector: usize) -> (u32, u64) {
+    let start = u32_at(entry, 0x74).unwrap_or(NO_STREAM);
+    let low = u64::from(u32_at(entry, 0x78).unwrap_or(0));
+    let high = if sector == 512 { 0 } else { u64::from(u32_at(entry, 0x7C).unwrap_or(0)) };
+    (start, high << 32 | low)
+}
+
+/// The root storage's children, from the red-black tree under its child
+/// pointer: name, whether a stream, first sector, size.
+fn children(
+    directory: &[u8],
+    sector: usize,
+    budget: &Budget<'_>,
+) -> Result<Vec<(String, bool, u32, u64)>> {
+    let entry = |index: u32| directory.get(index as usize * ENTRY..(index as usize + 1) * ENTRY);
+    let mut found = Vec::new();
+    let mut pending = vec![u32_at(directory, 0x4C).unwrap_or(NO_STREAM)];
+    let mut visits = 0_usize;
+    while let Some(index) = pending.pop() {
+        if index == NO_STREAM {
+            continue;
+        }
+        visits += 1;
+        if visits > directory.len() / ENTRY {
+            return Err(malformed("a directory tree that loops"));
+        }
+        budget.tick()?;
+        let Some(bytes) = entry(index) else {
+            return Err(malformed("a directory entry past the end"));
+        };
+        let length = usize::from(u16_at(bytes, 0x40).unwrap_or(0)).min(64).saturating_sub(2);
+        let units: Vec<u16> = bytes[..length]
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .map(|unit| u16::from_le_bytes(*unit))
+            .collect();
+        let (start, size) = location(bytes, sector);
+        found.push((String::from_utf16_lossy(&units), bytes[0x42] == 2, start, size));
+        pending.push(u32_at(bytes, 0x44).unwrap_or(NO_STREAM));
+        pending.push(u32_at(bytes, 0x48).unwrap_or(NO_STREAM));
+    }
+    Ok(found)
+}

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

@@ -86,11 +86,6 @@ impl<'a> Package<'a> {
         self.text(&part.target)?.map_or_else(|| Ok(T::default()), |text| parse(&text))
     }
 
-    /// The parts' names.
-    pub fn parts(&self) -> impl Iterator<Item = &'a str> + '_ {
-        self.zip.names()
-    }
-
     /// A part's bytes, `None` when the package has no such part.
     pub fn part(&self, name: &str) -> Result<Option<Vec<u8>>> {
         self.zip.read(name, self.budget)