imprimatur 0.1.0

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

@@ -0,0 +1,118 @@
+//! What a DOCX's parts besides the body say about its paragraphs: heading
+//! levels and lists from `styles.xml`, list kinds from `numbering.xml`.
+
+use crate::Result;
+use crate::read::Budget;
+use crate::xml::reader::{Event, Tag, XmlReader};
+
+/// What a paragraph style contributes.
+#[derive(Debug, Clone, Default)]
+pub struct Style {
+    pub id: String,
+    pub based_on: Option<String>,
+    pub heading: Option<u8>,
+    pub list: Option<(String, u8)>,
+}
+
+/// A `w:val` attribute, owned.
+pub fn value(tag: &Tag<'_>) -> Option<String> {
+    tag.attr("val").map(std::borrow::Cow::into_owned)
+}
+
+/// A `w:val` list level (`w:ilvl`), 0 to 8.
+pub fn level(tag: &Tag<'_>) -> Option<u8> {
+    tag.attr("val").and_then(|level| level.parse::<u8>().ok())
+}
+
+/// `w:outlineLvl`: 0 is a level-1 heading; 9 is body text.
+pub fn outline(tag: &Tag<'_>) -> Option<u8> {
+    level(tag).filter(|&level| level < 9).map(|level| level + 1)
+}
+
+pub fn read_styles(text: &str, budget: &Budget<'_>) -> Result<Vec<Style>> {
+    let mut xml = XmlReader::new(text, budget.max_depth());
+    let (mut styles, mut style): (Vec<Style>, Option<Style>) = (Vec::new(), None);
+    let (mut list_level, mut numbering) = (None, None);
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match (tag.name(), style.as_mut()) {
+                ("style", _) => {
+                    let paragraph = tag.attr("type").is_none_or(|kind| kind == "paragraph");
+                    style = paragraph.then(|| Style {
+                        id: tag.attr("styleId").unwrap_or_default().into_owned(),
+                        ..Style::default()
+                    });
+                    (list_level, numbering) = (None, None);
+                }
+                ("name", Some(style)) => {
+                    let name = tag.attr("val").unwrap_or_default().to_ascii_lowercase();
+                    style.heading = style.heading.or_else(|| match name.as_str() {
+                        "title" => Some(1),
+                        name => name
+                            .strip_prefix("heading ")
+                            .and_then(|level| level.trim().parse().ok()),
+                    });
+                }
+                ("basedOn", Some(style)) => {
+                    style.based_on = value(&tag);
+                }
+                ("outlineLvl", Some(style)) => {
+                    style.heading = style.heading.or_else(|| outline(&tag));
+                }
+                ("ilvl", Some(_)) => {
+                    list_level = self::level(&tag);
+                }
+                ("numId", Some(_)) => numbering = value(&tag),
+                _ => {}
+            },
+            Event::End("style") => {
+                if let Some(mut done) = style.take() {
+                    done.list = numbering.take().map(|id| (id, list_level.unwrap_or(0)));
+                    styles.push(done);
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(styles)
+}
+
+/// Which list levels are numbered rather than bulleted, by numbering id.
+pub fn read_numbering(text: &str, budget: &Budget<'_>) -> Result<Vec<(String, Vec<bool>)>> {
+    let mut xml = XmlReader::new(text, budget.max_depth());
+    let mut abstracts: Vec<(String, Vec<bool>)> = Vec::new();
+    let mut numbers: Vec<(String, String)> = Vec::new();
+    let mut current_number: Option<String> = None;
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "abstractNum" => abstracts
+                    .push((tag.attr("abstractNumId").unwrap_or_default().into_owned(), Vec::new())),
+                "numFmt" if current_number.is_none() => {
+                    if let Some((_, levels)) = abstracts.last_mut() {
+                        let format = tag.attr("val").unwrap_or_default();
+                        levels.push(!matches!(&*format, "bullet" | "none"));
+                    }
+                }
+                "num" => current_number = tag.attr("numId").map(std::borrow::Cow::into_owned),
+                "abstractNumId" => {
+                    if let (Some(number), Some(id)) = (current_number.clone(), tag.attr("val")) {
+                        numbers.push((number, id.into_owned()));
+                    }
+                }
+                _ => {}
+            },
+            Event::End("num") => current_number = None,
+            _ => {}
+        }
+    }
+    Ok(numbers
+        .into_iter()
+        .filter_map(|(number, id)| {
+            abstracts
+                .iter()
+                .find(|(abstract_id, _)| *abstract_id == id)
+                .map(|(_, levels)| (number, levels.clone()))
+        })
+        .collect())
+}

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

@@ -0,0 +1,336 @@
+//! DOCX: the body as blocks. Headings from paragraph styles (and outline
+//! levels), lists from numbering, bold, italic and links from runs, tables,
+//! text boxes after their paragraph. Deleted text, field codes and the
+//! fallback copy of alternate content are left out.
+
+mod styles;
+#[cfg(test)]
+mod tests;
+
+use super::Budget;
+use super::content::{Block, Grid, Mark, Text};
+use super::markdown::cell_text;
+use super::package::Package;
+use crate::Result;
+use crate::xml::reader::{Event, XmlReader};
+use styles::{Style, outline, read_numbering, read_styles, value};
+
+/// Run formatting, and the link a run belongs to.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+struct Look {
+    bold: bool,
+    italic: bool,
+    link: Option<usize>,
+}
+
+impl Look {
+    const fn is_plain(self) -> bool {
+        !self.bold && !self.italic && self.link.is_none()
+    }
+}
+
+/// A paragraph's text, with the look of each stretch of it.
+#[derive(Default)]
+struct Inline {
+    text: String,
+    looks: Vec<(std::ops::Range<usize>, Look)>,
+}
+
+impl Inline {
+    fn push(&mut self, text: &str, look: Look) {
+        let start = self.text.len();
+        self.text.push_str(text);
+        match self.looks.last_mut() {
+            Some((range, last)) if *last == look && range.end == start => {
+                range.end = self.text.len();
+            }
+            _ => self.looks.push((start..self.text.len(), look)),
+        }
+    }
+
+    fn clear(&mut self) {
+        self.text.clear();
+        self.looks.clear();
+    }
+
+    /// The text and its styled stretches, taken: the paragraph is done. A
+    /// run's spaces at the edges of a stretch are left out of it.
+    fn take(&mut self, links: &[String], styled: bool) -> Text {
+        let marks = if styled {
+            self.looks
+                .iter()
+                .filter(|(_, look)| !look.is_plain())
+                .filter_map(|(range, look)| {
+                    let stretch = &self.text[range.clone()];
+                    let start = range.start + (stretch.len() - stretch.trim_start().len());
+                    let end = range.end - (stretch.len() - stretch.trim_end().len());
+                    (start < end).then(|| Mark {
+                        range: start..end,
+                        bold: look.bold,
+                        italic: look.italic,
+                        link: look.link.and_then(|index| links.get(index)).cloned(),
+                    })
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        self.looks.clear();
+        Text { text: std::mem::take(&mut self.text), marks }
+    }
+}
+
+/// What the document's parts say about its paragraphs.
+struct Context<'a> {
+    budget: &'a Budget<'a>,
+    styles: Vec<Style>,
+    /// Ordered or not, by numbering id and level.
+    numbering: Vec<(String, Vec<bool>)>,
+    links: Vec<String>,
+    link_ids: Vec<String>,
+}
+
+impl Context<'_> {
+    /// A style's heading level and list, following `basedOn` a few steps.
+    fn style(&self, id: &str) -> (Option<u8>, Option<(String, u8)>) {
+        let (mut heading, mut list, mut next) = (None, None, Some(id));
+        for _ in 0..8 {
+            let Some(style) = next.and_then(|id| self.styles.iter().find(|style| style.id == id))
+            else {
+                break;
+            };
+            heading = heading.or(style.heading);
+            list = list.or_else(|| style.list.clone());
+            next = style.based_on.as_deref();
+        }
+        (heading, list)
+    }
+
+    fn ordered(&self, id: &str, level: u8) -> bool {
+        self.numbering
+            .iter()
+            .find(|(numbering, _)| numbering == id)
+            .and_then(|(_, levels)| levels.get(usize::from(level)).copied())
+            .unwrap_or(false)
+    }
+}
+
+/// The paragraph being read.
+#[derive(Default)]
+struct Paragraph {
+    style: Option<String>,
+    list: Option<(String, u8)>,
+    outline: Option<u8>,
+    inline: Inline,
+    /// Text boxes anchored in it, which follow it.
+    boxes: Vec<Block>,
+}
+
+pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Block>> {
+    let main = package.main();
+    let text = package.main_text()?;
+    let relationships = package.relationships(main)?;
+    let (mut links, mut link_ids) = (Vec::new(), Vec::new());
+    for relationship in relationships.iter().filter(|r| r.kind == "hyperlink" && r.external) {
+        link_ids.push(relationship.id.clone());
+        links.push(relationship.target.clone());
+    }
+    let styles =
+        package.parse_related(&relationships, "styles", |text| read_styles(text, budget))?;
+    let numbering =
+        package.parse_related(&relationships, "numbering", |text| read_numbering(text, budget))?;
+    let context = Context { budget, styles, numbering, links, link_ids };
+    let mut xml = XmlReader::new(&text, budget.max_depth());
+    let mut out = Vec::new();
+    while let Some(event) = xml.next()? {
+        if let Event::Start(tag) = event
+            && tag.name() == "body"
+        {
+            blocks(&mut xml, &context, &mut out, "body")?;
+            break;
+        }
+    }
+    Ok(out)
+}
+
+/// Block content up to the end of `until`: paragraphs, tables, and the
+/// containers around them. Returns the grid columns a table cell spans.
+fn blocks(
+    xml: &mut XmlReader<'_>,
+    context: &Context<'_>,
+    out: &mut Vec<Block>,
+    until: &str,
+) -> Result<u32> {
+    let mut span = 1;
+    let mut paragraph = Paragraph::default();
+    while let Some(event) = xml.next()? {
+        context.budget.tick()?;
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "p" => {
+                    paragraph.inline.clear();
+                    (paragraph.style, paragraph.list, paragraph.outline) = (None, None, None);
+                    read_paragraph(xml, context, &mut paragraph)?;
+                    push_paragraph(out, &mut paragraph, context);
+                }
+                "tbl" => {
+                    let grid = read_table(xml, context)?;
+                    if !grid.is_empty() {
+                        out.push(Block::Table(grid));
+                    }
+                }
+                "gridSpan" => {
+                    span = tag.attr("val").and_then(|span| span.parse().ok()).unwrap_or(1).max(1);
+                }
+                "sdtPr" | "sectPr" | "Fallback" | "del" | "moveFrom" => xml.skip()?,
+                _ => {}
+            },
+            Event::End(name) if name == until => return Ok(span),
+            _ => {}
+        }
+    }
+    Ok(span)
+}
+
+fn read_paragraph(
+    xml: &mut XmlReader<'_>,
+    context: &Context<'_>,
+    paragraph: &mut Paragraph,
+) -> Result<()> {
+    let mut link = None;
+    while let Some(event) = xml.next()? {
+        context.budget.tick()?;
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "pPr" => read_properties(xml, paragraph)?,
+                "r" => read_run(xml, context, paragraph, link)?,
+                "hyperlink" => {
+                    link = tag
+                        .attr("id")
+                        .and_then(|id| context.link_ids.iter().position(|known| *known == id));
+                }
+                "del" | "moveFrom" | "Fallback" | "rPr" | "sdtPr" => xml.skip()?,
+                _ => {}
+            },
+            Event::End("hyperlink") => link = None,
+            Event::End("p") => return Ok(()),
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+fn read_properties(xml: &mut XmlReader<'_>, paragraph: &mut Paragraph) -> Result<()> {
+    let (mut level, mut numbering) = (None, None);
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "pStyle" => paragraph.style = value(&tag),
+                "ilvl" => level = styles::level(&tag),
+                "numId" => numbering = value(&tag),
+                "outlineLvl" => paragraph.outline = outline(&tag),
+                "rPr" | "pPrChange" | "sectPr" => xml.skip()?,
+                _ => {}
+            },
+            Event::End("pPr") => break,
+            _ => {}
+        }
+    }
+    paragraph.list = numbering.map(|id| (id, level.unwrap_or(0)));
+    Ok(())
+}
+
+fn read_run(
+    xml: &mut XmlReader<'_>,
+    context: &Context<'_>,
+    paragraph: &mut Paragraph,
+    link: Option<usize>,
+) -> Result<()> {
+    let mut look = Look { link, ..Look::default() };
+    let mut in_text = false;
+    while let Some(event) = xml.next()? {
+        context.budget.tick()?;
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "rPr" => read_run_properties(xml, &mut look)?,
+                "t" => in_text = true,
+                "tab" | "ptab" => paragraph.inline.push(" ", look),
+                "br" | "cr" => paragraph.inline.push("\n", look),
+                "noBreakHyphen" => paragraph.inline.push("-", look),
+                "txbxContent" => {
+                    blocks(xml, context, &mut paragraph.boxes, "txbxContent")?;
+                }
+                "delText" | "instrText" | "delInstrText" | "Fallback" => xml.skip()?,
+                _ => {}
+            },
+            Event::Text(text) if in_text => paragraph.inline.push(&text, look),
+            Event::End("t") => in_text = false,
+            Event::End("r") => return Ok(()),
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+fn read_run_properties(xml: &mut XmlReader<'_>, look: &mut Look) -> Result<()> {
+    while let Some(event) = xml.next()? {
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "b" => look.bold = tag.flag("val"),
+                "i" => look.italic = tag.flag("val"),
+                "rPrChange" => xml.skip()?,
+                _ => {}
+            },
+            Event::End("rPr") => return Ok(()),
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+fn read_table(xml: &mut XmlReader<'_>, context: &Context<'_>) -> Result<Grid> {
+    let mut grid = Grid::default();
+    let (mut row, mut column) = (0_u32, 0_u32);
+    let mut cell = Vec::new();
+    while let Some(event) = xml.next()? {
+        context.budget.tick()?;
+        match event {
+            Event::Start(tag) => match tag.name() {
+                "tr" => column = 0,
+                "tc" => {
+                    cell.clear();
+                    let span = blocks(xml, context, &mut cell, "tc")?;
+                    cell_text(&cell, grid.buffer());
+                    grid.end_cell(row, column, super::content::Value::Text);
+                    column += span;
+                }
+                "tblPr" | "tblGrid" | "trPr" => xml.skip()?,
+                _ => {}
+            },
+            Event::End("tr") => row += 1,
+            Event::End("tbl") => return Ok(grid.finish()),
+            _ => {}
+        }
+    }
+    Ok(grid.finish())
+}
+
+/// The paragraph as a block, unless it has no text; then the blocks of its
+/// text boxes.
+fn push_paragraph(out: &mut Vec<Block>, paragraph: &mut Paragraph, context: &Context<'_>) {
+    let (styled_heading, styled_list) =
+        paragraph.style.as_deref().map_or((None, None), |style| context.style(style));
+    let heading = paragraph.outline.or(styled_heading);
+    let list = paragraph.list.clone().or(styled_list).filter(|(id, _)| id != "0");
+    if !paragraph.inline.text.trim().is_empty() {
+        out.push(if let Some(level) = heading {
+            Block::Heading { level, text: paragraph.inline.take(&context.links, false) }
+        } else if let Some((id, level)) = list {
+            let ordered = context.ordered(&id, level);
+            Block::ListItem { level, ordered, text: paragraph.inline.take(&context.links, true) }
+        } else {
+            Block::Paragraph { text: paragraph.inline.take(&context.links, true) }
+        });
+    }
+    out.append(&mut paragraph.boxes);
+}

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

@@ -0,0 +1,215 @@
+//! Image sizes from file headers, for the formats that put them up front.
+//! Vector formats give the size they are drawn at, in pixels at 96 dpi.
+
+use super::ImageFormat;
+use crate::xml::reader::Tag;
+
+/// Pixels per inch, for vector formats sized in physical units.
+const DPI: f64 = 96.0;
+
+/// Width and height, when the header says them.
+pub fn dimensions(format: ImageFormat, data: &[u8]) -> Option<(u32, u32)> {
+    let bytes = Bytes(data);
+    match format {
+        ImageFormat::Png => Some((bytes.u32_be(16)?, bytes.u32_be(20)?)),
+        ImageFormat::Gif => Some((bytes.u16_le(6)?.into(), bytes.u16_le(8)?.into())),
+        ImageFormat::Bmp => {
+            Some((bytes.i32_le(18)?.unsigned_abs(), bytes.i32_le(22)?.unsigned_abs()))
+        }
+        ImageFormat::Jpeg => jpeg(&bytes),
+        ImageFormat::Tiff => tiff(&bytes),
+        ImageFormat::Webp => webp(&bytes),
+        ImageFormat::Jpeg2000 => jpeg2000(&bytes),
+        ImageFormat::Emf => emf(&bytes),
+        ImageFormat::Wmf => wmf(&bytes),
+        ImageFormat::Svg => svg(data),
+        _ => None,
+    }
+    .filter(|&(width, height)| width > 0 && height > 0)
+}
+
+/// Bytes read at offsets; `None` past the end.
+struct Bytes<'a>(&'a [u8]);
+
+impl Bytes<'_> {
+    fn array<const N: usize>(&self, at: usize) -> Option<[u8; N]> {
+        self.0.get(at..at.checked_add(N)?)?.try_into().ok()
+    }
+
+    fn u16_le(&self, at: usize) -> Option<u16> {
+        self.array(at).map(u16::from_le_bytes)
+    }
+
+    fn u16_be(&self, at: usize) -> Option<u16> {
+        self.array(at).map(u16::from_be_bytes)
+    }
+
+    fn u32_le(&self, at: usize) -> Option<u32> {
+        self.array(at).map(u32::from_le_bytes)
+    }
+
+    fn u32_be(&self, at: usize) -> Option<u32> {
+        self.array(at).map(u32::from_be_bytes)
+    }
+
+    fn i32_le(&self, at: usize) -> Option<i32> {
+        self.array(at).map(i32::from_le_bytes)
+    }
+
+    fn i16_le(&self, at: usize) -> Option<i16> {
+        self.array(at).map(i16::from_le_bytes)
+    }
+
+    /// A 24-bit little-endian number.
+    fn u24_le(&self, at: usize) -> Option<u32> {
+        let [low, middle, high] = self.array(at)?;
+        Some(u32::from_le_bytes([low, middle, high, 0]))
+    }
+}
+
+/// From the start-of-frame marker.
+fn jpeg(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    let mut at = 2;
+    loop {
+        let [mark, marker] = bytes.array(at)?;
+        if mark != 0xFF {
+            return None;
+        }
+        // SOF0 to SOF15, but DHT, JPG and DAC share the range.
+        if (0xC0..=0xCF).contains(&marker) && !matches!(marker, 0xC4 | 0xC8 | 0xCC) {
+            return Some((bytes.u16_be(at + 7)?.into(), bytes.u16_be(at + 5)?.into()));
+        }
+        at += 2 + usize::from(bytes.u16_be(at + 2)?);
+    }
+}
+
+/// From the first image directory's `ImageWidth` and `ImageLength`.
+fn tiff(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    let little = bytes.0.starts_with(b"II");
+    let short = |at| if little { bytes.u16_le(at) } else { bytes.u16_be(at) };
+    let long = |at| if little { bytes.u32_le(at) } else { bytes.u32_be(at) };
+    let directory = usize::try_from(long(4)?).ok()?;
+    let (mut width, mut height) = (None, None);
+    for index in 0..usize::from(short(directory)?) {
+        let entry = directory + 2 + index * 12;
+        let value = match short(entry + 2)? {
+            3 => u32::from(short(entry + 8)?),
+            4 => long(entry + 8)?,
+            _ => continue,
+        };
+        match short(entry)? {
+            256 => width = Some(value),
+            257 => height = Some(value),
+            _ => {}
+        }
+        if let (Some(width), Some(height)) = (width, height) {
+            return Some((width, height));
+        }
+    }
+    None
+}
+
+/// From the first chunk: lossy, lossless or extended.
+fn webp(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    match &bytes.array(12)? {
+        b"VP8 " => {
+            let size = |at| bytes.u16_le(at).map(|value| u32::from(value & 0x3FFF));
+            Some((size(26)?, size(28)?))
+        }
+        b"VP8L" => {
+            let bits = bytes.u32_le(21)?;
+            Some(((bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1))
+        }
+        b"VP8X" => Some((bytes.u24_le(24)? + 1, bytes.u24_le(27)? + 1)),
+        _ => None,
+    }
+}
+
+/// From a codestream's SIZ marker, or a JP2 file's image header box.
+fn jpeg2000(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    if bytes.0.starts_with(&[0xFF, 0x4F, 0xFF, 0x51]) {
+        let width = bytes.u32_be(8)?.checked_sub(bytes.u32_be(16)?)?;
+        let height = bytes.u32_be(12)?.checked_sub(bytes.u32_be(20)?)?;
+        return Some((width, height));
+    }
+    let header = Bytes(find_box(find_box(bytes.0, *b"jp2h")?, *b"ihdr")?);
+    Some((header.u32_be(4)?, header.u32_be(0)?))
+}
+
+/// The contents of the first box of `kind` among `data`'s boxes.
+fn find_box(mut data: &[u8], kind: [u8; 4]) -> Option<&[u8]> {
+    while data.len() >= 8 {
+        let bytes = Bytes(data);
+        let (start, length) = match bytes.u32_be(0)? {
+            0 => (8, data.len()),
+            1 => (16, usize::try_from(u64::from_be_bytes(bytes.array(8)?)).ok()?),
+            length => (8, usize::try_from(length).ok()?),
+        };
+        if length < start || length > data.len() {
+            return None;
+        }
+        if bytes.array(4)? == kind {
+            return data.get(start..length);
+        }
+        data = &data[length..];
+    }
+    None
+}
+
+/// From the header record's bounds, in device units, inclusive.
+fn emf(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    let span = |low: i32, high: i32| u32::try_from(i64::from(high) - i64::from(low) + 1).ok();
+    Some((span(bytes.i32_le(8)?, bytes.i32_le(16)?)?, span(bytes.i32_le(12)?, bytes.i32_le(20)?)?))
+}
+
+/// From a placeable metafile's bounding box and its units per inch.
+fn wmf(bytes: &Bytes<'_>) -> Option<(u32, u32)> {
+    let inch = f64::from(bytes.u16_le(14)?);
+    let span =
+        |low: i16, high: i16| pixels(f64::from(i32::from(high) - i32::from(low)) / inch * DPI);
+    if inch == 0.0 {
+        return None;
+    }
+    Some((span(bytes.i16_le(6)?, bytes.i16_le(10)?)?, span(bytes.i16_le(8)?, bytes.i16_le(12)?)?))
+}
+
+/// From the root element's `width` and `height`, or its `viewBox`.
+fn svg(data: &[u8]) -> Option<(u32, u32)> {
+    let text = std::str::from_utf8(data.get(..data.len().min(64 * 1024))?).ok()?;
+    let start = text.match_indices("<svg").map(|(at, _)| at + 4).find(|&at| {
+        text[at..].starts_with(|ch: char| ch.is_ascii_whitespace() || ch == '>' || ch == '/')
+    })?;
+    let tag = Tag::new("svg", &text[start..start + text[start..].find('>')?]);
+    let length = |name| tag.attr(name).and_then(|value| svg_length(&value));
+    if let (Some(width), Some(height)) = (length("width"), length("height")) {
+        return Some((width, height));
+    }
+    let view = tag.attr("viewBox")?;
+    let mut numbers = view.split([' ', ',']).filter(|part| !part.is_empty()).skip(2);
+    let mut next = || numbers.next()?.parse::<f64>().ok().and_then(pixels);
+    Some((next()?, next()?))
+}
+
+/// An SVG length in pixels; `None` for relative units (`%`, `em`).
+fn svg_length(value: &str) -> Option<u32> {
+    let value = value.trim();
+    let split = value.find(|ch: char| ch.is_ascii_alphabetic() || ch == '%').unwrap_or(value.len());
+    let (number, unit) = value.split_at(split);
+    let number: f64 = number.trim().parse().ok()?;
+    let scale = match unit {
+        "" | "px" => 1.0,
+        "pt" => DPI / 72.0,
+        "pc" => DPI / 6.0,
+        "in" => DPI,
+        "cm" => DPI / 2.54,
+        "mm" => DPI / 25.4,
+        _ => return None,
+    };
+    pixels(number * scale)
+}
+
+#[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss, reason = "checked to fit")]
+fn pixels(value: f64) -> Option<u32> {
+    let value = value.round();
+    (value.is_finite() && (1.0..=f64::from(u32::MAX)).contains(&value)).then_some(value as u32)
+}