imprimatur 0.1.0 → 0.3.0

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

@@ -3,20 +3,21 @@
 //! digits), formulas without a cached result as `=FORMULA`, then the sheet's
 //! comments.
 
-mod numbers;
+mod formats;
 #[cfg(test)]
 mod tests;
 
 use std::sync::Arc;
 
+use self::formats::{Formats, formats};
 use super::Budget;
-use super::content::{Grid, Note, Sheet, Value};
+use super::content::{Columns, Grid, Note, Sheet, Styled, Validation, Value};
+use super::numbers::{Shown, push_number};
 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};
+use crate::xml::reader::{Event, Tag, XmlReader};
 
 /// A cell's `t` attribute.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -52,13 +53,24 @@ impl Strings {
     }
 }
 
-/// Where a cell's text events go.
+/// Where a cell's text events go, or a validation's formulas'.
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Into {
     Nowhere,
     Value,
     Formula,
     Inline,
+    First,
+    Second,
+}
+
+/// What a sheet holds besides its cells' values.
+#[derive(Default)]
+struct Parts {
+    columns: Vec<Columns>,
+    validations: Vec<Validation>,
+    /// Cells with a format of their own: row, column, format.
+    styled: Vec<(u32, u32, usize)>,
 }
 
 pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
@@ -68,21 +80,31 @@ pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>>
     let (listed, date1904) = workbook(&text, &relationships, budget)?;
     let strings = package
         .parse_related(&relationships, "sharedStrings", |text| shared_strings(text, budget))?;
-    let shown = package.parse_related(&relationships, "styles", |text| styles(text, budget))?;
-    let book = Book { strings: &strings, shown: &shown, date1904 };
+    let formats = package.parse_related(&relationships, "styles", |text| formats(text, budget))?;
+    let book = Book { strings: &strings, shown: &formats.shown, date1904 };
     let mut sheets = Vec::with_capacity(listed.len());
     let mut scratch = String::new();
     for sheet in listed {
         budget.check()?;
         let Some(text) = package.text(&sheet.part)? else { continue };
-        let cells = cells(&text, &book, &mut scratch, budget)?;
+        let (cells, parts) = cells(&text, &book, &mut scratch, budget)?;
         let comments = match package.related(&sheet.part, "comments")? {
             Some(part) => package
                 .text(&part)?
                 .map_or_else(|| Ok(Vec::new()), |text| comments(&text, budget))?,
             None => Vec::new(),
         };
-        sheets.push(Sheet { name: sheet.name, hidden: sheet.hidden, cells, comments });
+        let styles = styled(&parts.styled, &formats);
+        let (columns, validations) = (parts.columns, parts.validations);
+        sheets.push(Sheet {
+            name: sheet.name,
+            hidden: sheet.hidden,
+            cells,
+            comments,
+            columns,
+            validations,
+            styles,
+        });
     }
     Ok(sheets)
 }
@@ -156,8 +178,13 @@ struct Head {
     style: usize,
 }
 
-fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>) -> Result<Grid> {
-    let mut grid = Grid::default();
+fn cells(
+    text: &str,
+    book: &Book<'_>,
+    scratch: &mut String,
+    budget: &Budget<'_>,
+) -> Result<(Grid, Parts)> {
+    let (mut grid, mut parts, mut rule) = (Grid::default(), Parts::default(), None);
     let mut xml = XmlReader::new(text, budget.max_depth());
     let (mut row, mut next_row, mut next_column) = (0_u32, 0_u32, 0_u32);
     let (mut value, mut formula, mut inline) = (String::new(), String::new(), String::new());
@@ -167,10 +194,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
         match event {
             Event::Start(tag) => match tag.name() {
                 "row" => {
-                    row = tag
-                        .attr("r")
-                        .and_then(|r| r.parse::<u32>().ok())
-                        .map_or(next_row, |r| r.saturating_sub(1));
+                    row = tag.parse::<u32>("r").map_or(next_row, |r| r.saturating_sub(1));
                     next_column = 0;
                 }
                 "c" => {
@@ -187,7 +211,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                         Some("d") => Kind::Iso,
                         _ => Kind::Number,
                     };
-                    let style = tag.attr("s").and_then(|s| s.parse().ok()).unwrap_or(0);
+                    let style = tag.parse("s").unwrap_or(0);
                     head = Some(Head { row: at_row, column, kind, style });
                     value.clear();
                     formula.clear();
@@ -199,17 +223,36 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                     into = Into::Inline;
                 }
                 "rPh" => xml.skip()?,
+                "col" => parts.columns.extend(columns(tag)),
+                "dataValidation" => rule = Some(validation(tag)),
+                "formula1" if rule.is_some() => (into, value) = (Into::First, String::new()),
+                "formula2" if rule.is_some() => (into, value) = (Into::Second, String::new()),
                 _ => {}
             },
             Event::Text(text) => match into {
-                Into::Value => value.push_str(&text),
+                Into::Value | Into::First | Into::Second => value.push_str(&text),
                 Into::Formula => formula.push_str(&text),
                 Into::Inline => inline.push_str(&unescape_xstring(&text)),
                 Into::Nowhere => {}
             },
             Event::End("v" | "f" | "t") => into = Into::Nowhere,
+            Event::End(end @ ("formula1" | "formula2")) => {
+                if let Some(rule) = rule.as_mut() {
+                    let formula = Some(std::mem::take(&mut value));
+                    if end == "formula1" {
+                        rule.formula1 = formula;
+                    } else {
+                        rule.formula2 = formula;
+                    }
+                }
+                into = Into::Nowhere;
+            }
+            Event::End("dataValidation") => parts.validations.extend(rule.take()),
             Event::End("c") => {
                 if let Some(head) = head.take() {
+                    if head.style != 0 {
+                        parts.styled.push((head.row, head.column, head.style));
+                    }
                     write_cell(&mut grid, &head, book, [&value, &formula, &inline], scratch);
                     next_column = head.column + 1;
                 }
@@ -218,7 +261,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
             Event::End(_) => {}
         }
     }
-    Ok(grid.finish())
+    Ok((grid.finish(), parts))
 }
 
 fn write_cell(
@@ -273,6 +316,48 @@ fn write_cell(
     grid.end_cell(head.row, head.column, kind);
 }
 
+/// A `<col>`: a run of columns, from 0.
+fn columns(tag: Tag<'_>) -> Option<Columns> {
+    let number = |name| tag.parse::<u32>(name);
+    let (first, last) = (number("min")?.checked_sub(1)?, number("max")?.checked_sub(1)?);
+    let width = tag.parse("width");
+    let hidden = tag.on("hidden");
+    Some(Columns { first, last, width, hidden })
+}
+
+/// A `<dataValidation>`, its formulas still to come.
+fn validation(tag: Tag<'_>) -> Validation {
+    let text = |name| tag.attr(name).map(std::borrow::Cow::into_owned);
+    Validation {
+        range: text("sqref").unwrap_or_default(),
+        kind: text("type").unwrap_or_else(|| "none".to_owned()),
+        operator: text("operator"),
+        allow_blank: tag.on("allowBlank"),
+        // Inverted in the file format: showDropDown="1" hides the arrow.
+        dropdown: !tag.on("showDropDown"),
+        alert: tag
+            .on("showErrorMessage")
+            .then(|| text("errorStyle").unwrap_or_else(|| "stop".to_owned())),
+        error_title: text("errorTitle"),
+        error: text("error"),
+        prompt_title: text("promptTitle"),
+        prompt: text("prompt"),
+        ..Validation::default()
+    }
+}
+
+/// The formatted cells with their look; formats the workbook lacks are
+/// left out.
+fn styled(cells: &[(u32, u32, usize)], formats: &Formats) -> Vec<Styled> {
+    cells
+        .iter()
+        .filter_map(|&(row, column, format)| {
+            let look = Arc::clone(formats.looks.get(format)?);
+            Some(Styled { row, column, look })
+        })
+        .collect()
+}
+
 /// The sheet's comments.
 fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
     let mut xml = XmlReader::new(text, budget.max_depth());
@@ -287,8 +372,7 @@ fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
                 "author" => in_author = true,
                 "comment" => {
                     position = parse_cell_reference(&tag.attr("ref").unwrap_or_default()).ok();
-                    author_id =
-                        tag.attr("authorId").and_then(|id| id.parse().ok()).unwrap_or(usize::MAX);
+                    author_id = tag.parse("authorId").unwrap_or(usize::MAX);
                     body.clear();
                 }
                 "t" => in_text = true,

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

@@ -21,19 +21,26 @@ 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;
 pub use budget::Limits;
 pub use content::{
-    Block, Bounds, Cell, Content, Grid, Mark, Note, Page, Placed, Sheet, Text, Value,
+    Block, Bounds, Cell, Columns, Content, Grid, Look, Mark, Note, Page, Placed, Sheet, Styled,
+    Text, Validation, Value,
 };
 pub use image::{Image, ImageFormat, ImageLocation};
+#[cfg(test)]
+pub(crate) use image::{PngColor, png};
 
 use crate::zip::reader::ZipReader;
 use crate::{Error, Result};
@@ -46,41 +53,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 +124,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 +140,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 +184,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)
 }

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

@@ -0,0 +1,116 @@
+//! Scripts and the direction they are written in, for reading text back
+//! in order and for writing it with the right direction.
+
+#[cfg(test)]
+mod tests;
+
+use crate::style::TextDirection;
+
+/// What a character is, for the direction of the text around it (its
+/// UAX #9 bidirectional class, simplified).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Class {
+    /// A letter of Hebrew or another right-to-left script but Arabic's, or
+    /// the right-to-left mark.
+    Right,
+    /// A letter of the Arabic script (Arabic, Persian, Urdu..., Syriac,
+    /// Thaana): right to left, and the digits after it are Arabic numbers.
+    Arabic,
+    /// Any other letter, or the left-to-right mark.
+    Left,
+    /// A number: its digits read left to right in any line, but in a
+    /// right-to-left run the spaces between two numbers read right to left.
+    Number,
+    /// Arabic-Indic digits (not the Persian ones), and digits after Arabic
+    /// letters: a number that only `,` `.` `:` `/` join, and no sign goes
+    /// with (UAX #9, W2).
+    ArabicNumber,
+    /// Spaces, punctuation and symbols: they take the direction around them.
+    Neutral,
+}
+
+impl Class {
+    pub const fn right_to_left(self) -> bool {
+        matches!(self, Self::Right | Self::Arabic)
+    }
+
+    pub const fn number(self) -> bool {
+        matches!(self, Self::Number | Self::ArabicNumber)
+    }
+
+    pub const fn strong(self) -> bool {
+        matches!(self, Self::Right | Self::Arabic | Self::Left)
+    }
+}
+
+/// The letters and digits of some text, by direction.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct Counts {
+    pub right: usize,
+    pub left: usize,
+    pub numbers: usize,
+}
+
+impl Counts {
+    pub fn add(&mut self, text: &str) {
+        for ch in text.chars() {
+            match class(ch) {
+                Class::Right | Class::Arabic => self.right += 1,
+                Class::Left if ch.is_alphabetic() => self.left += 1,
+                Class::Number | Class::ArabicNumber => self.numbers += 1,
+                Class::Left | Class::Neutral => {}
+            }
+        }
+    }
+
+    /// Whether more of the letters read right to left than left to right.
+    pub const fn right_to_left(self) -> bool {
+        self.right > self.left
+    }
+
+    /// The direction most of the letters read in; `None` without a letter.
+    pub const fn direction(self) -> Option<TextDirection> {
+        if self.right > self.left {
+            Some(TextDirection::RightToLeft)
+        } else if self.left > 0 {
+            Some(TextDirection::LeftToRight)
+        } else {
+            None
+        }
+    }
+}
+
+/// The direction of a character.
+///
+/// Right to left: Hebrew (and Yiddish, Ladino), Arabic (and Persian, Urdu,
+/// Pashto, Sindhi, Kurdish, Uyghur), Syriac, Thaana (Dhivehi), N'Ko,
+/// Samaritan, Mandaic, their presentation forms; Adlam (Fulani), Hanifi
+/// Rohingya, Mende Kikakui, Yezidi, Garay and the historic scripts
+/// (Phoenician, Aramaic, Sogdian...); and the right-to-left mark. Of
+/// those, the Arabic script (with Syriac, Thaana, Hanifi Rohingya and the
+/// Siyaq numbers) is set apart. Digits are numbers, the Persian ones
+/// (Extended Arabic-Indic) too; Arabic-Indic ones are Arabic numbers. The
+/// Arabic comma, percent sign and separators are neutral, like their Latin
+/// counterparts.
+pub fn class(ch: char) -> Class {
+    match ch {
+        '0'..='9' | '\u{06F0}'..='\u{06F9}' => Class::Number,
+        '\u{0660}'..='\u{0669}' => Class::ArabicNumber,
+        '\u{060C}' | '\u{066A}'..='\u{066C}' => Class::Neutral,
+        '\u{0600}'..='\u{07BF}'
+        | '\u{0860}'..='\u{08FF}'
+        | '\u{FB50}'..='\u{FDFF}'
+        | '\u{FE70}'..='\u{FEFC}'
+        | '\u{10D00}'..='\u{10D3F}'
+        | '\u{10EC0}'..='\u{10EFF}'
+        | '\u{1EC70}'..='\u{1EEFF}' => Class::Arabic,
+        '\u{0590}'..='\u{08FF}'
+        | '\u{200F}'
+        | '\u{FB1D}'..='\u{FB4F}'
+        | '\u{10800}'..='\u{10FFF}'
+        | '\u{1E800}'..='\u{1EFFF}' => Class::Right,
+        '\u{200E}' => Class::Left,
+        ch if ch.is_alphanumeric() => Class::Left,
+        _ => Class::Neutral,
+    }
+}

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

@@ -3,6 +3,7 @@
 #[cfg(test)]
 mod tests;
 
+use crate::script::{Class, class};
 use crate::{Error, Result};
 
 /// An opaque RGB color.
@@ -72,6 +73,26 @@ pub enum TextDirection {
 }
 
 impl TextDirection {
+    /// The direction text takes on its own, the way Word and browsers settle
+    /// a paragraph left to automatic: that of its first letter (UAX #9, P2).
+    /// `None` when it has no letter: digits, punctuation, nothing.
+    ///
+    /// ```
+    /// use imprimatur::style::TextDirection;
+    ///
+    /// assert_eq!(TextDirection::of("2024 شهادة"), Some(TextDirection::RightToLeft));
+    /// assert_eq!(TextDirection::of("ISO 9001 אישור"), Some(TextDirection::LeftToRight));
+    /// assert_eq!(TextDirection::of("1,250.50"), None);
+    /// ```
+    #[must_use]
+    pub fn of(text: &str) -> Option<Self> {
+        text.chars().find_map(|ch| match class(ch) {
+            Class::Right | Class::Arabic => Some(Self::RightToLeft),
+            Class::Left => Some(Self::LeftToRight),
+            Class::Number | Class::ArabicNumber | Class::Neutral => None,
+        })
+    }
+
     /// `readingOrder`: 1 left to right, 2 right to left (0 is context).
     pub(crate) const fn reading_order(self) -> &'static str {
         match self {

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

@@ -16,11 +16,12 @@ pub fn read_zip(bytes: Vec<u8>) -> Vec<(String, Vec<u8>)> {
         .collect()
 }
 
-/// Every entry of a zip archive as text, by name, read as [`read_zip`] does.
+/// Every entry of a zip archive as text, by name, read as [`read_zip`] does;
+/// media come out garbled, for their names.
 pub fn text_parts(bytes: Vec<u8>) -> Vec<(String, String)> {
     read_zip(bytes)
         .into_iter()
-        .map(|(name, data)| (name, String::from_utf8(data).unwrap()))
+        .map(|(name, data)| (name, String::from_utf8_lossy(&data).into_owned()))
         .collect()
 }
 
@@ -161,3 +162,90 @@ pub fn tiff_of(data: &[u8]) -> (std::collections::BTreeMap<u16, u32>, &[u8]) {
     let (offset, length) = (tags[&273] as usize, tags[&279] as usize);
     (tags, &data[offset..offset + length])
 }
+
+/// A compound file (MS-CFB, version 3) holding one stream named `name` in
+/// its root storage; a stream under 4096 bytes goes to the mini stream, as
+/// writers put it.
+pub fn ole_of(name: &str, stream: &[u8]) -> Vec<u8> {
+    const SECTOR: usize = 512;
+    const END: u32 = 0xFFFF_FFFE;
+    let small = stream.len() < 4096;
+    let pad = |data: &[u8], size: usize| {
+        let mut data = data.to_vec();
+        data.resize(data.len().div_ceil(size).max(1) * size, 0);
+        data
+    };
+    // Sectors: FAT, directory, mini FAT (when small), then the data: the
+    // stream itself, or the mini stream holding it.
+    let data = if small { pad(stream, 64) } else { stream.to_vec() };
+    let data_sectors = data.len().div_ceil(SECTOR).max(1);
+    let first_data = if small { 3 } else { 2 };
+    let mut fat = vec![0xFFFF_FFFD_u32, END];
+    if small {
+        fat.push(END);
+    }
+    fat.extend((0..data_sectors).map(|index| {
+        if index + 1 == data_sectors { END } else { u32::try_from(first_data + index + 1).unwrap() }
+    }));
+    fat.resize(SECTOR / 4, 0xFFFF_FFFF);
+    let mut header = vec![0_u8; SECTOR];
+    header[..8].copy_from_slice(&[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
+    let put = |bytes: &mut Vec<u8>, at: usize, value: u32| {
+        bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
+    };
+    header[0x18..0x1A].copy_from_slice(&0x3E_u16.to_le_bytes());
+    header[0x1A..0x1C].copy_from_slice(&3_u16.to_le_bytes());
+    header[0x1C..0x1E].copy_from_slice(&0xFFFE_u16.to_le_bytes());
+    header[0x1E..0x20].copy_from_slice(&9_u16.to_le_bytes());
+    header[0x20..0x22].copy_from_slice(&6_u16.to_le_bytes());
+    put(&mut header, 0x2C, 1);
+    put(&mut header, 0x30, 1);
+    put(&mut header, 0x38, 4096);
+    put(&mut header, 0x3C, if small { 2 } else { END });
+    put(&mut header, 0x40, u32::from(small));
+    put(&mut header, 0x44, END);
+    put(&mut header, 0x4C, 0);
+    for index in 1..109 {
+        put(&mut header, 0x4C + index * 4, 0xFFFF_FFFF);
+    }
+    let entry = |name: &str, kind: u8, child: u32, start: u32, size: usize| {
+        let mut bytes = vec![0_u8; 128];
+        let units: Vec<u16> = name.encode_utf16().collect();
+        for (index, unit) in units.iter().enumerate() {
+            bytes[index * 2..index * 2 + 2].copy_from_slice(&unit.to_le_bytes());
+        }
+        bytes[0x40..0x42]
+            .copy_from_slice(&u16::try_from(units.len() * 2 + 2).unwrap().to_le_bytes());
+        bytes[0x42] = kind;
+        for at in [0x44, 0x48, 0x4C] {
+            put(&mut bytes, at, 0xFFFF_FFFF);
+        }
+        put(&mut bytes, 0x4C, child);
+        put(&mut bytes, 0x74, start);
+        put(&mut bytes, 0x78, u32::try_from(size).unwrap());
+        bytes
+    };
+    let first = u32::try_from(first_data).unwrap();
+    let mut directory = if small {
+        let mut directory = entry("Root Entry", 5, 1, first, data.len());
+        directory.extend(entry(name, 2, 0xFFFF_FFFF, 0, stream.len()));
+        directory
+    } else {
+        let mut directory = entry("Root Entry", 5, 1, END, 0);
+        directory.extend(entry(name, 2, 0xFFFF_FFFF, first, stream.len()));
+        directory
+    };
+    directory.resize(SECTOR, 0);
+    let mut file = header;
+    file.extend(fat.iter().flat_map(|word| word.to_le_bytes()));
+    file.extend(directory);
+    if small {
+        let mut mini_fat: Vec<u32> =
+            (1..data.len() / 64).map(|next| u32::try_from(next).unwrap()).collect();
+        mini_fat.push(END);
+        mini_fat.resize(SECTOR / 4, 0xFFFF_FFFF);
+        file.extend(mini_fat.iter().flat_map(|word| word.to_le_bytes()));
+    }
+    file.extend(pad(&data, SECTOR));
+    file
+}