imprimatur 0.2.0 → 0.3.0

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()
 }
 

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

@@ -0,0 +1,60 @@
+//! Column widths from the cells. There is no font to measure text with, so
+//! a column is as wide as its widest cell's character count says, scaled by
+//! that cell's font.
+
+#[cfg(test)]
+mod tests;
+
+use std::collections::BTreeMap;
+
+use super::cell::Cell;
+use super::format::Font;
+use super::worksheet::Worksheet;
+
+/// Excel's widest column, in characters.
+const MAX_WIDTH: f64 = 255.0;
+
+/// The width each column without one of its own needs for its widest cell:
+/// `(characters + 3) × points / 10`, a bold cell counting one and a half
+/// times, at most 255. Formulas are left out: their results are unknown.
+pub fn widths(sheet: &Worksheet, base: &Font) -> BTreeMap<u16, f64> {
+    let mut widths = BTreeMap::new();
+    for (_, cells) in sheet.rows() {
+        for (&column, entry) in cells {
+            if sheet.column_widths().contains_key(&column) {
+                continue;
+            }
+            let Some(characters) = characters(&entry.cell) else {
+                continue;
+            };
+            let font = usize::try_from(entry.style)
+                .ok()
+                .and_then(|style| style.checked_sub(1))
+                .and_then(|index| sheet.formats().get(index))
+                .map_or(base, |format| &format.font);
+            let bold = if font.bold { 1.5 } else { 1.0 };
+            #[expect(
+                clippy::cast_precision_loss,
+                reason = "a cell holds at most 32 767 characters"
+            )]
+            let width = (characters as f64 + 3.0) * f64::from(font.half_points(base)) / 20.0 * bold;
+            let width = (width.min(MAX_WIDTH) * 100.0).round() / 100.0;
+            let widest = widths.entry(column).or_insert(0.0_f64);
+            *widest = widest.max(width);
+        }
+    }
+    widths
+}
+
+/// How many characters a cell shows unformatted: a text's longest line,
+/// a number's digits, `TRUE`, a date as `yyyy-mm-dd` and a time
+/// `yyyy-mm-dd hh:mm:ss`.
+fn characters(cell: &Cell) -> Option<usize> {
+    match cell {
+        Cell::Text(text) => text.split('\n').map(|line| line.chars().count()).max(),
+        Cell::Number(number) => Some(number.to_string().len()),
+        Cell::Bool(value) => Some(if *value { 4 } else { 5 }),
+        Cell::DateTime(date) => Some(if date.has_time() { 19 } else { 10 }),
+        Cell::Formula(_) => None,
+    }
+}

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

@@ -90,6 +90,12 @@ impl DateTime {
         Self { hour: 0, minute: 0, second: 0, nanosecond: 0, ..self }
     }
 
+    /// Year, month and day.
+    #[must_use]
+    pub const fn year_month_day(&self) -> (u16, u8, u8) {
+        (self.year, self.month, self.day)
+    }
+
     /// Hours, minutes and seconds.
     #[must_use]
     pub const fn time_of_day(&self) -> (u8, u8, u8) {
@@ -147,7 +153,7 @@ const fn days_in_month(year: u16, month: u8) -> u8 {
 
 /// The calendar date `days` after 1970-01-01: the inverse of
 /// [`days_from_civil`] (Howard Hinnant's `civil_from_days`).
-const fn civil_from_days(days: i64) -> (i64, i64, i64) {
+pub const fn civil_from_days(days: i64) -> (i64, i64, i64) {
     let days = days + 719_468;
     let era = days.div_euclid(146_097);
     let day_of_era = days - era * 146_097;

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

@@ -132,7 +132,7 @@ impl Format {
         if length == 0 || length > MAX_FONT_NAME || name.chars().any(char::is_control) {
             return Err(Error::InvalidFontName(name));
         }
-        self.font.name = (name != DEFAULT_FONT).then_some(name);
+        self.font.name = Some(name);
         Ok(self)
     }
 
@@ -147,7 +147,7 @@ impl Format {
         #[expect(clippy::cast_possible_truncation, reason = "a whole number from 2 to 818")]
         #[expect(clippy::cast_sign_loss, reason = "a whole number from 2 to 818")]
         let half_points = half_points as u16;
-        self.font.half_points = (half_points != DEFAULT_HALF_POINTS).then_some(half_points);
+        self.font.half_points = Some(half_points);
         Ok(self)
     }
 
@@ -213,13 +213,29 @@ pub struct Font {
 }
 
 impl Font {
-    pub(crate) fn name(&self) -> &str {
-        self.name.as_deref().unwrap_or(DEFAULT_FONT)
+    /// No name or size of its own: the workbook's, Calibri 11 by default.
+    pub(crate) const BASE: Self = Self {
+        bold: false,
+        italic: false,
+        underline: false,
+        color: None,
+        name: None,
+        half_points: None,
+    };
+
+    /// Its name, or else the workbook's `base` one.
+    pub(crate) fn name<'a>(&'a self, base: &'a Self) -> &'a str {
+        self.name.as_deref().or(base.name.as_deref()).unwrap_or(DEFAULT_FONT)
+    }
+
+    /// Its size in half points, or else the workbook's `base` one.
+    pub(crate) fn half_points(&self, base: &Self) -> u16 {
+        self.half_points.or(base.half_points).unwrap_or(DEFAULT_HALF_POINTS)
     }
 
     /// The size in points as `<sz>` writes it: `11`, `10.5`.
-    pub(crate) fn size(&self) -> String {
-        let half_points = self.half_points.unwrap_or(DEFAULT_HALF_POINTS);
+    pub(crate) fn size(&self, base: &Self) -> String {
+        let half_points = self.half_points(base);
         let whole = half_points / 2;
         if half_points.is_multiple_of(2) { whole.to_string() } else { format!("{whole}.5") }
     }

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

@@ -1,10 +1,13 @@
 //! The parts of an `.xlsx` package and the relationships between them.
 
+use std::collections::BTreeMap;
 use std::fmt::Write as _;
 use std::io::Write;
 
+use super::autofit;
 use super::cell::{Cell, cell_reference, push_cell_reference};
 use super::comment;
+use super::format::Font;
 use super::styles::Stylesheet;
 use super::text::{SharedStrings, escape, needs_preserve};
 use super::validation;
@@ -28,7 +31,9 @@ const DRAWING_ID: &str = "rId2";
 /// compressed and dropped before the next is built, so only one sheet's XML
 /// is in memory at a time; the styles and the shared string table, complete
 /// only after every sheet, follow them.
-pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
+/// `font` is the workbook's: unformatted cells', and the formats' with no
+/// name or size.
+pub fn write<W: Write>(sheets: &[Worksheet], font: &Font, out: W) -> Result<W> {
     if sheets.is_empty() {
         return Err(Error::EmptyWorkbook);
     }
@@ -57,7 +62,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
     for (number, sheet) in (1..).zip(sheets) {
         let remap = styles.add_sheet(sheet)?;
         set(&mut name, format_args!("xl/worksheets/sheet{number}.xml"));
-        zip.add(&name, worksheet(sheet, &remap, &mut strings).as_bytes())?;
+        zip.add(&name, worksheet(sheet, &remap, &mut strings, font).as_bytes())?;
         let comments = sheet.comments();
         if comments.is_empty() {
             continue;
@@ -74,7 +79,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
         next_block += comment::blocks_for(comments.len());
     }
     debug_assert_eq!(has_strings, !strings.is_empty(), "the text scan matches the table");
-    zip.add("xl/styles.xml", styles.to_xml().as_bytes())?;
+    zip.add("xl/styles.xml", styles.to_xml(font).as_bytes())?;
     if has_strings {
         zip.add("xl/sharedStrings.xml", strings.to_xml().as_bytes())?;
     }
@@ -137,7 +142,12 @@ fn workbook(sheets: &[Worksheet]) -> String {
 
 /// `remap` turns the sheet's own style ids into the workbook's. The cell
 /// loop formats into three scratch buffers instead of allocating per cell.
-fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedStrings<'a>) -> String {
+fn worksheet<'a>(
+    sheet: &'a Worksheet,
+    remap: &[u32],
+    strings: &mut SharedStrings<'a>,
+    font: &Font,
+) -> String {
     let mut xml = XmlWriter::new();
     xml.open("worksheet", &[("xmlns", MAIN_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
     xml.empty("dimension", &[("ref", &dimension(sheet))]);
@@ -146,7 +156,7 @@ fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedString
         xml.empty("sheetView", &[("rightToLeft", "1"), ("workbookViewId", "0")]);
         xml.close("sheetViews");
     }
-    write_columns(&mut xml, sheet);
+    write_columns(&mut xml, sheet, font);
     xml.open("sheetData", &[]);
     let (mut reference, mut style, mut value) = (String::new(), String::new(), String::new());
     for (row, cells) in sheet.rows() {
@@ -216,13 +226,17 @@ fn set(buffer: &mut String, value: impl std::fmt::Display) {
 }
 
 /// `<cols>`: one `<col>` per run of adjacent columns with the same width.
-fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet) {
-    let widths = sheet.column_widths();
+/// The columns' widths: those set, and for an autofit sheet those its cells
+/// need.
+fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet, font: &Font) {
+    let mut widths =
+        if sheet.is_autofit() { autofit::widths(sheet, font) } else { BTreeMap::new() };
+    widths.extend(sheet.column_widths());
     if widths.is_empty() {
         return;
     }
     let mut runs: Vec<(u16, u16, f64)> = Vec::new();
-    for (&column, &width) in widths {
+    for (column, width) in widths {
         match runs.last_mut() {
             Some((_, last, run_width))
                 if *last + 1 == column && run_width.to_bits() == width.to_bits() =>

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

@@ -70,7 +70,8 @@ impl Stylesheet {
         Ok(remap)
     }
 
-    pub fn to_xml(&self) -> String {
+    /// The stylesheet, fonts without a name or size of their own in `base`.
+    pub fn to_xml(&self, base: &Font) -> String {
         let mut number_formats = Table::<&str>::new(FIRST_CUSTOM_NUMBER_FORMAT);
         let mut fonts = Table::<&Font>::new(1);
         let mut fills = Table::<Color>::new(2);
@@ -101,7 +102,7 @@ impl Stylesheet {
             }
             xml.close("numFmts");
         }
-        write_fonts(&mut xml, &fonts.order);
+        write_fonts(&mut xml, &fonts.order, base);
         write_fills(&mut xml, &fills.order);
         write_borders(&mut xml, &borders.order);
         xml.open("cellStyleXfs", &[("count", "1")]);
@@ -131,24 +132,24 @@ impl Stylesheet {
     }
 }
 
-fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font]) {
+/// Font 0, the one of unformatted cells, is `base`.
+fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font], base: &Font) {
     let count = (fonts.len() + 1).to_string();
     xml.open("fonts", &[("count", &count)]);
-    let default = Font::default();
-    for font in std::iter::once(&default).chain(fonts.iter().copied()) {
+    for font in std::iter::once(base).chain(fonts.iter().copied()) {
         xml.open("font", &[]);
         for (on, tag) in [(font.bold, "b"), (font.italic, "i"), (font.underline, "u")] {
             if on {
                 xml.empty(tag, &[]);
             }
         }
-        xml.empty("sz", &[("val", &font.size())]);
+        xml.empty("sz", &[("val", &font.size(base))]);
         if let Some(color) = font.color {
             xml.empty("color", &[("rgb", &color.argb())]);
         }
-        xml.empty("name", &[("val", font.name())]);
+        xml.empty("name", &[("val", font.name(base))]);
         // The family is a fallback hint; only Calibri's is known (2, swiss).
-        if font.name() == DEFAULT_FONT {
+        if font.name(base) == DEFAULT_FONT {
             xml.empty("family", &[("val", "2")]);
         }
         xml.close("font");

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

@@ -6,6 +6,7 @@ use std::sync::Arc;
 
 use super::text::check_length;
 use super::{Cell, CellRange, Comment, Format, Validation};
+use crate::script::Counts;
 use crate::{Error, Result};
 
 /// Rows in a sheet (Excel 2007 and later).
@@ -40,7 +41,9 @@ pub struct Worksheet {
     /// The style of an unformatted date, then of an unformatted date and time.
     date_styles: [Option<u32>; 2],
     widths: BTreeMap<u16, f64>,
-    right_to_left: bool,
+    autofit: bool,
+    /// As set; `None` to follow the sheet's text.
+    right_to_left: Option<bool>,
     validations: Vec<(CellRange, Validation)>,
     comments: BTreeMap<(u32, u16), Comment>,
 }
@@ -55,7 +58,8 @@ impl Worksheet {
             format_ids: HashMap::new(),
             date_styles: [None; 2],
             widths: BTreeMap::new(),
-            right_to_left: false,
+            autofit: false,
+            right_to_left: None,
             validations: Vec::new(),
             comments: BTreeMap::new(),
         }
@@ -174,16 +178,40 @@ impl Worksheet {
         Ok(self)
     }
 
-    /// Lays the sheet out right to left: column `A` on the right, as Excel
-    /// shows sheets for Arabic and Hebrew.
+    /// Sizes the columns without a width of their own to their widest cell,
+    /// estimated from its characters and font as
+    /// `(characters + 3) × points / 10`, bold one and a half times wider.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
+    }
+
+    #[must_use]
+    pub const fn is_autofit(&self) -> bool {
+        self.autofit
+    }
+
+    /// Lays the sheet out right to left, column `A` on the right, as Excel
+    /// shows sheets for Arabic and Hebrew; or left to right. Without a
+    /// call, a sheet is right to left when most of the letters of its name
+    /// and text cells are.
     pub const fn set_right_to_left(&mut self, right_to_left: bool) -> &mut Self {
-        self.right_to_left = right_to_left;
+        self.right_to_left = Some(right_to_left);
         self
     }
 
     #[must_use]
-    pub const fn is_right_to_left(&self) -> bool {
-        self.right_to_left
+    pub fn is_right_to_left(&self) -> bool {
+        self.right_to_left.unwrap_or_else(|| {
+            let mut counts = Counts::default();
+            counts.add(&self.name);
+            for entry in self.rows.values().flat_map(BTreeMap::values) {
+                if let Cell::Text(text) = &entry.cell {
+                    counts.add(text);
+                }
+            }
+            counts.right_to_left()
+        })
     }
 
     /// Applies a rule to the cells of `range`, whether or not they hold values.

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

@@ -1,5 +1,6 @@
 //! `SpreadsheetML` (`.xlsx`) workbooks, per ECMA-376 Part 1.
 
+mod autofit;
 mod cell;
 mod comment;
 mod date;
@@ -22,6 +23,9 @@ pub(crate) use cell::push_cell_reference;
 pub use cell::{Cell, cell_reference, column_name};
 pub use comment::Comment;
 pub use date::DateTime;
+#[cfg(feature = "archive")]
+pub(crate) use date::civil_from_days;
+use format::Font;
 pub use format::{Border, Format, VerticalAlign};
 pub use range::{CellRange, parse_cell_reference};
 pub use validation::{Alert, Validation};
@@ -36,12 +40,44 @@ const MAX_SHEET_NAME: usize = 31;
 #[derive(Debug, Default)]
 pub struct Workbook {
     sheets: Vec<Worksheet>,
+    /// The font of unformatted cells, and of formats with no name or size.
+    font: Font,
+    /// Whether new sheets size their columns to their cells.
+    autofit: bool,
 }
 
 impl Workbook {
     #[must_use]
     pub const fn new() -> Self {
-        Self { sheets: Vec::new() }
+        Self { sheets: Vec::new(), font: Font::BASE, autofit: false }
+    }
+
+    /// The font of cells without a format, and of formats that name no font:
+    /// Calibri unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontName`] for an empty name, one longer than 31
+    /// characters or with a control character.
+    pub fn set_font_name(&mut self, name: impl Into<String>) -> Result<&mut Self> {
+        self.font.name = Format::new().font_name(name)?.font.name;
+        Ok(self)
+    }
+
+    /// The size of cells without a format, and of formats that set none: 11
+    /// points unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontSize`] outside 1 to 409 points in steps of 0.5.
+    pub fn set_font_size(&mut self, points: f64) -> Result<&mut Self> {
+        self.font.half_points = Format::new().font_size(points)?.font.half_points;
+        Ok(self)
+    }
+
+    /// Whether the sheets added from now on size their columns to their
+    /// cells, as [`Worksheet::set_autofit`] does.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
     }
 
     /// Adds a sheet after the existing ones and returns it for writing.
@@ -56,7 +92,8 @@ impl Workbook {
         if self.sheets.iter().any(|sheet| sheet.name().to_lowercase() == folded) {
             return Err(Error::DuplicateSheetName(name));
         }
-        Ok(self.sheets.push_mut(Worksheet::new(name)))
+        let autofit = self.autofit;
+        Ok(self.sheets.push_mut(Worksheet::new(name)).set_autofit(autofit))
     }
 
     #[must_use]
@@ -73,7 +110,7 @@ impl Workbook {
     /// # Errors
     /// [`Error::EmptyWorkbook`] without sheets, [`Error::Io`] when `out` fails.
     pub fn write_to<W: Write>(&self, out: W) -> Result<W> {
-        package::write(&self.sheets, out)
+        package::write(&self.sheets, &self.font, out)
     }
 
     /// The `.xlsx` package as bytes.

data/ext/imprimatur_native/core/src/xml/reader.rs

@@ -57,6 +57,16 @@ impl<'a> Tag<'a> {
         }
     }
 
+    /// The attribute parsed: `None` when it is missing or does not parse.
+    pub fn parse<T: std::str::FromStr>(&self, local: &str) -> Option<T> {
+        self.attr(local)?.parse().ok()
+    }
+
+    /// Whether the attribute is there and on: `1`, `true` or `on`.
+    pub fn on(&self, local: &str) -> bool {
+        self.attr(local).is_some() && self.flag(local)
+    }
+
     /// `w:val`-style booleans: present without a value, `1`, `true` or
     /// `on` are true; Word writes `w:val="0"` to switch a property off.
     pub fn flag(&self, local: &str) -> bool {

data/ext/imprimatur_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur_native"
-version = "0.2.0"
+version = "0.3.0"
 description = "Ruby bindings for the imprimatur crate"
 publish = false
 edition.workspace = true
@@ -15,7 +15,8 @@ crate-type = ["cdylib"]
 workspace = true
 
 [dependencies]
-imprimatur = { workspace = true, features = ["archive", "json"] }
+# Gems ship precompiled, so they carry every feature of the crate.
+imprimatur = { workspace = true, features = ["archive", "fonts", "json"] }
 serde_json.workspace = true
 magnus.workspace = true
 rb-sys.workspace = true

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

@@ -45,9 +45,7 @@ impl ZipWriter {
         data: RString,
         comment: Option<String>,
     ) -> Result<(), Error> {
-        // SAFETY: the bytes are copied out at once, while the GVL is held.
-        #[allow(unsafe_code)]
-        let data = unsafe { data.as_slice() }.to_vec();
+        let data = crate::bytes(data);
         let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
         let writer = slot.as_mut().ok_or_else(|| finished(ruby))?;
         without_gvl(ruby, || writer.add(&name, &data, comment.as_deref()))?.or_raise(ruby)