imprimatur 0.1.0

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

@@ -0,0 +1,343 @@
+//! `WordprocessingML` (`.docx`), per ECMA-376 Part 1: the document model as
+//! Word paragraphs, runs and tables, with real Heading 1-3 styles so Word's
+//! navigation pane and table of contents see them.
+
+#[cfg(test)]
+mod tests;
+
+use std::io::Write;
+
+use crate::Result;
+use crate::doc::{Block, Document, Paragraph, Run, Table};
+use crate::opc;
+use crate::style::{Align, Color, TextDirection};
+use crate::xml::XmlWriter;
+use crate::zip::ZipWriter;
+
+const W_NS: &str = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const WORD_TYPE: &str = "application/vnd.openxmlformats-officedocument.wordprocessingml";
+/// One inch, Word's default margin, in twips.
+const MARGIN: u32 = 1_440;
+/// A header row's shading.
+const HEADER_FILL: &str = "D9E2F3";
+
+pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
+    let footer = document.has_page_numbers();
+    let mut parts = vec![("styles", "styles.xml")];
+    if footer {
+        parts.push(("footer", "footer1.xml"));
+    }
+    let mut zip = ZipWriter::new(out);
+    zip.add("[Content_Types].xml", content_types(footer).as_bytes())?;
+    let package = opc::relationships(&[("officeDocument", "word/document.xml")]);
+    zip.add("_rels/.rels", package.as_bytes())?;
+    zip.add("word/document.xml", body(document).as_bytes())?;
+    zip.add("word/_rels/document.xml.rels", opc::relationships(&parts).as_bytes())?;
+    zip.add("word/styles.xml", styles().as_bytes())?;
+    if footer {
+        zip.add("word/footer1.xml", page_number_footer().as_bytes())?;
+    }
+    zip.finish()
+}
+
+/// One override per part: the document, its styles and the footer.
+fn content_types(footer: bool) -> String {
+    let mut parts = vec![("/word/document.xml", "document.main"), ("/word/styles.xml", "styles")];
+    if footer {
+        parts.push(("/word/footer1.xml", "footer"));
+    }
+    let overrides: Vec<(&str, String)> =
+        parts.into_iter().map(|(part, kind)| (part, format!("{WORD_TYPE}.{kind}+xml"))).collect();
+    opc::content_types(&[], &overrides)
+}
+
+/// `word/footer1.xml`: a centered `PAGE / NUMPAGES`, which Word computes.
+fn page_number_footer() -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("w:ftr", &[("xmlns:w", W_NS)]);
+    xml.open("w:p", &[]);
+    xml.open("w:pPr", &[]);
+    xml.empty("w:jc", &[("w:val", "center")]);
+    xml.close("w:pPr");
+    let field = |xml: &mut XmlWriter, instruction: &str| {
+        for kind in ["begin", "instruction", "separate", "placeholder", "end"] {
+            xml.open("w:r", &[]);
+            match kind {
+                "instruction" => {
+                    xml.element("w:instrText", &[("xml:space", "preserve")], instruction);
+                }
+                "placeholder" => xml.element("w:t", &[], "1"),
+                _ => xml.empty("w:fldChar", &[("w:fldCharType", kind)]),
+            }
+            xml.close("w:r");
+        }
+    };
+    field(&mut xml, " PAGE ");
+    xml.open("w:r", &[]);
+    xml.element("w:t", &[("xml:space", "preserve")], " / ");
+    xml.close("w:r");
+    field(&mut xml, " NUMPAGES ");
+    xml.close("w:p");
+    xml.close("w:ftr");
+    xml.finish()
+}
+
+fn body(document: &Document) -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("w:document", &[("xmlns:w", W_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
+    xml.open("w:body", &[]);
+    for block in document.blocks() {
+        match block {
+            Block::Heading { level, text } => {
+                let style = format!("Heading{level}");
+                simple_paragraph(&mut xml, Some(&style), text, Look::default());
+            }
+            Block::Paragraph(content) => paragraph(&mut xml, content),
+            Block::Table(content) => table(&mut xml, content, document),
+            Block::PageBreak => {
+                xml.open("w:p", &[]);
+                xml.open("w:r", &[]);
+                xml.empty("w:br", &[("w:type", "page")]);
+                xml.close("w:r");
+                xml.close("w:p");
+            }
+        }
+    }
+    // Word ends a body that ends with a table with an empty paragraph anyway.
+    if matches!(document.blocks().last(), Some(Block::Table(_))) {
+        xml.empty("w:p", &[]);
+    }
+    section(&mut xml, document);
+    xml.close("w:body");
+    xml.close("w:document");
+    xml.finish()
+}
+
+fn paragraph(xml: &mut XmlWriter, content: &Paragraph) {
+    let rtl = content.direction == Some(TextDirection::RightToLeft);
+    open_paragraph(xml, None, rtl, content.align);
+    for item in &content.runs {
+        run(xml, &item.text, Look::of(item), rtl);
+    }
+    xml.close("w:p");
+}
+
+/// A one-run paragraph straight from borrowed text: headings and table cells.
+fn simple_paragraph(xml: &mut XmlWriter, style: Option<&str>, text: &str, look: Look) {
+    open_paragraph(xml, style, false, None);
+    run(xml, text, look, false);
+    xml.close("w:p");
+}
+
+/// `<w:p>` and its properties; the caller writes the runs and closes it.
+fn open_paragraph(xml: &mut XmlWriter, style: Option<&str>, rtl: bool, align: Option<Align>) {
+    xml.open("w:p", &[]);
+    if style.is_none() && !rtl && align.is_none() {
+        return;
+    }
+    xml.open("w:pPr", &[]);
+    if let Some(style) = style {
+        xml.empty("w:pStyle", &[("w:val", style)]);
+    }
+    if rtl {
+        xml.empty("w:bidi", &[]);
+    }
+    if let Some(align) = align {
+        let value = match align {
+            Align::Left => "left",
+            Align::Center => "center",
+            Align::Right => "right",
+        };
+        xml.empty("w:jc", &[("w:val", value)]);
+    }
+    xml.close("w:pPr");
+}
+
+/// How a run looks, apart from its text.
+#[derive(Clone, Copy, Default)]
+struct Look {
+    bold: bool,
+    italic: bool,
+    underline: bool,
+    color: Option<Color>,
+}
+
+impl Look {
+    const fn of(run: &Run) -> Self {
+        Self { bold: run.bold, italic: run.italic, underline: run.underline, color: run.color }
+    }
+}
+
+/// One `<w:r>` per piece of text, with `<w:br/>` for `\n` and `<w:tab/>` for `\t`.
+fn run(xml: &mut XmlWriter, text: &str, look: Look, rtl: bool) {
+    xml.open("w:r", &[]);
+    if look.bold || look.italic || look.underline || look.color.is_some() || rtl {
+        xml.open("w:rPr", &[]);
+        if look.bold {
+            xml.empty("w:b", &[]);
+        }
+        if look.italic {
+            xml.empty("w:i", &[]);
+        }
+        if look.underline {
+            xml.empty("w:u", &[("w:val", "single")]);
+        }
+        if let Some(color) = look.color {
+            let hex = color.argb();
+            xml.empty("w:color", &[("w:val", &hex[2..])]);
+        }
+        if rtl {
+            xml.empty("w:rtl", &[]);
+        }
+        xml.close("w:rPr");
+    }
+    for (index, line) in text.split('\n').enumerate() {
+        if index > 0 {
+            xml.empty("w:br", &[]);
+        }
+        for (index, piece) in line.split('\t').enumerate() {
+            if index > 0 {
+                xml.empty("w:tab", &[]);
+            }
+            if !piece.is_empty() {
+                xml.element("w:t", &[("xml:space", "preserve")], piece);
+            }
+        }
+    }
+    xml.close("w:r");
+}
+
+fn table(xml: &mut XmlWriter, content: &Table, document: &Document) {
+    let columns = content.columns();
+    let (page_width, _) = document.page_size().twips();
+    let usable = page_width - 2 * MARGIN;
+    // Never 0: a table has at least one column.
+    let column_width = (usable / u32::try_from(columns).unwrap_or(1).max(1)).to_string();
+
+    xml.open("w:tbl", &[]);
+    xml.open("w:tblPr", &[]);
+    xml.empty("w:tblStyle", &[("w:val", "TableGrid")]);
+    xml.empty("w:tblW", &[("w:w", "5000"), ("w:type", "pct")]);
+    xml.close("w:tblPr");
+    xml.open("w:tblGrid", &[]);
+    for _ in 0..columns {
+        xml.empty("w:gridCol", &[("w:w", &column_width)]);
+    }
+    xml.close("w:tblGrid");
+    for (index, row) in content.rows().iter().enumerate() {
+        let header = index == 0 && content.has_header();
+        xml.open("w:tr", &[]);
+        if header {
+            xml.open("w:trPr", &[]);
+            xml.empty("w:tblHeader", &[]);
+            xml.close("w:trPr");
+        }
+        for column in 0..columns {
+            xml.open("w:tc", &[]);
+            xml.open("w:tcPr", &[]);
+            xml.empty("w:tcW", &[("w:w", &column_width), ("w:type", "dxa")]);
+            if header {
+                xml.empty(
+                    "w:shd",
+                    &[("w:val", "clear"), ("w:color", "auto"), ("w:fill", HEADER_FILL)],
+                );
+            }
+            xml.close("w:tcPr");
+            let text = row.get(column).map_or("", String::as_str);
+            simple_paragraph(xml, None, text, Look { bold: header, ..Look::default() });
+            xml.close("w:tc");
+        }
+        xml.close("w:tr");
+    }
+    xml.close("w:tbl");
+}
+
+fn section(xml: &mut XmlWriter, document: &Document) {
+    let (width, height) = document.page_size().twips();
+    let (width, height, margin) = (width.to_string(), height.to_string(), MARGIN.to_string());
+    xml.open("w:sectPr", &[]);
+    if document.has_page_numbers() {
+        // rId2: the footer, after the styles (see `write`).
+        xml.empty("w:footerReference", &[("w:type", "default"), ("r:id", "rId2")]);
+    }
+    xml.empty("w:pgSz", &[("w:w", &width), ("w:h", &height)]);
+    let margins =
+        [("w:top", &margin), ("w:right", &margin), ("w:bottom", &margin), ("w:left", &margin)];
+    xml.empty("w:pgMar", &margins.map(|(key, value)| (key, value.as_str())));
+    xml.close("w:sectPr");
+}
+
+/// Heading 1-3: space before and after (twips), color, size (half-points).
+const HEADINGS: [(&str, &str, Option<&str>, &str); 3] = [
+    ("360", "120", Some("1F3864"), "40"),
+    ("240", "80", Some("1F3864"), "30"),
+    ("200", "60", None, "26"),
+];
+
+/// `word/styles.xml`: Normal text, Heading 1-3 and a bordered table style,
+/// with a Calibri 11pt body.
+fn styles() -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("w:styles", &[("xmlns:w", W_NS)]);
+    xml.open("w:docDefaults", &[]);
+    xml.open("w:rPrDefault", &[]);
+    xml.open("w:rPr", &[]);
+    xml.empty("w:rFonts", &[("w:ascii", "Calibri"), ("w:hAnsi", "Calibri"), ("w:cs", "Arial")]);
+    xml.empty("w:sz", &[("w:val", "22")]);
+    xml.empty("w:szCs", &[("w:val", "22")]);
+    xml.close("w:rPr");
+    xml.close("w:rPrDefault");
+    xml.open("w:pPrDefault", &[]);
+    xml.open("w:pPr", &[]);
+    xml.empty("w:spacing", &[("w:after", "160"), ("w:line", "259"), ("w:lineRule", "auto")]);
+    xml.close("w:pPr");
+    xml.close("w:pPrDefault");
+    xml.close("w:docDefaults");
+
+    xml.open("w:style", &[("w:type", "paragraph"), ("w:default", "1"), ("w:styleId", "Normal")]);
+    xml.empty("w:name", &[("w:val", "Normal")]);
+    xml.empty("w:qFormat", &[]);
+    xml.close("w:style");
+    for (level, (before, after, color, size)) in (1..).zip(HEADINGS) {
+        let (id, name, outline) =
+            (format!("Heading{level}"), format!("heading {level}"), level - 1);
+        xml.open("w:style", &[("w:type", "paragraph"), ("w:styleId", &id)]);
+        xml.empty("w:name", &[("w:val", &name)]);
+        xml.empty("w:basedOn", &[("w:val", "Normal")]);
+        xml.empty("w:next", &[("w:val", "Normal")]);
+        xml.empty("w:qFormat", &[]);
+        xml.open("w:pPr", &[]);
+        xml.empty("w:keepNext", &[]);
+        xml.empty("w:spacing", &[("w:before", before), ("w:after", after)]);
+        xml.empty("w:outlineLvl", &[("w:val", &outline.to_string())]);
+        xml.close("w:pPr");
+        xml.open("w:rPr", &[]);
+        xml.empty("w:b", &[]);
+        if let Some(color) = color {
+            xml.empty("w:color", &[("w:val", color)]);
+        }
+        xml.empty("w:sz", &[("w:val", size)]);
+        xml.empty("w:szCs", &[("w:val", size)]);
+        xml.close("w:rPr");
+        xml.close("w:style");
+    }
+
+    xml.open("w:style", &[("w:type", "table"), ("w:styleId", "TableGrid")]);
+    xml.empty("w:name", &[("w:val", "Table Grid")]);
+    xml.open("w:tblPr", &[]);
+    xml.open("w:tblBorders", &[]);
+    for side in ["top", "left", "bottom", "right", "insideH", "insideV"] {
+        let line = [("w:val", "single"), ("w:sz", "4"), ("w:space", "0"), ("w:color", "auto")];
+        xml.empty(&format!("w:{side}"), &line);
+    }
+    xml.close("w:tblBorders");
+    xml.open("w:tblCellMar", &[]);
+    for side in ["w:left", "w:right"] {
+        xml.empty(side, &[("w:w", "108"), ("w:type", "dxa")]);
+    }
+    xml.close("w:tblCellMar");
+    xml.close("w:tblPr");
+    xml.close("w:style");
+    xml.close("w:styles");
+    xml.finish()
+}

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

@@ -0,0 +1,113 @@
+use std::io;
+
+/// Everything that can go wrong while building or writing a document.
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum Error {
+    #[error("invalid sheet name {name:?}: {reason}")]
+    InvalidSheetName { name: String, reason: &'static str },
+
+    #[error("a sheet named {0:?} already exists (sheet names are case-insensitive)")]
+    DuplicateSheetName(String),
+
+    #[error("row {0} is out of range (rows are 0..1048576)")]
+    RowOutOfRange(u64),
+
+    #[error("column {0} is out of range (columns are 0..16384)")]
+    ColumnOutOfRange(u64),
+
+    #[error("text of {0} characters is too long for a cell (the limit is 32767)")]
+    TextTooLong(usize),
+
+    #[error("a formula of {0} characters is too long (the limit is 8192)")]
+    FormulaTooLong(usize),
+
+    #[error("{0} is not a finite number; cells cannot hold NaN or infinity")]
+    NonFiniteNumber(f64),
+
+    #[error("invalid color {0:?}: expected #RRGGBB")]
+    InvalidColor(String),
+
+    #[error(
+        "invalid number format {0:?}: it must be 1 to 255 characters, without control characters"
+    )]
+    InvalidNumberFormat(String),
+
+    #[error("{0} is outside Excel's dates (1900-01-01 to 9999-12-31)")]
+    DateOutOfRange(String),
+
+    #[error("column width {0} is out of range (0 to 255 characters)")]
+    InvalidColumnWidth(f64),
+
+    #[error("invalid font name {0:?}: it must be 1 to 31 characters, without control characters")]
+    InvalidFontName(String),
+
+    #[error("font size {0} is out of range (1 to 409 points, in steps of 0.5)")]
+    InvalidFontSize(f64),
+
+    #[error("invalid cell range {0:?}: expected a reference such as B2 or B2:D9")]
+    InvalidRange(String),
+
+    #[error("invalid data validation: {0}")]
+    InvalidValidation(String),
+
+    #[error("the data validation on {0} overlaps one already on the sheet")]
+    OverlappingValidation(String),
+
+    #[error("too many distinct formats (Excel's limit is 64000 per workbook)")]
+    TooManyFormats,
+
+    #[error("heading level {0} is out of range (1 to 3)")]
+    InvalidHeadingLevel(u8),
+
+    #[error("text contains the control character U+{0:04X}; only newlines and tabs are allowed")]
+    ControlCharacter(u32),
+
+    #[error("a table needs at least one row and one column")]
+    EmptyTable,
+
+    #[error(
+        "{character:?} (U+{code:04X}) cannot be written with the PDF standard font {font}: \
+         only Windows-1252 (Latin) text is supported until embedded fonts land",
+        code = u32::from(*character)
+    )]
+    UnsupportedCharacter { character: char, font: &'static str },
+
+    #[error("a table row needs {0:.0}pt, more than a whole page holds")]
+    RowTooTall(f64),
+
+    #[error("a workbook needs at least one sheet")]
+    EmptyWorkbook,
+
+    #[error("archive too large: {0} (zip64 is not supported yet)")]
+    ArchiveTooLarge(&'static str),
+
+    #[error("cannot read this document: {0}")]
+    UnsupportedDocument(String),
+
+    #[error("malformed {format}: {reason}")]
+    Malformed { format: &'static str, reason: String },
+
+    #[error("the document exceeds the {0} limit")]
+    LimitExceeded(&'static str),
+
+    #[error("reading the document was cancelled")]
+    Cancelled,
+
+    #[error("the PDF has no text layer: its pages are images, which need OCR")]
+    NoTextLayer,
+
+    #[error("the PDF is encrypted with a password")]
+    PasswordRequired,
+
+    #[error(transparent)]
+    Io(#[from] io::Error),
+}
+
+impl Error {
+    pub(crate) fn malformed(format: &'static str, reason: impl Into<String>) -> Self {
+        Self::Malformed { format, reason: reason.into() }
+    }
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;

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

@@ -0,0 +1,38 @@
+//! Document authoring with no third-party format stack: the XML and zip
+//! writers underneath every format are written here, on `miniz_oxide`
+//! (deflate) and `crc32fast`.
+//!
+//! [`xlsx`] writes workbooks; [`doc`] is one document model that renders to
+//! PDF and DOCX.
+//!
+//! ```
+//! use imprimatur::xlsx::{Cell, Workbook};
+//!
+//! let mut book = Workbook::new();
+//! let sheet = book.add_sheet("Sales")?;
+//! sheet.append_row(["Region", "Q1"])?;
+//! sheet.append_row([Cell::from("North"), Cell::from(12.5)])?;
+//! sheet.append_row([Cell::from("Total"), Cell::formula("SUM(B2:B2)")])?;
+//! let bytes = book.to_bytes()?;
+//! assert!(bytes.starts_with(b"PK\x03\x04"));
+//! # Ok::<(), imprimatur::Error>(())
+//! ```
+
+pub mod doc;
+mod docx;
+mod error;
+mod opc;
+mod pdf;
+pub mod read;
+pub mod style;
+#[cfg(test)]
+mod test_support;
+pub mod xlsx;
+pub(crate) mod xml;
+pub(crate) mod zip;
+
+pub use error::{Error, Result};
+
+#[doc = include_str!("../README.md")]
+#[cfg(doctest)]
+pub struct ReadmeDoctests;

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

@@ -0,0 +1,51 @@
+//! The Open Packaging Conventions parts every OOXML package carries
+//! (ECMA-376 Part 2): the content types and the relationships.
+
+use crate::xml::XmlWriter;
+
+/// The relationship namespace (`xmlns:r`), and the prefix of every
+/// relationship type: `{RELATIONSHIPS}/officeDocument`, `.../styles`, ...
+pub const RELATIONSHIPS: &str =
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+const PACKAGE_RELATIONSHIPS_NS: &str =
+    "http://schemas.openxmlformats.org/package/2006/relationships";
+const CONTENT_TYPES_NS: &str = "http://schemas.openxmlformats.org/package/2006/content-types";
+const RELATIONSHIPS_CONTENT_TYPE: &str = "application/vnd.openxmlformats-package.relationships+xml";
+
+/// `[Content_Types].xml`: defaults for `.rels`, `.xml` and each
+/// `(extension, content type)` in `defaults`, then one override per
+/// `(part name, content type)`.
+pub fn content_types<P: AsRef<str>, T: AsRef<str>>(
+    defaults: &[(&str, &str)],
+    overrides: &[(P, T)],
+) -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("Types", &[("xmlns", CONTENT_TYPES_NS)]);
+    xml.empty("Default", &[("Extension", "rels"), ("ContentType", RELATIONSHIPS_CONTENT_TYPE)]);
+    xml.empty("Default", &[("Extension", "xml"), ("ContentType", "application/xml")]);
+    for (extension, content_type) in defaults {
+        xml.empty("Default", &[("Extension", extension), ("ContentType", content_type)]);
+    }
+    for (part, content_type) in overrides {
+        xml.empty(
+            "Override",
+            &[("PartName", part.as_ref()), ("ContentType", content_type.as_ref())],
+        );
+    }
+    xml.close("Types");
+    xml.finish()
+}
+
+/// A relationships part: `(type, target)` pairs become `rId1`, `rId2`, ...
+/// in order; the type is the last segment, such as `styles`.
+pub fn relationships<T: AsRef<str>>(targets: &[(&str, T)]) -> String {
+    let mut xml = XmlWriter::new();
+    xml.open("Relationships", &[("xmlns", PACKAGE_RELATIONSHIPS_NS)]);
+    for (index, (kind, target)) in targets.iter().enumerate() {
+        let id = format!("rId{}", index + 1);
+        let kind = format!("{RELATIONSHIPS}/{kind}");
+        xml.empty("Relationship", &[("Id", &id), ("Type", &kind), ("Target", target.as_ref())]);
+    }
+    xml.close("Relationships");
+    xml.finish()
+}

data/ext/imprimatur_native/core/src/pdf/font.rs

@@ -0,0 +1,96 @@
+//! The four Helvetica faces: `WinAnsiEncoding` and advance widths.
+
+#[cfg(test)]
+mod tests;
+
+use super::metrics::{
+    FontMetrics, HELVETICA, HELVETICA_BOLD, HELVETICA_BOLDOBLIQUE, HELVETICA_OBLIQUE, WIN_ANSI_HIGH,
+};
+use crate::{Error, Result};
+
+/// A face of the body font; its index is its `/F1`..`/F4` resource number.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Face {
+    Regular,
+    Bold,
+    Italic,
+    BoldItalic,
+}
+
+impl Face {
+    pub const ALL: [Self; 4] = [Self::Regular, Self::Bold, Self::Italic, Self::BoldItalic];
+
+    pub const fn new(bold: bool, italic: bool) -> Self {
+        match (bold, italic) {
+            (false, false) => Self::Regular,
+            (true, false) => Self::Bold,
+            (false, true) => Self::Italic,
+            (true, true) => Self::BoldItalic,
+        }
+    }
+
+    pub const fn metrics(self) -> &'static FontMetrics {
+        match self {
+            Self::Regular => &HELVETICA,
+            Self::Bold => &HELVETICA_BOLD,
+            Self::Italic => &HELVETICA_OBLIQUE,
+            Self::BoldItalic => &HELVETICA_BOLDOBLIQUE,
+        }
+    }
+
+    /// The resource name: `F1` to `F4`.
+    pub const fn resource(self) -> &'static str {
+        match self {
+            Self::Regular => "F1",
+            Self::Bold => "F2",
+            Self::Italic => "F3",
+            Self::BoldItalic => "F4",
+        }
+    }
+
+    /// The text in `WinAnsiEncoding`, the encoding the standard fonts use here.
+    ///
+    /// # Errors
+    /// [`Error::UnsupportedCharacter`] for anything Windows-1252 has no byte for
+    /// or the font has no glyph for.
+    pub fn encode(self, text: &str) -> Result<Vec<u8>> {
+        let metrics = self.metrics();
+        text.chars()
+            .map(|ch| {
+                win_ansi(ch)
+                    .filter(|&byte| {
+                        ch == '\n' || ch == '\t' || metrics.widths[usize::from(byte)] > 0
+                    })
+                    .ok_or(Error::UnsupportedCharacter { character: ch, font: metrics.name })
+            })
+            .collect()
+    }
+
+    /// The advance width of encoded text at `size` points.
+    pub fn width(self, bytes: &[u8], size: f64) -> f64 {
+        let widths = &self.metrics().widths;
+        let units: u32 = bytes.iter().map(|&byte| u32::from(widths[usize::from(byte)])).sum();
+        f64::from(units) * size / 1000.0
+    }
+
+    /// The height above the baseline at `size` points.
+    pub fn ascent(self, size: f64) -> f64 {
+        f64::from(self.metrics().ascender) * size / 1000.0
+    }
+
+    /// The depth below the baseline at `size` points, as a positive number.
+    pub fn descent(self, size: f64) -> f64 {
+        -f64::from(self.metrics().descender) * size / 1000.0
+    }
+}
+
+/// The Windows-1252 byte for a character: Latin-1 maps to itself, except
+/// 0x80..=0x9F, which Windows-1252 gives typographic characters.
+fn win_ansi(ch: char) -> Option<u8> {
+    let code = u32::from(ch);
+    if code < 0x80 || (0xA0..=0xFF).contains(&code) {
+        return u8::try_from(code).ok();
+    }
+    let index = WIN_ANSI_HIGH.iter().position(|&high| high == Some(ch))?;
+    u8::try_from(0x80 + index).ok()
+}