imprimatur 0.2.0 → 0.4.0

data/ext/imprimatur_native/core/src/pdf/truetype/descriptor.rs

@@ -0,0 +1,129 @@
+//! TrueType metadata needed by a PDF `FontDescriptor`, in 1000-unit glyph space.
+
+#[cfg(test)]
+mod tests;
+
+use std::io::Write;
+
+use read_fonts::{
+    FontRead, FontRef, TableProvider,
+    tables::{head::MacStyle, os2::Os2, post::Post},
+    types::{NameId, Tag},
+};
+
+use crate::font::{TrueTypeFont, invalid};
+use crate::pdf::objects::{Num, PdfWriter};
+use crate::{Error, Result};
+
+pub struct Descriptor {
+    /// PostScript name, escaped as a PDF name (without its leading slash).
+    pub name: String,
+    bounds: [Num; 4],
+    ascent: Num,
+    descent: Num,
+    cap_height: Num,
+    italic_angle: Num,
+    flags: u32,
+    stem: Num,
+}
+
+impl Descriptor {
+    pub fn read(font: &TrueTypeFont<'_>) -> Result<Self> {
+        let tables = FontRef::new(font.as_bytes()).map_err(invalid)?;
+        let head = tables.head().map_err(invalid)?;
+        let post =
+            tables.table_data(Tag::new(b"post")).map(Post::read).transpose().map_err(invalid)?;
+        let os2 =
+            tables.table_data(Tag::new(b"OS/2")).map(Os2::read).transpose().map_err(invalid)?;
+        if let Some(os2) = &os2 {
+            let rights = os2.fs_type();
+            // Older fonts can set several rights bits; the least restrictive wins.
+            (rights & 0x0002 == 0 || rights & 0x000C != 0)
+                .ok_or(Error::UnsupportedFont("restricted font embedding"))?;
+            (rights & 0x0200 == 0).ok_or(Error::UnsupportedFont("bitmap-only font embedding"))?;
+            // The no-subsetting bit is compatible with embedding the complete font.
+        }
+        (head.x_min() <= head.x_max() && head.y_min() <= head.y_max())
+            .ok_or_else(|| invalid("inverted font bounding box"))?;
+        let metrics = font.metrics();
+        let scale = 1000.0 / f64::from(metrics.units_per_em);
+        let cap_height = os2
+            .as_ref()
+            .and_then(Os2::s_cap_height)
+            .filter(|height| *height > 0)
+            .unwrap_or(metrics.ascender);
+        let angle = post.as_ref().map_or(0.0, |post| post.italic_angle().to_f64());
+        // Symbolic: Identity-H is a CID encoding, not the standard Latin encoding.
+        let mut flags = 4;
+        if post.as_ref().is_some_and(|post| post.is_fixed_pitch() != 0) {
+            flags |= 1;
+        }
+        if angle != 0.0 || head.mac_style().contains(MacStyle::ITALIC) {
+            flags |= 64;
+        }
+        let family = os2.as_ref().map_or(0, |os2| os2.s_family_class() >> 8);
+        if (1..=7).contains(&family) {
+            flags |= 2;
+        } else if family == 10 {
+            flags |= 8;
+        }
+        let weight = os2.as_ref().map_or(400, |os2| os2.us_weight_class().clamp(1, 1000));
+        let stem_weight = f64::from(weight) / 65.0;
+        Ok(Self {
+            name: postscript_name(&tables)?,
+            bounds: [head.x_min(), head.y_min(), head.x_max(), head.y_max()]
+                .map(|value| Num(f64::from(value) * scale)),
+            ascent: Num(f64::from(metrics.ascender) * scale),
+            descent: Num(f64::from(metrics.descender) * scale),
+            // Older OS/2 tables lack cap height; the ascender is an approximation.
+            cap_height: Num(f64::from(cap_height) * scale),
+            italic_angle: Num(angle),
+            flags,
+            // TrueType has no stem-width field: estimate it from the weight class.
+            stem: Num(stem_weight.mul_add(stem_weight, 50.0)),
+        })
+    }
+
+    pub fn write<W: Write>(&self, pdf: &mut PdfWriter<W>, id: usize, file: usize) -> Result<()> {
+        let Self { name, bounds, ascent, descent, cap_height, italic_angle, flags, stem } = self;
+        let [left, bottom, right, top] = bounds;
+        pdf.object(
+            id,
+            format_args!(
+                "<< /Type /FontDescriptor /FontName /{name} /Flags {flags} \
+                 /FontBBox [{left} {bottom} {right} {top}] /ItalicAngle {italic_angle} \
+                 /Ascent {ascent} /Descent {descent} /CapHeight {cap_height} \
+                 /StemV {stem} /FontFile2 {file} 0 R >>"
+            ),
+        )
+    }
+}
+
+fn postscript_name(font: &FontRef<'_>) -> Result<String> {
+    let names = font.name().map_err(invalid)?;
+    for platform in [3, 0, 1] {
+        for record in names.name_record() {
+            if record.name_id() != NameId::POSTSCRIPT_NAME || record.platform_id() != platform {
+                continue;
+            }
+            if !(record.is_unicode() || platform == 1 && record.encoding_id() == 0) {
+                continue;
+            }
+            if record.is_unicode() && !record.length().is_multiple_of(2) {
+                return Err(invalid("odd UTF-16 PostScript name length"));
+            }
+            let name = record.string(names.string_data()).map_err(invalid)?.to_string();
+            // OpenType name ID 6: 1..63 printable ASCII characters, excluding
+            // PostScript delimiters. '#' is legal there but needs escaping in PDF.
+            if !name.is_empty()
+                && name.len() <= 63
+                && name
+                    .bytes()
+                    .all(|byte| (33..=126).contains(&byte) && !b"[](){}<>/%".contains(&byte))
+            {
+                return Ok(name.replace('#', "#23"));
+            }
+        }
+    }
+    Err(Error::UnsupportedFont("no usable PostScript font name"))
+}

data/ext/imprimatur_native/core/src/pdf/truetype/program.rs

@@ -0,0 +1,70 @@
+//! A `CIDFont`'s TrueType program retains every glyph but omits the cmap table
+//! (ISO 32000-1, 9.9). Rebuild the sfnt directory, padding and checksums; glyph
+//! outlines, IDs, metrics and hinting tables are unchanged.
+
+#[cfg(test)]
+mod tests;
+
+use read_fonts::{FontRef, TableRecord, types::Tag};
+
+use crate::Result;
+use crate::font::{TrueTypeFont, invalid};
+
+pub fn for_pdf(font: &TrueTypeFont<'_>) -> Result<Vec<u8>> {
+    let source = FontRef::new(font.as_bytes()).map_err(invalid)?;
+    let mut tags: Vec<_> = source
+        .table_directory()
+        .table_records()
+        .iter()
+        .map(TableRecord::tag)
+        // Rewriting the directory also invalidates any digital signature.
+        .filter(|tag| *tag != Tag::new(b"cmap") && *tag != Tag::new(b"DSIG"))
+        .collect();
+    tags.sort_unstable();
+    (!tags.windows(2).any(|pair| pair[0] == pair[1]))
+        .ok_or_else(|| invalid("duplicate sfnt tables"))?;
+    let count = u16::try_from(tags.len()).map_err(invalid)?;
+    // searchRange and rangeShift are byte counts in 16-bit fields.
+    (count > 0 && count <= 4095).ok_or_else(|| invalid("sfnt table count out of range"))?;
+    let selector = u16::try_from(count.ilog2()).map_err(invalid)?;
+    let range = (1_u16 << selector) * 16;
+    let mut data = Vec::with_capacity(font.as_bytes().len());
+    data.extend_from_slice(&font.as_bytes()[..4]);
+    for value in [count, range, selector, count * 16 - range] {
+        data.extend_from_slice(&value.to_be_bytes());
+    }
+    data.resize(12 + 16 * tags.len(), 0);
+    let mut head = None;
+    for (index, tag) in tags.into_iter().enumerate() {
+        let table = source.table_data(tag).ok_or_else(|| invalid("missing sfnt table"))?;
+        let start = data.len();
+        let offset = u32::try_from(start).map_err(invalid)?;
+        let length = u32::try_from(table.len()).map_err(invalid)?;
+        data.extend_from_slice(table.as_bytes());
+        if tag == Tag::new(b"head") {
+            // head's own checksum is calculated with checkSumAdjustment zero.
+            data[start + 8..start + 12].fill(0);
+            head = Some(start);
+        }
+        let sum = checksum(&data[start..]);
+        data.resize(data.len().next_multiple_of(4), 0);
+        let record = 12 + 16 * index;
+        data[record..record + 4].copy_from_slice(&tag.to_be_bytes());
+        for (field, value) in [sum, offset, length].into_iter().enumerate() {
+            let field = record + 4 * (field + 1);
+            data[field..field + 4].copy_from_slice(&value.to_be_bytes());
+        }
+    }
+    let head = head.ok_or_else(|| invalid("missing head table"))?;
+    let adjustment = 0xB1B0_AFBA_u32.wrapping_sub(checksum(&data));
+    data[head + 8..head + 12].copy_from_slice(&adjustment.to_be_bytes());
+    Ok(data)
+}
+
+fn checksum(data: &[u8]) -> u32 {
+    data.chunks(4).fold(0_u32, |sum, bytes| {
+        let mut word = [0; 4];
+        word[..bytes.len()].copy_from_slice(bytes);
+        sum.wrapping_add(u32::from_be_bytes(word))
+    })
+}

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

@@ -0,0 +1,149 @@
+//! A complete TrueType font as a horizontal Type 0 / `CIDFontType2` resource
+//! (ISO 32000-1, 9.7 and 9.10). Document font selection and layout are separate.
+
+mod descriptor;
+mod program;
+#[cfg(test)]
+mod tests;
+
+use std::collections::BTreeMap;
+use std::fmt::{self, Write as _};
+use std::io::Write;
+
+use super::objects::{Num, PdfWriter};
+use crate::font::TrueTypeFont;
+use crate::{Error, Result};
+use descriptor::Descriptor;
+
+/// Objects written in order: Type 0 font, descendant, descriptor, font file,
+/// CID-to-glyph map, `ToUnicode` character map.
+pub const OBJECTS: usize = 6;
+
+/// Collects glyph uses before writing the font resource once for all its pages.
+/// CIDs are allocated per (glyph, original text), not per glyph alone: distinct
+/// characters can share an outline, and a ligature can represent several.
+pub struct EmbeddedFont<'a> {
+    font: TrueTypeFont<'a>,
+    descriptor: Descriptor,
+    program: Vec<u8>,
+    /// CID 1 onwards, with unscaled advances; CID 0 is reserved for .notdef.
+    glyphs: Vec<(u16, u16)>,
+    codes: BTreeMap<(u16, String), u16>,
+}
+
+impl<'a> EmbeddedFont<'a> {
+    /// Reads the metadata needed for a PDF descriptor and checks embedding rights.
+    pub fn new(font: TrueTypeFont<'a>) -> Result<Self> {
+        let descriptor = Descriptor::read(&font)?;
+        let program = program::for_pdf(&font)?;
+        Ok(Self { font, descriptor, program, glyphs: Vec::new(), codes: BTreeMap::new() })
+    }
+
+    /// The two big-endian bytes to put in a PDF text string for this glyph use.
+    /// `text` is its original Unicode sequence, in logical order. Empty text
+    /// omits its `ToUnicode` entry, for glyphs with no text of their own.
+    /// This does not shape text or infer glyphs from characters.
+    pub fn encode_glyph(&mut self, glyph: u16, text: &str) -> Result<[u8; 2]> {
+        // A ToUnicode destination string may contain at most 512 bytes.
+        (text.encode_utf16().take(257).count() <= 256)
+            .ok_or_else(|| invalid("Unicode mapping exceeds 256 UTF-16 code units"))?;
+        let width = self
+            .font
+            .advance_width(glyph)
+            .filter(|_| glyph != 0)
+            .ok_or_else(|| invalid("glyph is missing or outside the font's glyph range"))?;
+        let key = (glyph, text.to_owned());
+        if let Some(code) = self.codes.get(&key) {
+            return Ok(code.to_be_bytes());
+        }
+        let code = u16::try_from(self.glyphs.len() + 1)
+            .map_err(|_| invalid("more than 65535 distinct glyph mappings"))?;
+        self.glyphs.push((glyph, width));
+        self.codes.insert(key, code);
+        Ok(code.to_be_bytes())
+    }
+
+    /// Writes six consecutive objects, starting at `first`, which is the font
+    /// reference for a page's resources. Collect every glyph before calling this.
+    /// Every glyph is embedded with its original ID and outline. The font's cmap
+    /// is replaced by PDF mappings; its table directory and checksums are rebuilt.
+    pub fn write<W: Write>(&self, pdf: &mut PdfWriter<W>, first: usize) -> Result<()> {
+        let (descendant, descriptor, file, mapping, unicode) =
+            (first + 1, first + 2, first + 3, first + 4, first + 5);
+        let name = &self.descriptor.name;
+        pdf.object(
+            first,
+            format_args!(
+                "<< /Type /Font /Subtype /Type0 /BaseFont /{name} /Encoding /Identity-H \
+                 /DescendantFonts [{descendant} 0 R] /ToUnicode {unicode} 0 R >>"
+            ),
+        )?;
+        let scale = 1000.0 / f64::from(self.font.metrics().units_per_em);
+        let default_width = Num(f64::from(self.font.advance_width(0).unwrap_or(0)) * scale);
+        let widths = fmt::from_fn(|f| {
+            // Keep both the outer W array and each inner width array below the
+            // PDF 1.7 implementation limit of 8191 elements (Annex C).
+            for (index, glyphs) in self.glyphs.chunks(256).enumerate() {
+                if index > 0 {
+                    f.write_str(" ")?;
+                }
+                write!(f, "{} [", 1 + index * 256)?;
+                for &(_, width) in glyphs {
+                    write!(f, "{} ", Num(f64::from(width) * scale))?;
+                }
+                f.write_str("]")?;
+            }
+            Ok(())
+        });
+        pdf.object(
+            descendant,
+            format_args!(
+                "<< /Type /Font /Subtype /CIDFontType2 /BaseFont /{name} \
+                 /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> \
+                 /FontDescriptor {descriptor} 0 R /DW {default_width} /W [{widths}] \
+                 /CIDToGIDMap {mapping} 0 R >>"
+            ),
+        )?;
+        self.descriptor.write(pdf, descriptor, file)?;
+        pdf.stream(file, &self.program, &[("Length1", &self.program.len())])?;
+        let mut gids = Vec::with_capacity(2 * (self.glyphs.len() + 1));
+        gids.extend_from_slice(&[0, 0]);
+        for &(glyph, _) in &self.glyphs {
+            gids.extend_from_slice(&glyph.to_be_bytes());
+        }
+        pdf.stream(mapping, &gids, &[])?;
+        pdf.stream(unicode, self.to_unicode().as_bytes(), &[])
+    }
+
+    fn to_unicode(&self) -> String {
+        let mut cmap = String::from(
+            "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n\
+             /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n\
+             /CMapName /Imprimatur-UCS def\n/CMapType 2 def\n\
+             1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n",
+        );
+        let mappings: Vec<_> =
+            self.codes.iter().filter(|((_, text), _)| !text.is_empty()).collect();
+        // CMap mapping operators accept at most 100 entries per block.
+        for chunk in mappings.chunks(100) {
+            // Writing to a String cannot fail.
+            let _ = writeln!(cmap, "{} beginbfchar", chunk.len());
+            for ((_, text), code) in chunk {
+                // Writing to a String cannot fail.
+                let _ = write!(cmap, "<{code:04X}> <");
+                for unit in text.encode_utf16() {
+                    // Writing to a String cannot fail.
+                    let _ = write!(cmap, "{unit:04X}");
+                }
+                cmap.push_str(">\n");
+            }
+            cmap.push_str("endbfchar\n");
+        }
+        cmap.push_str("endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");
+        cmap
+    }
+}
+
+fn invalid(reason: &str) -> Error {
+    Error::malformed("PDF font", reason)
+}

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

@@ -1,14 +1,22 @@
 //! PDF output: the document laid out with the standard Helvetica fonts
 //! (`WinAnsiEncoding`, so Windows-1252 text), written with our own object
-//! writer. Embedded TrueType fonts, and with them every other script, come next.
+//! writer. `truetype` serializes embedded font resources; connecting these to
+//! document layout, shaping and bidirectional text comes next.
 
 mod font;
 mod layout;
 #[rustfmt::skip]
 pub mod metrics;
 mod objects;
+mod picture;
 #[cfg(test)]
 mod tests;
+#[cfg(feature = "fonts")]
+#[cfg_attr(
+    not(test),
+    expect(dead_code, reason = "font resources are connected to document layout in a follow-up")
+)]
+mod truetype;
 
 use std::fmt;
 use std::io::Write;
@@ -26,12 +34,18 @@ const FIRST_FONT: usize = 3;
 const INFO: usize = FIRST_FONT + Face::ALL.len();
 
 pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
-    let mut layout = Layout::new(document.page_size());
+    let mut layout = Layout::new(document)?;
+    let mut pictures = Vec::new();
     for block in document.blocks() {
         match block {
             Block::Heading { level, text } => layout.heading(*level, text)?,
             Block::Paragraph(paragraph) => layout.paragraph(paragraph)?,
             Block::Table(table) => layout.table(table)?,
+            Block::Picture(picture) => {
+                layout.picture(picture, pictures.len());
+                pictures.push(picture);
+            }
+            Block::Symbol(symbol) => layout.symbol(symbol),
             Block::PageBreak => layout.page_break(),
         }
     }
@@ -67,6 +81,23 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
         }
         Ok(())
     });
+    // Pictures follow the pages: an image, then its soft mask if it has one.
+    let mut ids = Vec::with_capacity(pictures.len());
+    let mut next = page_id(pages.len());
+    for picture in &pictures {
+        ids.push(next);
+        next += 1 + usize::from(picture::has_mask(picture));
+    }
+    let images = fmt::from_fn(|f| {
+        if !ids.is_empty() {
+            f.write_str("/XObject << ")?;
+            for (index, id) in ids.iter().enumerate() {
+                write!(f, "/Im{index} {id} 0 R ")?;
+            }
+            f.write_str(">> ")?;
+        }
+        Ok(())
+    });
     let (width, height) = (Num(width), Num(height));
     for (index, content) in pages.iter().enumerate() {
         let id = page_id(index);
@@ -74,11 +105,16 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
             id,
             format_args!(
                 "<< /Type /Page /Parent {PAGES} 0 R /MediaBox [0 0 {width} {height}] \
-                 /Resources << /Font << {fonts}>> >> /Contents {} 0 R >>",
+                 /Resources << /Font << {fonts}>> {images}>> /Contents {} 0 R >>",
                 id + 1
             ),
         )?;
-        pdf.stream(id + 1, content)?;
+        pdf.stream(id + 1, content, &[])?;
+    }
+    for (picture, id) in pictures.into_iter().zip(ids) {
+        for (offset, stream) in (0..).zip(picture::streams(picture, id + 1)?) {
+            pdf.stored(id + offset, format_args!("{}", stream.dictionary), &stream.data)?;
+        }
     }
     pdf.finish(CATALOG, INFO)
 }

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

@@ -144,13 +144,86 @@ pub struct Mark {
     pub link: Option<String>,
 }
 
-/// A workbook sheet: its cells, then its comments.
-#[derive(Debug, Clone, PartialEq)]
+/// A workbook sheet: its cells and comments and, from an XLSX workbook,
+/// its column widths, data validations and cell formats.
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct Sheet {
     pub name: String,
     pub hidden: bool,
     pub cells: Grid,
     pub comments: Vec<Note>,
+    pub columns: Vec<Columns>,
+    pub validations: Vec<Validation>,
+    /// The cells with a format of their own, empty ones included.
+    pub styles: Vec<Styled>,
+}
+
+/// A run of columns, from 0, and their width in characters.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Columns {
+    pub first: u32,
+    pub last: u32,
+    pub width: Option<f64>,
+    pub hidden: bool,
+}
+
+/// A data validation rule, as the workbook stores it.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Validation {
+    /// The cells it applies to: `B2:B100 D2`.
+    pub range: String,
+    /// `list`, `whole`, `decimal`, `date`, `time`, `textLength`, `custom`,
+    /// or `none` for an input message alone.
+    pub kind: String,
+    pub operator: Option<String>,
+    pub formula1: Option<String>,
+    pub formula2: Option<String>,
+    pub allow_blank: bool,
+    /// Whether a list shows its in-cell drop-down arrow.
+    pub dropdown: bool,
+    /// `stop`, `warning` or `information`, when a wrong value is refused.
+    pub alert: Option<String>,
+    pub error_title: Option<String>,
+    pub error: Option<String>,
+    pub prompt_title: Option<String>,
+    pub prompt: Option<String>,
+}
+
+/// A cell with a format of its own, from 0.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Styled {
+    pub row: u32,
+    pub column: u32,
+    pub look: Arc<Look>,
+}
+
+impl Styled {
+    /// The cell's A1 reference: `B2`.
+    #[must_use]
+    pub fn reference(&self) -> String {
+        reference(self.row, self.column)
+    }
+}
+
+/// How a cell format shows a cell. Colors are ARGB (`FFFF0000`), and only
+/// those given as such: theme and indexed colors are left out.
+#[derive(Debug, Clone, Default, PartialEq)]
+#[expect(clippy::struct_excessive_bools, reason = "a format's switches, as Excel keeps them")]
+pub struct Look {
+    pub font: String,
+    /// In points.
+    pub size: f64,
+    pub bold: bool,
+    pub italic: bool,
+    pub underline: bool,
+    pub color: Option<String>,
+    pub fill: Option<String>,
+    pub align: Option<String>,
+    pub valign: Option<String>,
+    pub wrap: bool,
+    /// The left border's style: `thin`, `medium`, `thick`, `dashed`...
+    pub border: Option<String>,
+    pub number_format: String,
 }
 
 /// A comment on a cell.

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

@@ -128,6 +128,20 @@ pub fn png(
     bits: u8,
     palette: Option<&[u8]>,
     rows: &[u8],
+) -> Vec<u8> {
+    png_with_transparency(width, height, color, bits, palette, &[], rows)
+}
+
+/// As [`png`], with a `tRNS` chunk unless `transparency` is empty: a
+/// palette's alphas by index, or the gray or RGB color that is transparent.
+pub fn png_with_transparency(
+    width: u32,
+    height: u32,
+    color: PngColor,
+    bits: u8,
+    palette: Option<&[u8]>,
+    transparency: &[u8],
+    rows: &[u8],
 ) -> Vec<u8> {
     let channels: usize = match color {
         PngColor::Gray | PngColor::Palette => 1,
@@ -157,6 +171,9 @@ pub fn png(
     if let Some(palette) = palette {
         chunk(&mut out, *b"PLTE", palette);
     }
+    if !transparency.is_empty() {
+        chunk(&mut out, *b"tRNS", transparency);
+    }
     chunk(&mut out, *b"IDAT", &compressed);
     chunk(&mut out, *b"IEND", &[]);
     out

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

@@ -9,17 +9,34 @@ 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) | Content::Ods(sheets) | Content::Xls(sheets) => {
-            object.insert("sheets".into(), sheets.iter().map(sheet).collect())
+            object.insert("sheets".into(), sheets.iter().map(|it| sheet(it, options)).collect())
         }
         Content::Docx(blocks) => object.insert("blocks".into(), blocks.iter().map(block).collect()),
     };
@@ -116,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()
@@ -125,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,
     })
 }