imprimatur 0.1.0 → 0.3.0

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

@@ -9,16 +9,35 @@ mod tests;
 
 use serde_json::{Map, Value as Json, json};
 
-use super::{Block, Bounds, Cell, Content, Grid, Image, ImageLocation, Mark, Page, Sheet, Value};
+use super::{
+    Block, Bounds, Cell, Columns, Content, Grid, Image, ImageLocation, Look, Mark, Page, Sheet,
+    Styled, Validation, Value,
+};
+use crate::xlsx::column_name;
+
+/// What [`content_with`] adds to the content.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Options {
+    /// Each formatted cell of a sheet, with its look.
+    pub styles: bool,
+}
 
 /// The document's content, by format: `pages`, `sheets` or `blocks`.
 #[must_use]
 pub fn content(content: &Content) -> Map<String, Json> {
+    content_with(content, Options::default())
+}
+
+/// The document's content, with what `options` add.
+#[must_use]
+pub fn content_with(content: &Content, options: Options) -> Map<String, Json> {
     let mut object = Map::new();
     object.insert("format".into(), content.format().as_str().into());
     match content {
         Content::Pdf(pages) => object.insert("pages".into(), pages.iter().map(page).collect()),
-        Content::Xlsx(sheets) => object.insert("sheets".into(), sheets.iter().map(sheet).collect()),
+        Content::Xlsx(sheets) | Content::Ods(sheets) | Content::Xls(sheets) => {
+            object.insert("sheets".into(), sheets.iter().map(|it| sheet(it, options)).collect())
+        }
         Content::Docx(blocks) => object.insert("blocks".into(), blocks.iter().map(block).collect()),
     };
     object
@@ -114,7 +133,19 @@ fn with_marks(mut object: Json, marks: &[Mark]) -> Json {
     object
 }
 
-fn sheet(sheet: &Sheet) -> Json {
+fn sheet(sheet: &Sheet, options: Options) -> Json {
+    let mut object = Map::new();
+    object.insert("name".into(), sheet.name.clone().into());
+    object.insert("hidden".into(), sheet.hidden.into());
+    object.insert("rows".into(), rows(&sheet.cells, true));
+    object.extend(sheet_details(sheet, options));
+    Json::Object(object)
+}
+
+/// What a sheet has besides its values: `comments`, `columns`,
+/// `validations` and, with `options.styles`, `styles`.
+#[must_use]
+pub fn sheet_details(sheet: &Sheet, options: Options) -> Map<String, Json> {
     let comments: Vec<Json> = sheet
         .comments
         .iter()
@@ -123,11 +154,69 @@ fn sheet(sheet: &Sheet) -> Json {
             json!({ "cell": note.reference(), "author": author, "text": note.text })
         })
         .collect();
+    let mut details = Map::new();
+    details.insert("comments".into(), comments.into());
+    details.insert("columns".into(), sheet.columns.iter().map(columns).collect());
+    details.insert("validations".into(), sheet.validations.iter().map(validation).collect());
+    if options.styles {
+        details.insert("styles".into(), sheet.styles.iter().map(styled).collect());
+    }
+    details
+}
+
+/// Columns by letter: `A`, `XFD`.
+fn columns(run: &Columns) -> Json {
+    let name = |column: u32| column_name(u16::try_from(column).unwrap_or(u16::MAX));
+    let (first, last) = (name(run.first), name(run.last));
+    json!({ "first": first, "last": last, "width": run.width, "hidden": run.hidden })
+}
+
+fn validation(rule: &Validation) -> Json {
+    json!({
+        "range": rule.range,
+        "type": rule.kind,
+        "operator": rule.operator,
+        "formula1": rule.formula1,
+        "formula2": rule.formula2,
+        "allow_blank": rule.allow_blank,
+        "dropdown": rule.dropdown,
+        "alert": rule.alert,
+        "error_title": rule.error_title,
+        "error": rule.error,
+        "prompt_title": rule.prompt_title,
+        "prompt": rule.prompt,
+    })
+}
+
+fn styled(cell: &Styled) -> Json {
+    let Look {
+        font,
+        size,
+        bold,
+        italic,
+        underline,
+        color,
+        fill,
+        align,
+        valign,
+        wrap,
+        border,
+        number_format,
+    } = cell.look.as_ref();
     json!({
-        "name": sheet.name,
-        "hidden": sheet.hidden,
-        "rows": rows(&sheet.cells, true),
-        "comments": comments,
+        "cell": cell.reference(),
+        "font": font,
+        "size": size,
+        "bold": bold,
+        "italic": italic,
+        "underline": underline,
+        "color": color,
+        "fill": fill,
+        "align": align,
+        "valign": valign,
+        "wrap": wrap,
+        "border": border,
+        "number_format": number_format,
     })
 }
 

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

@@ -23,7 +23,7 @@ impl Content {
         let mut out = String::new();
         match self {
             Self::Pdf(pages) => pdf(&mut out, pages),
-            Self::Xlsx(sheets) => {
+            Self::Xlsx(sheets) | Self::Ods(sheets) | Self::Xls(sheets) => {
                 for sheet in sheets {
                     write_sheet(&mut out, sheet);
                 }

data/ext/imprimatur_native/core/src/read/{xlsx/numbers.rs → numbers.rs}

@@ -1,13 +1,11 @@
-//! How XLSX number formats show numbers: which formats are dates, times
-//! or percentages, and Excel's General format.
+//! How spreadsheet number formats show numbers: which formats are dates,
+//! times or percentages, and Excel's General format. XLSX and XLS share
+//! Excel's format codes and built-in formats.
 
 use std::fmt::Write as _;
 
-use crate::Result;
-use crate::read::Budget;
 use crate::read::content::Value;
 use crate::xlsx::DateTime;
-use crate::xml::reader::{Event, XmlReader};
 
 /// How a number format shows a number.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -16,43 +14,24 @@ pub enum Shown {
     Date,
     Time,
     DateTime,
-    Percent,
-}
-
-/// How each cell format (`cellXfs`, by index) shows numbers.
-pub fn styles(text: &str, budget: &Budget<'_>) -> Result<Vec<Shown>> {
-    let mut xml = XmlReader::new(text, budget.max_depth());
-    let (mut custom, mut shown, mut in_cell_formats) = (Vec::new(), Vec::new(), false);
-    while let Some(event) = xml.next()? {
-        match event {
-            Event::Start(tag) => match tag.name() {
-                "numFmt" => {
-                    if let (Some(id), Some(code)) = (tag.attr("numFmtId"), tag.attr("formatCode")) {
-                        custom.push((id.parse::<u32>().unwrap_or(u32::MAX), classify(&code)));
-                    }
-                }
-                "cellXfs" => in_cell_formats = true,
-                "xf" if in_cell_formats => {
-                    let id =
-                        tag.attr("numFmtId").and_then(|id| id.parse::<u32>().ok()).unwrap_or(0);
-                    let custom =
-                        custom.iter().find(|&&(custom, _)| custom == id).map(|&(_, shown)| shown);
-                    shown.push(custom.unwrap_or_else(|| built_in(id)));
-                }
-                _ => {}
-            },
-            Event::End("cellXfs") => in_cell_formats = false,
-            _ => {}
-        }
-    }
-    Ok(shown)
+    /// A fixed number of decimals, thousands grouped with `,` or not, as a
+    /// percentage or not: `0.00`, `#,##0`, `0%`.
+    Fixed {
+        decimals: u8,
+        grouping: bool,
+        percent: bool,
+    },
 }
 
 /// Excel's built-in number formats (ECMA-376 Part 1, 18.8.30), with the
 /// East Asian date formats.
-const fn built_in(id: u32) -> Shown {
+pub const fn built_in(id: u32) -> Shown {
     match id {
-        9 | 10 => Shown::Percent,
+        2 => fixed(2, false, false),
+        3 | 37 | 38 => fixed(0, true, false),
+        4 | 39 | 40 => fixed(2, true, false),
+        9 => fixed(0, false, true),
+        10 => fixed(2, false, true),
         14..=17 | 27..=31 | 34..=36 | 50..=58 => Shown::Date,
         18..=21 | 32 | 33 | 45..=47 => Shown::Time,
         22 => Shown::DateTime,
@@ -60,14 +39,26 @@ const fn built_in(id: u32) -> Shown {
     }
 }
 
+pub const fn fixed(decimals: u8, grouping: bool, percent: bool) -> Shown {
+    Shown::Fixed { decimals, grouping, percent }
+}
+
 /// What a custom format code shows, from its first section: date and time
-/// tokens, outside quoted text, escapes and `[...]` (colors, locales;
-/// `[h]` is elapsed time).
+/// tokens, decimals, `,` grouping and `%`, outside quoted text, escapes and
+/// `[...]` (colors, locales; `[h]` is elapsed time). Scientific formats
+/// (`0.00E+00`) are shown as General.
 pub fn classify(code: &str) -> Shown {
     let (mut date, mut time, mut month, mut percent) = (false, false, false, false);
-    let mut chars = code.chars();
+    let (mut digits, mut point, mut decimals, mut grouping, mut scientific) =
+        (false, false, 0_u8, false, false);
+    let mut chars = code.chars().peekable();
     while let Some(ch) = chars.next() {
         match ch.to_ascii_lowercase() {
+            '0' | '#' | '?' if point => decimals = decimals.saturating_add(1),
+            '0' | '#' | '?' => digits = true,
+            '.' => point = true,
+            ',' if digits && !point => grouping = true,
+            'e' if matches!(chars.peek(), Some('+' | '-')) => scientific = true,
             ';' => break,
             '"' => {
                 chars.by_ref().find(|&ch| ch == '"');
@@ -90,8 +81,8 @@ pub fn classify(code: &str) -> Shown {
         (true, true) => Shown::DateTime,
         (true, false) => Shown::Date,
         (false, true) => Shown::Time,
-        (false, false) if percent => Shown::Percent,
-        (false, false) => Shown::General,
+        (false, false) if scientific || !(decimals > 0 || grouping || percent) => Shown::General,
+        (false, false) => Shown::Fixed { decimals, grouping, percent },
     }
 }
 
@@ -129,15 +120,48 @@ pub fn push_number(
             let _ =
                 write!(out, "{:02}:{:02}:{:02}", seconds / 3600, seconds / 60 % 60, seconds % 60);
         }
-        Shown::Percent => {
-            push_general(out, number * 100.0, scratch);
-            out.push('%');
+        Shown::Fixed { decimals, grouping, percent } => {
+            let number = if percent { number * 100.0 } else { number };
+            push_fixed(out, number, decimals, grouping, scratch);
+            if percent {
+                out.push('%');
+            }
         }
         _ => push_general(out, number, scratch),
     }
     Value::Number(number)
 }
 
+/// A number with `decimals` decimals, its thousands grouped with `,`,
+/// rounded half away from zero as Excel does (`12.5` shows `13`, `1.005`
+/// `1.01`): a few units in the last place toward the tie undo the binary
+/// error that makes `1.005` `1.00499...`, which Rust would round down, as it
+/// rounds an exact tie to even.
+fn push_fixed(out: &mut String, number: f64, decimals: u8, grouping: bool, scratch: &mut String) {
+    let number = (number.abs() * 4.0 * f64::EPSILON).mul_add(number.signum(), number);
+    scratch.clear();
+    // Writing to a String cannot fail.
+    let _ = write!(scratch, "{number:.*}", usize::from(decimals));
+    if !grouping {
+        out.push_str(scratch);
+        return;
+    }
+    let (sign, digits) =
+        scratch.strip_prefix('-').map_or(("", scratch.as_str()), |rest| ("-", rest));
+    let (whole, fraction) = digits.split_once('.').map_or((digits, None), |(w, f)| (w, Some(f)));
+    out.push_str(sign);
+    for (index, digit) in whole.char_indices() {
+        if index > 0 && (whole.len() - index).is_multiple_of(3) {
+            out.push(',');
+        }
+        out.push(digit);
+    }
+    if let Some(fraction) = fraction {
+        out.push('.');
+        out.push_str(fraction);
+    }
+}
+
 /// A number as Excel's General format shows it: 15 significant digits.
 pub fn push_general(out: &mut String, number: f64, scratch: &mut String) {
     #[expect(clippy::cast_possible_truncation, reason = "whole and under 1e15: exact in i64")]

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

@@ -0,0 +1,356 @@
+//! `.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,
+                    ..Sheet::default()
+                });
+                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 })
+}