imprimatur 0.1.0

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

@@ -0,0 +1,173 @@
+//! Dates as Excel stores them: a number of days since 1900-01-00, with the
+//! time of day as the fraction. No time zone; the wall-clock fields are what
+//! the cell shows.
+
+#[cfg(test)]
+mod tests;
+
+use std::fmt;
+
+use crate::{Error, Result};
+
+const SECONDS_PER_DAY: f64 = 86_400.0;
+
+/// A date, optionally with a time of day, between 1900-01-01 and 9999-12-31.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DateTime {
+    year: u16,
+    month: u8,
+    day: u8,
+    hour: u8,
+    minute: u8,
+    second: u8,
+    nanosecond: u32,
+}
+
+impl DateTime {
+    /// Midnight on a calendar date.
+    ///
+    /// # Errors
+    /// [`Error::DateOutOfRange`] for an invalid date or one Excel cannot hold.
+    pub fn date(year: u16, month: u8, day: u8) -> Result<Self> {
+        let date = Self { year, month, day, hour: 0, minute: 0, second: 0, nanosecond: 0 };
+        let valid = (1900..=9999).contains(&year)
+            && (1..=12).contains(&month)
+            && day >= 1
+            && day <= days_in_month(year, month);
+        valid.ok_or_else(|| Error::DateOutOfRange(date.to_string()))?;
+        Ok(date)
+    }
+
+    /// The same date at a time of day. Excel shows milliseconds at most.
+    ///
+    /// # Errors
+    /// [`Error::DateOutOfRange`] for an hour, minute, second or nanosecond
+    /// out of range (leap seconds included).
+    pub fn at(self, hour: u8, minute: u8, second: u8, nanosecond: u32) -> Result<Self> {
+        let time = Self { hour, minute, second, nanosecond, ..self };
+        (hour < 24 && minute < 60 && second < 60 && nanosecond < 1_000_000_000)
+            .ok_or_else(|| Error::DateOutOfRange(time.to_string()))?;
+        Ok(time)
+    }
+
+    /// The date a serial number stands for, to the second: the inverse of
+    /// [`serial`](Self::serial). `date1904` is the Mac epoch some workbooks
+    /// use, where 0 is 1904-01-01. `None` outside 1900-01-01 to 9999-12-31,
+    /// and for 60, the 1900-02-29 that never existed.
+    #[must_use]
+    pub fn from_serial(serial: f64, date1904: bool) -> Option<Self> {
+        if !serial.is_finite() || serial < 0.0 {
+            return None;
+        }
+        #[expect(clippy::cast_possible_truncation, reason = "checked against 9999-12-31 below")]
+        let seconds = (serial * SECONDS_PER_DAY).round() as i64;
+        let (mut days, seconds) = (seconds.div_euclid(86_400), seconds.rem_euclid(86_400));
+        days += if date1904 {
+            days_from_civil(1904, 1, 1)
+        } else if days == 60 {
+            return None;
+        } else if days > 60 {
+            days_from_civil(1899, 12, 30)
+        } else {
+            days_from_civil(1899, 12, 31)
+        };
+        let (year, month, day) = civil_from_days(days);
+        let (Ok(year), Ok(month), Ok(day)) =
+            (u16::try_from(year), u8::try_from(month), u8::try_from(day))
+        else {
+            return None;
+        };
+        let (hour, minute, second) = (seconds / 3600, seconds / 60 % 60, seconds % 60);
+        #[expect(clippy::cast_possible_truncation, reason = "a time of day: 0 to 59, or 23")]
+        #[expect(clippy::cast_sign_loss, reason = "rem_euclid is never negative")]
+        let time = (hour as u8, minute as u8, second as u8);
+        Self::date(year, month, day).ok()?.at(time.0, time.1, time.2, 0).ok()
+    }
+
+    /// The same day at midnight.
+    #[must_use]
+    pub const fn date_only(self) -> Self {
+        Self { hour: 0, minute: 0, second: 0, nanosecond: 0, ..self }
+    }
+
+    /// Hours, minutes and seconds.
+    #[must_use]
+    pub const fn time_of_day(&self) -> (u8, u8, u8) {
+        (self.hour, self.minute, self.second)
+    }
+
+    /// Whether the time of day is past midnight.
+    #[must_use]
+    pub const fn has_time(&self) -> bool {
+        self.hour != 0 || self.minute != 0 || self.second != 0 || self.nanosecond != 0
+    }
+
+    /// The Excel serial number: 1 is 1900-01-01, 45000 is 2023-03-15.
+    #[must_use]
+    pub fn serial(&self) -> f64 {
+        let (year, month, day) = (i64::from(self.year), i64::from(self.month), i64::from(self.day));
+        let mut days = days_from_civil(year, month, day) - days_from_civil(1899, 12, 31);
+        // Excel keeps Lotus 1-2-3's 1900-02-29, which never existed: every
+        // later date is one day further along.
+        if (self.year, self.month) >= (1900, 3) {
+            days += 1;
+        }
+        let seconds =
+            u32::from(self.hour) * 3600 + u32::from(self.minute) * 60 + u32::from(self.second);
+        let fraction = (f64::from(seconds) + f64::from(self.nanosecond) / 1e9) / SECONDS_PER_DAY;
+        #[expect(clippy::cast_precision_loss, reason = "at most 2958465 days, far below 2**53")]
+        let days = days as f64;
+        days + fraction
+    }
+}
+
+impl fmt::Display for DateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)?;
+        if self.has_time() {
+            write!(f, " {:02}:{:02}:{:02}", self.hour, self.minute, self.second)?;
+            if self.nanosecond != 0 {
+                write!(f, ".{:09}", self.nanosecond)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+const fn days_in_month(year: u16, month: u8) -> u8 {
+    match month {
+        2 if year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400)) => {
+            29
+        }
+        2 => 28,
+        4 | 6 | 9 | 11 => 30,
+        _ => 31,
+    }
+}
+
+/// 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) {
+    let days = days + 719_468;
+    let era = days.div_euclid(146_097);
+    let day_of_era = days - era * 146_097;
+    let year_of_era =
+        (day_of_era - day_of_era / 1460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
+    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
+    let shifted_month = (5 * day_of_year + 2) / 153;
+    let day = day_of_year - (153 * shifted_month + 2) / 5 + 1;
+    let month = if shifted_month < 10 { shifted_month + 3 } else { shifted_month - 9 };
+    let year = year_of_era + era * 400 + if month <= 2 { 1 } else { 0 };
+    (year, month, day)
+}
+
+/// Days from 1970-01-01 in the proleptic Gregorian calendar (Howard
+/// Hinnant's `days_from_civil`).
+const fn days_from_civil(year: i64, month: i64, day: i64) -> i64 {
+    let year = if month <= 2 { year - 1 } else { year };
+    let era = year.div_euclid(400);
+    let year_of_era = year - era * 400;
+    let day_of_year = (153 * ((month + 9) % 12) + 2) / 5 + day - 1;
+    let day_of_era = year_of_era * 365 + year_of_era / 4 - year_of_era / 100 + day_of_year;
+    era * 146_097 + day_of_era - 719_468
+}

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

@@ -0,0 +1,226 @@
+//! How a cell looks: number format, font, fill, alignment and border.
+
+#[cfg(test)]
+mod tests;
+
+use crate::style::{Align, Color, TextDirection};
+use crate::{Error, Result};
+
+/// Excel's limit on a number format code.
+const MAX_NUMBER_FORMAT: usize = 255;
+/// Excel's limit on a font name.
+const MAX_FONT_NAME: usize = 31;
+/// The largest font size Excel accepts, in points.
+const MAX_FONT_SIZE: f64 = 409.0;
+/// The font of unformatted cells.
+pub const DEFAULT_FONT: &str = "Calibri";
+/// Its size, in half points.
+const DEFAULT_HALF_POINTS: u16 = 22;
+
+/// Vertical alignment within the cell. Excel's default is the bottom.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum VerticalAlign {
+    Top,
+    Center,
+    Bottom,
+}
+
+impl VerticalAlign {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
+            Self::Top => "top",
+            Self::Center => "center",
+            Self::Bottom => "bottom",
+        }
+    }
+}
+
+/// A line on all four sides of the cell.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Border {
+    Thin,
+    Medium,
+    Thick,
+}
+
+impl Border {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
+            Self::Thin => "thin",
+            Self::Medium => "medium",
+            Self::Thick => "thick",
+        }
+    }
+}
+
+/// A cell format, built up from the default look:
+///
+/// ```
+/// use imprimatur::xlsx::{Align, Color, Format};
+///
+/// let money = Format::new().number_format("#,##0.00")?.bold().fill(Color::rgb(0xFFF2CC));
+/// let header = Format::new().bold().align(Align::Center);
+/// # Ok::<(), imprimatur::Error>(())
+/// ```
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct Format {
+    pub(crate) number_code: Option<String>,
+    pub(crate) font: Font,
+    pub(crate) fill: Option<Color>,
+    pub(crate) align: Option<Align>,
+    pub(crate) valign: Option<VerticalAlign>,
+    pub(crate) direction: Option<TextDirection>,
+    pub(crate) wrap: bool,
+    pub(crate) border: Option<Border>,
+}
+
+impl Format {
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// An Excel number format code, such as `0.00`, `#,##0`, `0%` or
+    /// `yyyy-mm-dd`. `General` is the default.
+    ///
+    /// # Errors
+    /// [`Error::InvalidNumberFormat`] when empty, over 255 characters, or
+    /// holding a control character.
+    pub fn number_format(mut self, code: impl Into<String>) -> Result<Self> {
+        let code = code.into();
+        let length = code.chars().count();
+        if length == 0 || length > MAX_NUMBER_FORMAT || code.chars().any(char::is_control) {
+            return Err(Error::InvalidNumberFormat(code));
+        }
+        self.number_code = Some(code);
+        Ok(self)
+    }
+
+    #[must_use]
+    pub const fn bold(mut self) -> Self {
+        self.font.bold = true;
+        self
+    }
+
+    #[must_use]
+    pub const fn italic(mut self) -> Self {
+        self.font.italic = true;
+        self
+    }
+
+    #[must_use]
+    pub const fn underline(mut self) -> Self {
+        self.font.underline = true;
+        self
+    }
+
+    #[must_use]
+    pub const fn font_color(mut self, color: Color) -> Self {
+        self.font.color = Some(color);
+        self
+    }
+
+    /// The typeface, such as `Arial`; Calibri by default. Excel substitutes
+    /// another font when the reader's machine lacks it.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontName`] when empty, over 31 characters, or holding
+    /// a control character.
+    pub fn font_name(mut self, name: impl Into<String>) -> Result<Self> {
+        let name = name.into();
+        let length = name.chars().count();
+        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);
+        Ok(self)
+    }
+
+    /// The size in points, 11 by default.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontSize`] outside 1 to 409, or between half points.
+    pub fn font_size(mut self, points: f64) -> Result<Self> {
+        let half_points = points * 2.0;
+        let valid = (1.0..=MAX_FONT_SIZE).contains(&points) && half_points.fract() == 0.0;
+        valid.ok_or(Error::InvalidFontSize(points))?;
+        #[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);
+        Ok(self)
+    }
+
+    /// A solid background.
+    #[must_use]
+    pub const fn fill(mut self, color: Color) -> Self {
+        self.fill = Some(color);
+        self
+    }
+
+    #[must_use]
+    pub const fn align(mut self, align: Align) -> Self {
+        self.align = Some(align);
+        self
+    }
+
+    #[must_use]
+    pub const fn valign(mut self, valign: VerticalAlign) -> Self {
+        self.valign = Some(valign);
+        self
+    }
+
+    #[must_use]
+    pub const fn direction(mut self, direction: TextDirection) -> Self {
+        self.direction = Some(direction);
+        self
+    }
+
+    /// Wraps text onto several lines within the column width.
+    #[must_use]
+    pub const fn wrap(mut self) -> Self {
+        self.wrap = true;
+        self
+    }
+
+    #[must_use]
+    pub const fn border(mut self, border: Border) -> Self {
+        self.border = Some(border);
+        self
+    }
+
+    pub(crate) const fn has_number_format(&self) -> bool {
+        self.number_code.is_some()
+    }
+
+    /// Whether the format needs an `<alignment>` element.
+    pub(crate) const fn has_alignment(&self) -> bool {
+        self.align.is_some() || self.valign.is_some() || self.direction.is_some() || self.wrap
+    }
+}
+
+/// The part of a format that lives in `<fonts>`. The default typeface and
+/// size are `None`, so a format naming them equals one that does not.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct Font {
+    pub(crate) bold: bool,
+    pub(crate) italic: bool,
+    pub(crate) underline: bool,
+    pub(crate) color: Option<Color>,
+    pub(crate) name: Option<String>,
+    /// Points times two: sizes come in steps of 0.5.
+    pub(crate) half_points: Option<u16>,
+}
+
+impl Font {
+    pub(crate) fn name(&self) -> &str {
+        self.name.as_deref().unwrap_or(DEFAULT_FONT)
+    }
+
+    /// 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);
+        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

@@ -0,0 +1,268 @@
+//! The parts of an `.xlsx` package and the relationships between them.
+
+use std::fmt::Write as _;
+use std::io::Write;
+
+use super::cell::{Cell, cell_reference, push_cell_reference};
+use super::comment;
+use super::styles::Stylesheet;
+use super::text::{SharedStrings, escape, needs_preserve};
+use super::validation;
+use super::worksheet::Worksheet;
+use crate::opc;
+use crate::xml::XmlWriter;
+use crate::zip::ZipWriter;
+use crate::{Error, Result};
+
+pub const MAIN_NS: &str = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+
+const SPREADSHEET_TYPE: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml";
+pub const VML_TYPE: &str = "application/vnd.openxmlformats-officedocument.vmlDrawing";
+/// A sheet's own relationships: its comments, then their drawing.
+const SHEET_RELATIONSHIPS: [(&str, &str); 2] =
+    [("comments", "../comments{n}.xml"), ("vmlDrawing", "../drawings/vmlDrawing{n}.vml")];
+const DRAWING_ID: &str = "rId2";
+
+/// Writes the whole package. Each sheet becomes `xl/worksheets/sheetN.xml`,
+/// followed by its comments and their drawing if it has any, and is
+/// 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> {
+    if sheets.is_empty() {
+        return Err(Error::EmptyWorkbook);
+    }
+    let has_strings = sheets.iter().any(|sheet| {
+        sheet
+            .rows()
+            .any(|(_, cells)| cells.values().any(|entry| matches!(entry.cell, Cell::Text(_))))
+    });
+
+    let mut zip = ZipWriter::new(out);
+    zip.add("[Content_Types].xml", content_types(sheets, has_strings).as_bytes())?;
+    zip.add(
+        "_rels/.rels",
+        opc::relationships(&[("officeDocument", "xl/workbook.xml")]).as_bytes(),
+    )?;
+    zip.add("xl/workbook.xml", workbook(sheets).as_bytes())?;
+    zip.add(
+        "xl/_rels/workbook.xml.rels",
+        workbook_relationships(sheets.len(), has_strings).as_bytes(),
+    )?;
+    let mut strings = SharedStrings::default();
+    let mut styles = Stylesheet::default();
+    let mut name = String::new();
+    // VML shape ids are unique across the workbook, in blocks of 1024.
+    let mut next_block = 1;
+    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())?;
+        let comments = sheet.comments();
+        if comments.is_empty() {
+            continue;
+        }
+        let targets = SHEET_RELATIONSHIPS
+            .map(|(kind, target)| (kind, target.replace("{n}", &number.to_string())));
+        set(&mut name, format_args!("xl/worksheets/_rels/sheet{number}.xml.rels"));
+        zip.add(&name, opc::relationships(&targets).as_bytes())?;
+        set(&mut name, format_args!("xl/comments{number}.xml"));
+        zip.add(&name, comment::comments_xml(comments).as_bytes())?;
+        set(&mut name, format_args!("xl/drawings/vmlDrawing{number}.vml"));
+        let drawing = comment::vml(comments, sheet.column_widths(), next_block);
+        zip.add(&name, drawing.as_bytes())?;
+        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())?;
+    if has_strings {
+        zip.add("xl/sharedStrings.xml", strings.to_xml().as_bytes())?;
+    }
+    zip.finish()
+}
+
+/// One override per part: the workbook, its styles, shared strings, sheets
+/// and comments. Drawings, by their `.vml` extension.
+fn content_types(sheets: &[Worksheet], has_strings: bool) -> String {
+    let mut parts = vec![
+        ("/xl/workbook.xml".to_owned(), "sheet.main"),
+        ("/xl/styles.xml".to_owned(), "styles"),
+    ];
+    if has_strings {
+        parts.push(("/xl/sharedStrings.xml".to_owned(), "sharedStrings"));
+    }
+    let mut commented = false;
+    for (number, sheet) in (1..).zip(sheets) {
+        parts.push((format!("/xl/worksheets/sheet{number}.xml"), "worksheet"));
+        if !sheet.comments().is_empty() {
+            parts.push((format!("/xl/comments{number}.xml"), "comments"));
+            commented = true;
+        }
+    }
+    let overrides: Vec<(String, String)> = parts
+        .into_iter()
+        .map(|(part, kind)| (part, format!("{SPREADSHEET_TYPE}.{kind}+xml")))
+        .collect();
+    let defaults: &[(&str, &str)] = if commented { &[("vml", VML_TYPE)] } else { &[] };
+    opc::content_types(defaults, &overrides)
+}
+
+/// Sheets are `rId1`..`rIdN`, then styles, then shared strings.
+fn workbook_relationships(sheet_count: usize, has_strings: bool) -> String {
+    let mut targets: Vec<(&str, String)> = (1..=sheet_count)
+        .map(|number| ("worksheet", format!("worksheets/sheet{number}.xml")))
+        .collect();
+    targets.push(("styles", "styles.xml".to_owned()));
+    if has_strings {
+        targets.push(("sharedStrings", "sharedStrings.xml".to_owned()));
+    }
+    opc::relationships(&targets)
+}
+
+fn workbook(sheets: &[Worksheet]) -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("workbook", &[("xmlns", MAIN_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
+    xml.open("sheets", &[]);
+    for (index, sheet) in sheets.iter().enumerate() {
+        let number = (index + 1).to_string();
+        let id = format!("rId{number}");
+        xml.empty("sheet", &[("name", sheet.name()), ("sheetId", &number), ("r:id", &id)]);
+    }
+    xml.close("sheets");
+    // Formulas are written without cached results: have Excel compute them.
+    xml.empty("calcPr", &[("fullCalcOnLoad", "1")]);
+    xml.close("workbook");
+    xml.finish()
+}
+
+/// `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 {
+    let mut xml = XmlWriter::new();
+    xml.open("worksheet", &[("xmlns", MAIN_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
+    xml.empty("dimension", &[("ref", &dimension(sheet))]);
+    if sheet.is_right_to_left() {
+        xml.open("sheetViews", &[]);
+        xml.empty("sheetView", &[("rightToLeft", "1"), ("workbookViewId", "0")]);
+        xml.close("sheetViews");
+    }
+    write_columns(&mut xml, sheet);
+    xml.open("sheetData", &[]);
+    let (mut reference, mut style, mut value) = (String::new(), String::new(), String::new());
+    for (row, cells) in sheet.rows() {
+        set(&mut value, u64::from(row) + 1);
+        xml.open("row", &[("r", &value)]);
+        for (&column, entry) in cells {
+            reference.clear();
+            push_cell_reference(&mut reference, row, column);
+            // Every style id a cell holds came from the sheet's own table.
+            let id = remap.get(entry.style as usize).copied().unwrap_or_default();
+            set(&mut style, id);
+            let styled = id != 0;
+            let (kind, text) = match &entry.cell {
+                Cell::Text(text) => {
+                    set(&mut value, strings.intern(text));
+                    (Some("s"), None)
+                }
+                Cell::Number(number) => {
+                    set(&mut value, number);
+                    (None, None)
+                }
+                Cell::DateTime(date) => {
+                    set(&mut value, date.serial());
+                    (None, None)
+                }
+                Cell::Bool(flag) => {
+                    set(&mut value, u8::from(*flag));
+                    (Some("b"), None)
+                }
+                Cell::Formula(formula) => (None, Some(formula)),
+            };
+            let attrs =
+                [("r", reference.as_str()), ("s", style.as_str()), ("t", kind.unwrap_or(""))];
+            let attrs: &[(&str, &str)] = match (styled, kind.is_some()) {
+                (true, true) => &attrs,
+                (true, false) => &attrs[..2],
+                (false, true) => &[attrs[0], attrs[2]],
+                (false, false) => &attrs[..1],
+            };
+            xml.open("c", attrs);
+            match text {
+                Some(formula) => {
+                    let preserve: &[(&str, &str)] =
+                        if needs_preserve(formula) { &[("xml:space", "preserve")] } else { &[] };
+                    xml.element("f", preserve, &escape(formula));
+                }
+                None => xml.element("v", &[], &value),
+            }
+            xml.close("c");
+        }
+        xml.close("row");
+    }
+    xml.close("sheetData");
+    validation::write_all(&mut xml, sheet.validations());
+    if !sheet.comments().is_empty() {
+        xml.empty("legacyDrawing", &[("r:id", DRAWING_ID)]);
+    }
+    xml.close("worksheet");
+    xml.finish()
+}
+
+/// Replaces `buffer` with `value`'s text, reusing its allocation.
+fn set(buffer: &mut String, value: impl std::fmt::Display) {
+    buffer.clear();
+    // Writing to a String cannot fail.
+    let _ = write!(buffer, "{value}");
+}
+
+/// `<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();
+    if widths.is_empty() {
+        return;
+    }
+    let mut runs: Vec<(u16, u16, f64)> = Vec::new();
+    for (&column, &width) in widths {
+        match runs.last_mut() {
+            Some((_, last, run_width))
+                if *last + 1 == column && run_width.to_bits() == width.to_bits() =>
+            {
+                *last = column;
+            }
+            _ => runs.push((column, column, width)),
+        }
+    }
+    xml.open("cols", &[]);
+    for (first, last, width) in runs {
+        // <col> numbers columns from 1.
+        let (min, max) = ((first + 1).to_string(), (last + 1).to_string());
+        let width = width.to_string();
+        xml.empty("col", &[("min", &min), ("max", &max), ("width", &width), ("customWidth", "1")]);
+    }
+    xml.close("cols");
+}
+
+/// The used range, `A1` for an empty sheet as Excel writes it.
+fn dimension(sheet: &Worksheet) -> String {
+    let mut bounds: Option<(u32, u16, u32, u16)> = None;
+    for (row, cells) in sheet.rows() {
+        let (Some((&first, _)), Some((&last, _))) =
+            (cells.first_key_value(), cells.last_key_value())
+        else {
+            continue;
+        };
+        bounds = Some(match bounds {
+            None => (row, first, row, last),
+            Some((top, left, _, right)) => (top, left.min(first), row, right.max(last)),
+        });
+    }
+    let Some((top, left, bottom, right)) = bounds else {
+        return "A1".to_owned();
+    };
+    let mut range = cell_reference(top, left);
+    if (top, left) != (bottom, right) {
+        // Writing to a String cannot fail.
+        let _ = write!(range, ":{}", cell_reference(bottom, right));
+    }
+    range
+}