imprimatur 0.2.0 → 0.3.0

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

@@ -2,15 +2,18 @@
 //! glyphs, paragraphs by the gaps between lines, headings by size, and
 //! the running headers and footers left out.
 
+mod bidi;
 #[cfg(test)]
 mod tests;
 
 use std::collections::HashMap;
 use std::ops::Range;
 
+use self::bidi::{Scratch, is_mark};
 use super::content::{Glyph, PageText};
 use crate::read::content::{Block, Bounds, Page, Placed, Text};
 use crate::read::span;
+use crate::script::Counts;
 
 /// Share of the page height, at the top and the bottom, where running
 /// headers and footers live.
@@ -61,7 +64,9 @@ pub fn lines(page: &PageText) -> PageLines {
         height,
         images: u32::try_from(page.images).unwrap_or(u32::MAX),
     };
+    let right_to_left = right_to_left(page);
     let mut pieces: Vec<&str> = Vec::new();
+    let mut scratch = Scratch::default();
     let mut glyphs: Vec<(f64, f64, &Glyph)> = Vec::with_capacity(page.glyphs.len());
     for turns in 0..4_u8 {
         glyphs.clear();
@@ -89,7 +94,7 @@ pub fn lines(page: &PageText) -> PageLines {
             let row = &mut glyphs[start..end];
             row.sort_by(|a, b| a.0.total_cmp(&b.0));
             let added = out.lines.len();
-            line(page, row, turns, &mut pieces, &mut out);
+            line(page, row, turns, right_to_left, &mut pieces, &mut scratch, &mut out);
             if let Some(line) = out.lines.get_mut(added)
                 && turns == 0
                 && (line.y > height * (1.0 - EDGE) || line.y < height * EDGE)
@@ -103,14 +108,31 @@ pub fn lines(page: &PageText) -> PageLines {
     out
 }
 
+/// Whether a page reads right to left: more of its letters, those in the
+/// top and bottom margins of upright text aside, are right to left.
+fn right_to_left(page: &PageText) -> bool {
+    let height = page.size.1.max(1.0);
+    let mut counts = Counts::default();
+    for glyph in &page.glyphs {
+        if glyph.turns == 0 && (glyph.y > height * (1.0 - EDGE) || glyph.y < height * EDGE) {
+            continue;
+        }
+        counts.add(&page.text[glyph.text.start as usize..glyph.text.end as usize]);
+    }
+    counts.right_to_left()
+}
+
 /// One line's text, appended to `out.text`: spaces where glyphs leave a
 /// word gap, a glyph drawn twice on itself (fake bold) kept once, and
-/// right-to-left lines in reading order. A line with no text is not added.
+/// right-to-left text in reading order, in the page's direction. A line
+/// with no text is not added.
 fn line<'p>(
     page: &'p PageText,
     row: &[(f64, f64, &Glyph)],
     turns: u8,
+    right_to_left: bool,
     pieces: &mut Vec<&'p str>,
+    scratch: &mut Scratch,
     out: &mut PageLines,
 ) {
     // Glyph texts and the spaces between them, left to right as drawn.
@@ -139,9 +161,7 @@ fn line<'p>(
         count += 1;
         previous = Some((x, glyph, glyph_text));
     }
-    if right_to_left(pieces) {
-        reorder(pieces);
-    }
+    bidi::reading_order(pieces, right_to_left, scratch);
     // Spaces collapsed and trimmed on the way in.
     let start = out.text.len();
     for ch in pieces.iter().flat_map(|piece| piece.chars()) {
@@ -172,120 +192,6 @@ fn margin_key(text: &str) -> u64 {
     hash.max(1)
 }
 
-/// The strong direction of a character: `Some(true)` for the scripts
-/// written right to left, `Some(false)` for other letters and for digits
-/// (which keep their order within right-to-left text), `None` for spaces
-/// and punctuation.
-///
-/// Right to left: Hebrew (and Yiddish, Ladino), Arabic (and Persian, Urdu,
-/// Pashto, Sindhi, Kurdish, Uyghur), Syriac, Thaana (Dhivehi), N'Ko,
-/// Samaritan, Mandaic, their presentation forms; Adlam (Fulani), Hanifi
-/// Rohingya, Mende Kikakui, Yezidi, Garay and the historic scripts
-/// (Phoenician, Aramaic, Sogdian...); and the right-to-left mark.
-fn direction(ch: char) -> Option<bool> {
-    match ch {
-        '\u{0590}'..='\u{08FF}'
-        | '\u{200F}'
-        | '\u{FB1D}'..='\u{FDFF}'
-        | '\u{FE70}'..='\u{FEFC}'
-        | '\u{10800}'..='\u{10FFF}'
-        | '\u{1E800}'..='\u{1EFFF}' => Some(true),
-        '\u{200E}' => Some(false),
-        ch if ch.is_alphanumeric() => Some(false),
-        _ => None,
-    }
-}
-
-/// Combining marks: diacritics, and the vowel points and signs of the
-/// right-to-left scripts. Drawn as glyphs of their own, they never start a
-/// word.
-const fn is_mark(ch: char) -> bool {
-    matches!(
-        ch,
-        '\u{0300}'..='\u{036F}'
-            // Hebrew points and cantillation.
-            | '\u{0591}'..='\u{05C7}'
-            | '\u{FB1E}'
-            // Arabic harakat, Quranic annotation, extended Arabic marks.
-            | '\u{0610}'..='\u{061A}'
-            | '\u{064B}'..='\u{065F}'
-            | '\u{0670}'
-            | '\u{06D6}'..='\u{06ED}'
-            | '\u{0898}'..='\u{089F}'
-            | '\u{08CA}'..='\u{08E1}'
-            | '\u{08E3}'..='\u{08FF}'
-            // Syriac, Thaana, N'Ko, Samaritan, Mandaic.
-            | '\u{0711}'
-            | '\u{0730}'..='\u{074A}'
-            | '\u{07A6}'..='\u{07B0}'
-            | '\u{07EB}'..='\u{07F3}'
-            | '\u{07FD}'
-            | '\u{0816}'..='\u{0819}'
-            | '\u{081B}'..='\u{0823}'
-            | '\u{0825}'..='\u{0827}'
-            | '\u{0829}'..='\u{082D}'
-            | '\u{0859}'..='\u{085B}'
-            | '\u{1AB0}'..='\u{1AFF}'
-            | '\u{20D0}'..='\u{20FF}'
-            | '\u{FE20}'..='\u{FE2F}'
-            // Hanifi Rohingya, Adlam.
-            | '\u{10D24}'..='\u{10D27}'
-            | '\u{1E944}'..='\u{1E94A}'
-    )
-}
-
-fn piece_direction(piece: &str) -> Option<bool> {
-    piece.chars().find_map(direction)
-}
-
-/// Whether more of the line's letters read right to left than left to right.
-fn right_to_left(pieces: &[&str]) -> bool {
-    let (mut right, mut left) = (0_usize, 0_usize);
-    for ch in pieces.iter().flat_map(|piece| piece.chars()) {
-        match direction(ch) {
-            Some(true) => right += 1,
-            Some(false) if ch.is_alphabetic() => left += 1,
-            _ => {}
-        }
-    }
-    right > left
-}
-
-/// Puts a right-to-left line, drawn left to right, in reading order: runs
-/// of left-to-right text (Latin words, numbers) keep their order inside,
-/// everything else reads from the right. Spaces and punctuation between two
-/// left-to-right pieces belong to their run.
-fn reorder(pieces: &mut [&str]) {
-    let directions: Vec<Option<bool>> = pieces.iter().map(|piece| piece_direction(piece)).collect();
-    let left_to_right: Vec<bool> = (0..pieces.len())
-        .map(|at| {
-            directions[at].map_or_else(
-                || {
-                    let before = directions[..at].iter().rev().find_map(|direction| *direction);
-                    let after = directions[at + 1..].iter().find_map(|direction| *direction);
-                    before == Some(false) && after == Some(false)
-                },
-                |rtl| !rtl,
-            )
-        })
-        .collect();
-    pieces.reverse();
-    let mut at = 0;
-    let total = pieces.len();
-    while at < total {
-        // Reversed, so a left-to-right run is now backwards: turn it back.
-        if left_to_right[total - 1 - at] {
-            let start = at;
-            while at < total && left_to_right[total - 1 - at] {
-                at += 1;
-            }
-            pieces[start..at].reverse();
-        } else {
-            at += 1;
-        }
-    }
-}
-
 /// The document's pages, from their lines: blocks of the lines that are
 /// not running headers or footers.
 pub fn pages(pages: &[PageLines]) -> Vec<Page> {

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

@@ -52,7 +52,7 @@ pub fn content(ole: &Ole<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
             name: listed.name.clone(),
             hidden: listed.hidden,
             cells,
-            comments: Vec::new(),
+            ..Sheet::default()
         });
     }
     Ok(sheets)

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,
+    })
+}

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

@@ -3,19 +3,21 @@
 //! digits), formulas without a cached result as `=FORMULA`, then the sheet's
 //! comments.
 
+mod formats;
 #[cfg(test)]
 mod tests;
 
 use std::sync::Arc;
 
+use self::formats::{Formats, formats};
 use super::Budget;
-use super::content::{Grid, Note, Sheet, Value};
-use super::numbers::{Shown, push_number, styles};
+use super::content::{Columns, Grid, Note, Sheet, Styled, Validation, Value};
+use super::numbers::{Shown, push_number};
 use super::package::Package;
 use crate::Result;
 use crate::xlsx::parse_cell_reference;
 use crate::xlsx::text::unescape as unescape_xstring;
-use crate::xml::reader::{Event, XmlReader};
+use crate::xml::reader::{Event, Tag, XmlReader};
 
 /// A cell's `t` attribute.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -51,13 +53,24 @@ impl Strings {
     }
 }
 
-/// Where a cell's text events go.
+/// Where a cell's text events go, or a validation's formulas'.
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Into {
     Nowhere,
     Value,
     Formula,
     Inline,
+    First,
+    Second,
+}
+
+/// What a sheet holds besides its cells' values.
+#[derive(Default)]
+struct Parts {
+    columns: Vec<Columns>,
+    validations: Vec<Validation>,
+    /// Cells with a format of their own: row, column, format.
+    styled: Vec<(u32, u32, usize)>,
 }
 
 pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>> {
@@ -67,21 +80,31 @@ pub fn content(package: &Package<'_>, budget: &Budget<'_>) -> Result<Vec<Sheet>>
     let (listed, date1904) = workbook(&text, &relationships, budget)?;
     let strings = package
         .parse_related(&relationships, "sharedStrings", |text| shared_strings(text, budget))?;
-    let shown = package.parse_related(&relationships, "styles", |text| styles(text, budget))?;
-    let book = Book { strings: &strings, shown: &shown, date1904 };
+    let formats = package.parse_related(&relationships, "styles", |text| formats(text, budget))?;
+    let book = Book { strings: &strings, shown: &formats.shown, date1904 };
     let mut sheets = Vec::with_capacity(listed.len());
     let mut scratch = String::new();
     for sheet in listed {
         budget.check()?;
         let Some(text) = package.text(&sheet.part)? else { continue };
-        let cells = cells(&text, &book, &mut scratch, budget)?;
+        let (cells, parts) = cells(&text, &book, &mut scratch, budget)?;
         let comments = match package.related(&sheet.part, "comments")? {
             Some(part) => package
                 .text(&part)?
                 .map_or_else(|| Ok(Vec::new()), |text| comments(&text, budget))?,
             None => Vec::new(),
         };
-        sheets.push(Sheet { name: sheet.name, hidden: sheet.hidden, cells, comments });
+        let styles = styled(&parts.styled, &formats);
+        let (columns, validations) = (parts.columns, parts.validations);
+        sheets.push(Sheet {
+            name: sheet.name,
+            hidden: sheet.hidden,
+            cells,
+            comments,
+            columns,
+            validations,
+            styles,
+        });
     }
     Ok(sheets)
 }
@@ -155,8 +178,13 @@ struct Head {
     style: usize,
 }
 
-fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>) -> Result<Grid> {
-    let mut grid = Grid::default();
+fn cells(
+    text: &str,
+    book: &Book<'_>,
+    scratch: &mut String,
+    budget: &Budget<'_>,
+) -> Result<(Grid, Parts)> {
+    let (mut grid, mut parts, mut rule) = (Grid::default(), Parts::default(), None);
     let mut xml = XmlReader::new(text, budget.max_depth());
     let (mut row, mut next_row, mut next_column) = (0_u32, 0_u32, 0_u32);
     let (mut value, mut formula, mut inline) = (String::new(), String::new(), String::new());
@@ -166,10 +194,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
         match event {
             Event::Start(tag) => match tag.name() {
                 "row" => {
-                    row = tag
-                        .attr("r")
-                        .and_then(|r| r.parse::<u32>().ok())
-                        .map_or(next_row, |r| r.saturating_sub(1));
+                    row = tag.parse::<u32>("r").map_or(next_row, |r| r.saturating_sub(1));
                     next_column = 0;
                 }
                 "c" => {
@@ -186,7 +211,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                         Some("d") => Kind::Iso,
                         _ => Kind::Number,
                     };
-                    let style = tag.attr("s").and_then(|s| s.parse().ok()).unwrap_or(0);
+                    let style = tag.parse("s").unwrap_or(0);
                     head = Some(Head { row: at_row, column, kind, style });
                     value.clear();
                     formula.clear();
@@ -198,17 +223,36 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
                     into = Into::Inline;
                 }
                 "rPh" => xml.skip()?,
+                "col" => parts.columns.extend(columns(tag)),
+                "dataValidation" => rule = Some(validation(tag)),
+                "formula1" if rule.is_some() => (into, value) = (Into::First, String::new()),
+                "formula2" if rule.is_some() => (into, value) = (Into::Second, String::new()),
                 _ => {}
             },
             Event::Text(text) => match into {
-                Into::Value => value.push_str(&text),
+                Into::Value | Into::First | Into::Second => value.push_str(&text),
                 Into::Formula => formula.push_str(&text),
                 Into::Inline => inline.push_str(&unescape_xstring(&text)),
                 Into::Nowhere => {}
             },
             Event::End("v" | "f" | "t") => into = Into::Nowhere,
+            Event::End(end @ ("formula1" | "formula2")) => {
+                if let Some(rule) = rule.as_mut() {
+                    let formula = Some(std::mem::take(&mut value));
+                    if end == "formula1" {
+                        rule.formula1 = formula;
+                    } else {
+                        rule.formula2 = formula;
+                    }
+                }
+                into = Into::Nowhere;
+            }
+            Event::End("dataValidation") => parts.validations.extend(rule.take()),
             Event::End("c") => {
                 if let Some(head) = head.take() {
+                    if head.style != 0 {
+                        parts.styled.push((head.row, head.column, head.style));
+                    }
                     write_cell(&mut grid, &head, book, [&value, &formula, &inline], scratch);
                     next_column = head.column + 1;
                 }
@@ -217,7 +261,7 @@ fn cells(text: &str, book: &Book<'_>, scratch: &mut String, budget: &Budget<'_>)
             Event::End(_) => {}
         }
     }
-    Ok(grid.finish())
+    Ok((grid.finish(), parts))
 }
 
 fn write_cell(
@@ -272,6 +316,48 @@ fn write_cell(
     grid.end_cell(head.row, head.column, kind);
 }
 
+/// A `<col>`: a run of columns, from 0.
+fn columns(tag: Tag<'_>) -> Option<Columns> {
+    let number = |name| tag.parse::<u32>(name);
+    let (first, last) = (number("min")?.checked_sub(1)?, number("max")?.checked_sub(1)?);
+    let width = tag.parse("width");
+    let hidden = tag.on("hidden");
+    Some(Columns { first, last, width, hidden })
+}
+
+/// A `<dataValidation>`, its formulas still to come.
+fn validation(tag: Tag<'_>) -> Validation {
+    let text = |name| tag.attr(name).map(std::borrow::Cow::into_owned);
+    Validation {
+        range: text("sqref").unwrap_or_default(),
+        kind: text("type").unwrap_or_else(|| "none".to_owned()),
+        operator: text("operator"),
+        allow_blank: tag.on("allowBlank"),
+        // Inverted in the file format: showDropDown="1" hides the arrow.
+        dropdown: !tag.on("showDropDown"),
+        alert: tag
+            .on("showErrorMessage")
+            .then(|| text("errorStyle").unwrap_or_else(|| "stop".to_owned())),
+        error_title: text("errorTitle"),
+        error: text("error"),
+        prompt_title: text("promptTitle"),
+        prompt: text("prompt"),
+        ..Validation::default()
+    }
+}
+
+/// The formatted cells with their look; formats the workbook lacks are
+/// left out.
+fn styled(cells: &[(u32, u32, usize)], formats: &Formats) -> Vec<Styled> {
+    cells
+        .iter()
+        .filter_map(|&(row, column, format)| {
+            let look = Arc::clone(formats.looks.get(format)?);
+            Some(Styled { row, column, look })
+        })
+        .collect()
+}
+
 /// The sheet's comments.
 fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
     let mut xml = XmlReader::new(text, budget.max_depth());
@@ -286,8 +372,7 @@ fn comments(text: &str, budget: &Budget<'_>) -> Result<Vec<Note>> {
                 "author" => in_author = true,
                 "comment" => {
                     position = parse_cell_reference(&tag.attr("ref").unwrap_or_default()).ok();
-                    author_id =
-                        tag.attr("authorId").and_then(|id| id.parse().ok()).unwrap_or(usize::MAX);
+                    author_id = tag.parse("authorId").unwrap_or(usize::MAX);
                     body.clear();
                 }
                 "t" => in_text = true,

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

@@ -35,9 +35,12 @@ mod xlsx;
 pub(crate) use budget::Budget;
 pub use budget::Limits;
 pub use content::{
-    Block, Bounds, Cell, Content, Grid, Mark, Note, Page, Placed, Sheet, Text, Value,
+    Block, Bounds, Cell, Columns, Content, Grid, Look, Mark, Note, Page, Placed, Sheet, Styled,
+    Text, Validation, Value,
 };
 pub use image::{Image, ImageFormat, ImageLocation};
+#[cfg(test)]
+pub(crate) use image::{PngColor, png};
 
 use crate::zip::reader::ZipReader;
 use crate::{Error, Result};