imprimatur 0.1.0 → 0.3.0

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

@@ -0,0 +1,156 @@
+//! Workbook strings: BIFF8's Latin-1 or UTF-16, BIFF5's Windows-1252
+//! bytes, and BIFF8's shared string table, whose strings may be split
+//! across `CONTINUE` records.
+
+use crate::Result;
+use crate::pdf::metrics::WIN_ANSI_HIGH;
+use crate::read::Budget;
+
+/// How a workbook's strings are stored.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Encoding {
+    /// BIFF8: each string says whether it is Latin-1 or UTF-16.
+    Unicode,
+    /// BIFF5: bytes in the workbook's code page.
+    Windows1252,
+}
+
+/// A string with a 1-byte or 2-byte character count at `at`; `None` past
+/// the end.
+pub fn string(bytes: &[u8], at: usize, wide_count: bool, encoding: Encoding) -> Option<String> {
+    let (count, at) = if wide_count {
+        (usize::from(u16::from_le_bytes(bytes.get(at..at + 2)?.try_into().ok()?)), at + 2)
+    } else {
+        (usize::from(*bytes.get(at)?), at + 1)
+    };
+    if encoding == Encoding::Windows1252 {
+        let chars = bytes.get(at..at + count).or_else(|| bytes.get(at..))?;
+        return Some(chars.iter().map(|&byte| windows_1252(byte)).collect());
+    }
+    let high = bytes.get(at)? & 1 != 0;
+    let mut out = String::with_capacity(count);
+    let mut units = Vec::new();
+    let width = if high { 2 } else { 1 };
+    let chars = bytes.get(at + 1..at + 1 + count * width).or_else(|| bytes.get(at + 1..))?;
+    decode(chars, high, &mut units, &mut out);
+    flush(&mut units, &mut out);
+    Some(out)
+}
+
+/// A Windows-1252 byte: Latin-1, but for the typographic characters at
+/// 0x80 to 0x9F.
+fn windows_1252(byte: u8) -> char {
+    match byte {
+        0x80..=0x9F => WIN_ANSI_HIGH[usize::from(byte - 0x80)].unwrap_or_else(|| char::from(byte)),
+        _ => char::from(byte),
+    }
+}
+
+/// Appends characters: Latin-1 bytes at once, UTF-16 units to `units`
+/// (a surrogate pair may span two pieces), decoded by [`flush`].
+fn decode(chars: &[u8], high: bool, units: &mut Vec<u16>, out: &mut String) {
+    if high {
+        units.extend(chars.as_chunks::<2>().0.iter().map(|unit| u16::from_le_bytes(*unit)));
+    } else {
+        flush(units, out);
+        out.extend(chars.iter().map(|&byte| char::from(byte)));
+    }
+}
+
+fn flush(units: &mut Vec<u16>, out: &mut String) {
+    out.extend(
+        char::decode_utf16(units.drain(..)).map(|ch| ch.unwrap_or(char::REPLACEMENT_CHARACTER)),
+    );
+}
+
+/// The shared string table (`SST`): its record's body, then each
+/// `CONTINUE` body after it.
+pub fn shared(parts: &[&[u8]], budget: &Budget<'_>) -> Result<Vec<String>> {
+    let mut reader = Cursor { parts, part: 0, at: 8 };
+    let Some(unique) = parts.first().and_then(|first| first.get(4..8)) else {
+        return Ok(Vec::new());
+    };
+    let unique = u32::from_le_bytes(unique.try_into().unwrap_or([0; 4])) as usize;
+    let mut strings = Vec::with_capacity(unique.min(1 << 20));
+    let mut units = Vec::new();
+    while strings.len() < unique {
+        budget.tick()?;
+        let Some(string) = reader.string(&mut units) else { break };
+        strings.push(string);
+    }
+    Ok(strings)
+}
+
+/// A cursor over record bodies read as one stream.
+struct Cursor<'p, 'a> {
+    parts: &'p [&'a [u8]],
+    part: usize,
+    at: usize,
+}
+
+impl Cursor<'_, '_> {
+    fn byte(&mut self) -> Option<u8> {
+        while self.at >= self.parts.get(self.part)?.len() {
+            self.part += 1;
+            self.at = 0;
+        }
+        let byte = self.parts[self.part][self.at];
+        self.at += 1;
+        Some(byte)
+    }
+
+    fn u16(&mut self) -> Option<u16> {
+        Some(u16::from_le_bytes([self.byte()?, self.byte()?]))
+    }
+
+    fn u32(&mut self) -> Option<u32> {
+        Some(u32::from_le_bytes([self.byte()?, self.byte()?, self.byte()?, self.byte()?]))
+    }
+
+    fn skip(&mut self, mut count: usize) -> Option<()> {
+        while count > 0 {
+            let left = self.parts.get(self.part)?.len().saturating_sub(self.at);
+            if left == 0 {
+                self.part += 1;
+                self.at = 0;
+                continue;
+            }
+            let step = left.min(count);
+            self.at += step;
+            count -= step;
+        }
+        Some(())
+    }
+
+    /// An `XLUnicodeRichExtendedString`: where its characters cross into the
+    /// next record, that record starts with their width again.
+    fn string(&mut self, units: &mut Vec<u16>) -> Option<String> {
+        let count = usize::from(self.u16()?);
+        let flags = self.byte()?;
+        let runs = if flags & 0x08 != 0 { usize::from(self.u16()?) } else { 0 };
+        let extended = if flags & 0x04 != 0 { self.u32()? as usize } else { 0 };
+        let mut high = flags & 1 != 0;
+        let mut out = String::with_capacity(count);
+        let mut left = count;
+        while left > 0 {
+            let part = self.parts.get(self.part)?;
+            if self.at >= part.len() {
+                self.part += 1;
+                self.at = 1;
+                high = self.parts.get(self.part)?.first()? & 1 != 0;
+                continue;
+            }
+            let width = if high { 2 } else { 1 };
+            let take = ((part.len() - self.at) / width).min(left);
+            if take == 0 {
+                return None;
+            }
+            decode(&part[self.at..self.at + take * width], high, units, &mut out);
+            self.at += take * width;
+            left -= take;
+        }
+        flush(units, &mut out);
+        self.skip(runs * 4 + extended)?;
+        Some(out)
+    }
+}

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

@@ -0,0 +1,342 @@
+//! Legacy Excel workbooks (`.xls`): BIFF8 (Excel 97 to 2003) and BIFF5
+//! (Excel 5.0 and 95), the `Workbook` or `Book` stream of a compound file,
+//! a sequence of records. Cell values come from the cells' records (shared
+//! or inline strings, numbers, RK numbers, booleans, errors, formula
+//! results) and show through their number formats as in XLSX. Comments,
+//! charts and macro sheets are left out.
+
+mod strings;
+#[cfg(test)]
+mod tests;
+
+use super::Budget;
+use super::content::{Grid, Sheet, Value};
+use super::numbers::{Shown, built_in, classify, push_number};
+use super::ole::Ole;
+use crate::{Error, Result};
+use strings::Encoding;
+
+const BOF: u16 = 0x0809;
+const EOF: u16 = 0x000A;
+const CONTINUE: u16 = 0x003C;
+/// BIFF8, the version of Excel 97 and later; BIFF5, of Excel 5.0 and 95.
+const BIFF8: u16 = 0x0600;
+const BIFF5: u16 = 0x0500;
+
+fn malformed(reason: &str) -> Error {
+    Error::malformed("XLS", reason)
+}
+
+/// The workbook's sheets, in order, its chart and macro sheets left out.
+///
+/// # Errors
+/// [`Error::UnsupportedDocument`] for a compound file that is no workbook,
+/// one older than Excel 5.0 or in a code page other than Western European,
+/// [`Error::PasswordRequired`] for an encrypted one, [`Error::Malformed`]
+/// for a damaged one.
+pub fn content(ole: &Ole<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
+    let stream = match ole.stream("Workbook", budget)? {
+        Some(stream) => stream,
+        None => ole.stream("Book", budget)?.ok_or_else(|| {
+            Error::UnsupportedDocument(
+                "an Office file that is not a workbook (a legacy .doc?)".to_owned(),
+            )
+        })?,
+    };
+    let book = globals(&stream, budget)?;
+    let mut scratch = String::new();
+    let mut sheets = Vec::with_capacity(book.sheets.len());
+    for listed in &book.sheets {
+        let cells = cells(&stream, listed.offset, &book, &mut scratch, budget)?;
+        sheets.push(Sheet {
+            name: listed.name.clone(),
+            hidden: listed.hidden,
+            cells,
+            ..Sheet::default()
+        });
+    }
+    Ok(sheets)
+}
+
+/// One record: its type and its body, `CONTINUE` records left apart.
+fn records(data: &[u8], mut at: usize) -> impl Iterator<Item = (u16, &[u8])> {
+    std::iter::from_fn(move || {
+        let header = data.get(at..at + 4)?;
+        let kind = u16::from_le_bytes([header[0], header[1]]);
+        let length = usize::from(u16::from_le_bytes([header[2], header[3]]));
+        let body = data.get(at + 4..at + 4 + length)?;
+        at += 4 + length;
+        Some((kind, body))
+    })
+}
+
+fn u16_at(body: &[u8], at: usize) -> Option<u16> {
+    Some(u16::from_le_bytes(body.get(at..at + 2)?.try_into().ok()?))
+}
+
+fn u32_at(body: &[u8], at: usize) -> Option<u32> {
+    Some(u32::from_le_bytes(body.get(at..at + 4)?.try_into().ok()?))
+}
+
+/// A worksheet the workbook lists.
+struct Listed {
+    name: String,
+    hidden: bool,
+    offset: usize,
+}
+
+/// What the workbook's global records say: its sheets, its shared strings,
+/// how each cell format shows numbers, and its date system.
+struct Book {
+    sheets: Vec<Listed>,
+    strings: Vec<String>,
+    shown: Vec<Shown>,
+    date1904: bool,
+    encoding: Encoding,
+}
+
+impl Book {
+    /// How the cell format `xf` shows numbers.
+    fn shown(&self, xf: Option<u16>) -> Shown {
+        xf.and_then(|xf| self.shown.get(usize::from(xf))).copied().unwrap_or(Shown::General)
+    }
+
+    /// A string in the workbook's encoding.
+    fn string(&self, bytes: &[u8], at: usize, wide_count: bool) -> String {
+        strings::string(bytes, at, wide_count, self.encoding).unwrap_or_default()
+    }
+}
+
+fn globals(stream: &[u8], budget: &Budget<'_>) -> Result<Book> {
+    let mut all = records(stream, 0).peekable();
+    let encoding = match all.next() {
+        Some((BOF, body)) if u16_at(body, 0) == Some(BIFF8) => Encoding::Unicode,
+        Some((BOF, body)) if u16_at(body, 0) == Some(BIFF5) => Encoding::Windows1252,
+        Some((BOF, _)) => {
+            return Err(Error::UnsupportedDocument(
+                "a workbook older than Excel 5.0 (.xls); save it as .xlsx".into(),
+            ));
+        }
+        _ => return Err(malformed("the workbook stream does not start with BOF")),
+    };
+    let mut book = Book {
+        sheets: Vec::new(),
+        strings: Vec::new(),
+        shown: Vec::new(),
+        date1904: false,
+        encoding,
+    };
+    let mut formats: Vec<(u16, Shown)> = Vec::new();
+    let mut format_ids = Vec::new();
+    while let Some((kind, body)) = all.next() {
+        budget.tick()?;
+        match kind {
+            EOF => break,
+            // FILEPASS: the rest is encrypted.
+            0x002F => return Err(Error::PasswordRequired),
+            0x0022 => book.date1904 = u16_at(body, 0) == Some(1),
+            // CODEPAGE: BIFF5's strings are bytes of it; Western European
+            // (or ASCII) only, rather than misread text.
+            0x0042 if encoding == Encoding::Windows1252 => {
+                let page = u16_at(body, 0).unwrap_or(1252);
+                if !matches!(page, 1252 | 367 | 0x8001) {
+                    return Err(Error::UnsupportedDocument(format!(
+                        "an Excel 5.0/95 workbook in code page {page} (.xls); save it as .xlsx"
+                    )));
+                }
+            }
+            0x041E => {
+                if let Some(id) = u16_at(body, 0) {
+                    let code = book.string(body, 2, encoding == Encoding::Unicode);
+                    formats.push((id, classify(&code)));
+                }
+            }
+            0x00E0 => format_ids.push(u16_at(body, 2).unwrap_or(0)),
+            0x0085 => {
+                let (Some(offset), Some(&state), Some(&kind)) =
+                    (u32_at(body, 0), body.get(4), body.get(5))
+                else {
+                    continue;
+                };
+                // Worksheets only: macro sheets, charts and modules hold no table.
+                if kind == 0 {
+                    let name = book.string(body, 6, false);
+                    book.sheets.push(Listed {
+                        name,
+                        hidden: state & 3 != 0,
+                        offset: offset as usize,
+                    });
+                }
+            }
+            0x00FC => {
+                let mut parts = vec![body];
+                while let Some(&(CONTINUE, more)) = all.peek() {
+                    parts.push(more);
+                    all.next();
+                }
+                book.strings = strings::shared(&parts, budget)?;
+            }
+            _ => {}
+        }
+    }
+    book.shown = format_ids
+        .iter()
+        .map(|&id| {
+            formats
+                .iter()
+                .find(|&&(custom, _)| custom == id)
+                .map_or_else(|| built_in(u32::from(id)), |&(_, shown)| shown)
+        })
+        .collect();
+    Ok(book)
+}
+
+/// An `RK` number: a 30-bit integer or the high bits of a double, either
+/// perhaps divided by 100.
+fn rk(value: u32) -> f64 {
+    #[expect(clippy::cast_possible_wrap, reason = "the bits are a signed integer")]
+    let number = if value & 2 != 0 {
+        f64::from((value as i32) >> 2)
+    } else {
+        f64::from_bits(u64::from(value & 0xFFFF_FFFC) << 32)
+    };
+    if value & 1 != 0 { number / 100.0 } else { number }
+}
+
+/// An error code as Excel shows it.
+const fn error_text(code: u8) -> &'static str {
+    match code {
+        0x00 => "#NULL!",
+        0x07 => "#DIV/0!",
+        0x0F => "#VALUE!",
+        0x17 => "#REF!",
+        0x1D => "#NAME?",
+        0x24 => "#NUM!",
+        _ => "#N/A",
+    }
+}
+
+/// A worksheet's cells, from its BOF at `offset` to its EOF.
+fn cells(
+    stream: &[u8],
+    offset: usize,
+    book: &Book,
+    scratch: &mut String,
+    budget: &Budget<'_>,
+) -> Result<Grid> {
+    let mut grid = Grid::default();
+    let mut all = records(stream, offset);
+    if !matches!(all.next(), Some((BOF, _))) {
+        return Err(malformed("a sheet that does not start with BOF"));
+    }
+    // A formula's string result follows it in a STRING record.
+    let mut pending: Option<(u32, u32)> = None;
+    for (kind, body) in all {
+        budget.tick()?;
+        let (Some(row), Some(column)) = (u16_at(body, 0), u16_at(body, 2)) else {
+            if kind == EOF {
+                break;
+            }
+            continue;
+        };
+        let (row, column) = (u32::from(row), u32::from(column));
+        // NUMBER, RK and numeric FORMULA results, written after the match.
+        let number = match kind {
+            EOF => break,
+            // LABELSST
+            0x00FD => {
+                let text = u32_at(body, 6).and_then(|index| book.strings.get(index as usize));
+                text_cell(&mut grid, (row, column), text.map_or("", String::as_str));
+                None
+            }
+            // LABEL, RSTRING
+            0x0204 | 0x00D6 => {
+                text_cell(&mut grid, (row, column), &book.string(body, 6, true));
+                None
+            }
+            0x0203 => {
+                body.get(6..14).map(|bits| f64::from_le_bytes(bits.try_into().unwrap_or([0; 8])))
+            }
+            0x027E => u32_at(body, 6).map(rk),
+            // MULRK: (format, RK) pairs from the first column on.
+            0x00BD => {
+                let pairs = body.get(4..body.len().saturating_sub(2)).unwrap_or_default();
+                for (index, pair) in (0..).zip(pairs.as_chunks::<6>().0) {
+                    let value = rk(u32::from_le_bytes([pair[2], pair[3], pair[4], pair[5]]));
+                    let shown = book.shown(Some(u16::from_le_bytes([pair[0], pair[1]])));
+                    number_cell(
+                        &mut grid,
+                        (row, column + index),
+                        value,
+                        shown,
+                        book.date1904,
+                        scratch,
+                    );
+                }
+                None
+            }
+            // BOOLERR
+            0x0205 => {
+                let (Some(&value), Some(&error)) = (body.get(6), body.get(7)) else { continue };
+                flag_cell(&mut grid, (row, column), value, error != 0);
+                None
+            }
+            // FORMULA: its cached result.
+            0x0006 => {
+                let Some(result) = body.get(6..14) else { continue };
+                if result[6..8] == [0xFF, 0xFF] {
+                    match result[0] {
+                        0 => pending = Some((row, column)),
+                        1 => flag_cell(&mut grid, (row, column), result[2], false),
+                        2 => flag_cell(&mut grid, (row, column), result[2], true),
+                        _ => {}
+                    }
+                    None
+                } else {
+                    Some(f64::from_le_bytes(result.try_into().unwrap_or([0; 8])))
+                }
+            }
+            // STRING: the string result of the formula before it.
+            0x0207 => {
+                if let Some(at) = pending.take() {
+                    text_cell(&mut grid, at, &book.string(body, 0, true));
+                }
+                None
+            }
+            _ => None,
+        };
+        if let Some(number) = number {
+            let shown = book.shown(u16_at(body, 4));
+            number_cell(&mut grid, (row, column), number, shown, book.date1904, scratch);
+        }
+    }
+    Ok(grid.finish())
+}
+
+fn number_cell(
+    grid: &mut Grid,
+    (row, column): (u32, u32),
+    number: f64,
+    shown: Shown,
+    date1904: bool,
+    scratch: &mut String,
+) {
+    let value = push_number(grid.buffer(), number, shown, date1904, scratch);
+    grid.end_cell(row, column, value);
+}
+
+fn text_cell(grid: &mut Grid, (row, column): (u32, u32), text: &str) {
+    grid.buffer().push_str(text);
+    grid.end_cell(row, column, Value::Text);
+}
+
+/// A boolean, or an error code.
+fn flag_cell(grid: &mut Grid, (row, column): (u32, u32), value: u8, error: bool) {
+    let (text, value) = match (error, value) {
+        (true, code) => (error_text(code), Value::Error),
+        (false, 0) => ("FALSE", Value::Bool(false)),
+        (false, _) => ("TRUE", Value::Bool(true)),
+    };
+    grid.buffer().push_str(text);
+    grid.end_cell(row, column, value);
+}

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

@@ -0,0 +1,155 @@
+//! A workbook's cell formats (`styles.xml`): for each, how it shows numbers
+//! and how it looks.
+
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use crate::Result;
+use crate::read::Budget;
+use crate::read::content::Look;
+use crate::read::numbers::{Shown, built_in, classify};
+use crate::xml::reader::{Event, XmlReader};
+
+/// The cell formats (`cellXfs`), by index.
+#[derive(Default)]
+pub struct Formats {
+    pub shown: Vec<Shown>,
+    pub looks: Vec<Arc<Look>>,
+}
+
+/// Where in `styles.xml` the reader is.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Section {
+    Other,
+    Fonts,
+    Fills,
+    Borders,
+    CellFormats,
+}
+
+/// A font, fill and border by their index, before the formats pick them.
+#[derive(Default)]
+struct Parts {
+    codes: Vec<(u32, String)>,
+    fonts: Vec<Look>,
+    fills: Vec<Option<String>>,
+    borders: Vec<Option<String>>,
+}
+
+pub fn formats(text: &str, budget: &Budget<'_>) -> Result<Formats> {
+    let mut xml = XmlReader::new(text, budget.max_depth());
+    let (mut parts, mut section, mut side) = (Parts::default(), Section::Other, "");
+    let mut formats = Formats { shown: Vec::new(), looks: Vec::new() };
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match (section, tag.name()) {
+                (_, "numFmt") => {
+                    if let (Some(id), Some(code)) = (tag.attr("numFmtId"), tag.attr("formatCode")) {
+                        parts.codes.push((id.parse().unwrap_or(u32::MAX), code.into_owned()));
+                    }
+                }
+                (_, "fonts") => section = Section::Fonts,
+                (_, "fills") => section = Section::Fills,
+                (_, "borders") => section = Section::Borders,
+                (_, "cellXfs") => section = Section::CellFormats,
+                (Section::Fonts, "font") => parts.fonts.push(Look::default()),
+                (Section::Fonts, name) => font_part(&mut parts.fonts, name, tag),
+                (Section::Fills, "fill") => parts.fills.push(None),
+                (Section::Fills, "fgColor") => {
+                    if let Some(fill) = parts.fills.last_mut() {
+                        *fill = tag.attr("rgb").map(|rgb| rgb.to_uppercase());
+                    }
+                }
+                (Section::Borders, "border") => parts.borders.push(None),
+                (Section::Borders, name) if side.is_empty() => {
+                    side = name;
+                    if name == "left"
+                        && let Some(border) = parts.borders.last_mut()
+                    {
+                        *border = tag.attr("style").map(Cow::into_owned);
+                    }
+                }
+                (Section::CellFormats, "xf") => {
+                    let id = |name| tag.parse::<usize>(name);
+                    let number = tag.parse("numFmtId").unwrap_or(0);
+                    let custom = parts.codes.iter().find(|(id, _)| *id == number);
+                    let shown = custom.map_or_else(|| built_in(number), |(_, code)| classify(code));
+                    let font = parts.fonts.get(id("fontId").unwrap_or(0));
+                    let mut look = font.cloned().unwrap_or_default();
+                    look.fill = parts.fills.get(id("fillId").unwrap_or(0)).cloned().flatten();
+                    look.border = parts.borders.get(id("borderId").unwrap_or(0)).cloned().flatten();
+                    look.number_format = custom.map_or_else(
+                        || built_in_code(number).map_or_else(|| number.to_string(), str::to_owned),
+                        |(_, code)| code.clone(),
+                    );
+                    formats.shown.push(shown);
+                    formats.looks.push(Arc::new(look));
+                }
+                (Section::CellFormats, "alignment") => {
+                    if let Some(look) = formats.looks.last_mut().map(Arc::make_mut) {
+                        look.align = tag.attr("horizontal").map(Cow::into_owned);
+                        look.valign = tag.attr("vertical").map(Cow::into_owned);
+                        look.wrap = tag.on("wrapText");
+                    }
+                }
+                _ => {}
+            },
+            Event::End(name) => match name {
+                "fonts" | "fills" | "borders" | "cellXfs" => section = Section::Other,
+                _ if name == side => side = "",
+                _ => {}
+            },
+            Event::Text(_) => {}
+        }
+    }
+    Ok(formats)
+}
+
+/// A property of the font being read.
+fn font_part(fonts: &mut [Look], name: &str, tag: crate::xml::reader::Tag<'_>) {
+    let Some(font) = fonts.last_mut() else { return };
+    match name {
+        "b" => font.bold = tag.flag("val"),
+        "i" => font.italic = tag.flag("val"),
+        "u" => font.underline = tag.attr("val").is_none_or(|style| style != "none"),
+        "sz" => font.size = tag.parse("val").unwrap_or(0.0),
+        "name" => font.font = tag.attr("val").map(Cow::into_owned).unwrap_or_default(),
+        "color" => font.color = tag.attr("rgb").map(|rgb| rgb.to_uppercase()),
+        _ => {}
+    }
+}
+
+/// The codes of Excel's built-in number formats (ECMA-376 Part 1, 18.8.30).
+const fn built_in_code(id: u32) -> Option<&'static str> {
+    Some(match id {
+        0 => "General",
+        1 => "0",
+        2 => "0.00",
+        3 => "#,##0",
+        4 => "#,##0.00",
+        9 => "0%",
+        10 => "0.00%",
+        11 => "0.00E+00",
+        12 => "# ?/?",
+        13 => "# ??/??",
+        14 => "mm-dd-yy",
+        15 => "d-mmm-yy",
+        16 => "d-mmm",
+        17 => "mmm-yy",
+        18 => "h:mm AM/PM",
+        19 => "h:mm:ss AM/PM",
+        20 => "h:mm",
+        21 => "h:mm:ss",
+        22 => "m/d/yy h:mm",
+        37 => "#,##0 ;(#,##0)",
+        38 => "#,##0 ;[Red](#,##0)",
+        39 => "#,##0.00;(#,##0.00)",
+        40 => "#,##0.00;[Red](#,##0.00)",
+        45 => "mm:ss",
+        46 => "[h]:mm:ss",
+        47 => "mmss.0",
+        48 => "##0.0E+0",
+        49 => "@",
+        _ => return None,
+    })
+}