imprimatur 0.2.0 → 0.4.0

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

@@ -4,11 +4,8 @@
 
 use std::fmt::Write as _;
 
-use crate::Result;
-use crate::read::Budget;
 use crate::read::content::Value;
 use crate::xlsx::DateTime;
-use crate::xml::reader::{Event, XmlReader};
 
 /// How a number format shows a number.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -17,43 +14,24 @@ pub enum Shown {
     Date,
     Time,
     DateTime,
-    Percent,
-}
-
-/// How each cell format (`cellXfs`, by index) shows numbers.
-pub fn styles(text: &str, budget: &Budget<'_>) -> Result<Vec<Shown>> {
-    let mut xml = XmlReader::new(text, budget.max_depth());
-    let (mut custom, mut shown, mut in_cell_formats) = (Vec::new(), Vec::new(), false);
-    while let Some(event) = xml.next()? {
-        match event {
-            Event::Start(tag) => match tag.name() {
-                "numFmt" => {
-                    if let (Some(id), Some(code)) = (tag.attr("numFmtId"), tag.attr("formatCode")) {
-                        custom.push((id.parse::<u32>().unwrap_or(u32::MAX), classify(&code)));
-                    }
-                }
-                "cellXfs" => in_cell_formats = true,
-                "xf" if in_cell_formats => {
-                    let id =
-                        tag.attr("numFmtId").and_then(|id| id.parse::<u32>().ok()).unwrap_or(0);
-                    let custom =
-                        custom.iter().find(|&&(custom, _)| custom == id).map(|&(_, shown)| shown);
-                    shown.push(custom.unwrap_or_else(|| built_in(id)));
-                }
-                _ => {}
-            },
-            Event::End("cellXfs") => in_cell_formats = false,
-            _ => {}
-        }
-    }
-    Ok(shown)
+    /// A fixed number of decimals, thousands grouped with `,` or not, as a
+    /// percentage or not: `0.00`, `#,##0`, `0%`.
+    Fixed {
+        decimals: u8,
+        grouping: bool,
+        percent: bool,
+    },
 }
 
 /// Excel's built-in number formats (ECMA-376 Part 1, 18.8.30), with the
 /// East Asian date formats.
 pub const fn built_in(id: u32) -> Shown {
     match id {
-        9 | 10 => Shown::Percent,
+        2 => fixed(2, false, false),
+        3 | 37 | 38 => fixed(0, true, false),
+        4 | 39 | 40 => fixed(2, true, false),
+        9 => fixed(0, false, true),
+        10 => fixed(2, false, true),
         14..=17 | 27..=31 | 34..=36 | 50..=58 => Shown::Date,
         18..=21 | 32 | 33 | 45..=47 => Shown::Time,
         22 => Shown::DateTime,
@@ -61,14 +39,26 @@ pub const fn built_in(id: u32) -> Shown {
     }
 }
 
+pub const fn fixed(decimals: u8, grouping: bool, percent: bool) -> Shown {
+    Shown::Fixed { decimals, grouping, percent }
+}
+
 /// What a custom format code shows, from its first section: date and time
-/// tokens, outside quoted text, escapes and `[...]` (colors, locales;
-/// `[h]` is elapsed time).
+/// tokens, decimals, `,` grouping and `%`, outside quoted text, escapes and
+/// `[...]` (colors, locales; `[h]` is elapsed time). Scientific formats
+/// (`0.00E+00`) are shown as General.
 pub fn classify(code: &str) -> Shown {
     let (mut date, mut time, mut month, mut percent) = (false, false, false, false);
-    let mut chars = code.chars();
+    let (mut digits, mut point, mut decimals, mut grouping, mut scientific) =
+        (false, false, 0_u8, false, false);
+    let mut chars = code.chars().peekable();
     while let Some(ch) = chars.next() {
         match ch.to_ascii_lowercase() {
+            '0' | '#' | '?' if point => decimals = decimals.saturating_add(1),
+            '0' | '#' | '?' => digits = true,
+            '.' => point = true,
+            ',' if digits && !point => grouping = true,
+            'e' if matches!(chars.peek(), Some('+' | '-')) => scientific = true,
             ';' => break,
             '"' => {
                 chars.by_ref().find(|&ch| ch == '"');
@@ -91,8 +81,8 @@ pub fn classify(code: &str) -> Shown {
         (true, true) => Shown::DateTime,
         (true, false) => Shown::Date,
         (false, true) => Shown::Time,
-        (false, false) if percent => Shown::Percent,
-        (false, false) => Shown::General,
+        (false, false) if scientific || !(decimals > 0 || grouping || percent) => Shown::General,
+        (false, false) => Shown::Fixed { decimals, grouping, percent },
     }
 }
 
@@ -130,15 +120,48 @@ pub fn push_number(
             let _ =
                 write!(out, "{:02}:{:02}:{:02}", seconds / 3600, seconds / 60 % 60, seconds % 60);
         }
-        Shown::Percent => {
-            push_general(out, number * 100.0, scratch);
-            out.push('%');
+        Shown::Fixed { decimals, grouping, percent } => {
+            let number = if percent { number * 100.0 } else { number };
+            push_fixed(out, number, decimals, grouping, scratch);
+            if percent {
+                out.push('%');
+            }
         }
         _ => push_general(out, number, scratch),
     }
     Value::Number(number)
 }
 
+/// A number with `decimals` decimals, its thousands grouped with `,`,
+/// rounded half away from zero as Excel does (`12.5` shows `13`, `1.005`
+/// `1.01`): a few units in the last place toward the tie undo the binary
+/// error that makes `1.005` `1.00499...`, which Rust would round down, as it
+/// rounds an exact tie to even.
+fn push_fixed(out: &mut String, number: f64, decimals: u8, grouping: bool, scratch: &mut String) {
+    let number = (number.abs() * 4.0 * f64::EPSILON).mul_add(number.signum(), number);
+    scratch.clear();
+    // Writing to a String cannot fail.
+    let _ = write!(scratch, "{number:.*}", usize::from(decimals));
+    if !grouping {
+        out.push_str(scratch);
+        return;
+    }
+    let (sign, digits) =
+        scratch.strip_prefix('-').map_or(("", scratch.as_str()), |rest| ("-", rest));
+    let (whole, fraction) = digits.split_once('.').map_or((digits, None), |(w, f)| (w, Some(f)));
+    out.push_str(sign);
+    for (index, digit) in whole.char_indices() {
+        if index > 0 && (whole.len() - index).is_multiple_of(3) {
+            out.push(',');
+        }
+        out.push(digit);
+    }
+    if let Some(fraction) = fraction {
+        out.push('.');
+        out.push_str(fraction);
+    }
+}
+
 /// A number as Excel's General format shows it: 15 significant digits.
 pub fn push_general(out: &mut String, number: f64, scratch: &mut String) {
     #[expect(clippy::cast_possible_truncation, reason = "whole and under 1e15: exact in i64")]

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

@@ -120,8 +120,7 @@ impl Reader {
                 self.sheets.push(Sheet {
                     name: tag.attr("name").map(std::borrow::Cow::into_owned).unwrap_or_default(),
                     hidden,
-                    cells: Grid::default(),
-                    comments: Vec::new(),
+                    ..Sheet::default()
                 });
                 self.row = 0;
             }

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

@@ -0,0 +1,212 @@
+//! Right-to-left text, from the order a PDF draws it to the order it reads.
+//!
+//! A PDF draws every line left to right, whatever its script: a Hebrew or
+//! Arabic line comes out backwards, and so does an Arabic name inside an
+//! English line. Each piece of a line gets the level the Unicode
+//! bidirectional algorithm (UAX #9) gives it, even for left to right, odd
+//! for right to left, and the runs are reversed the way a renderer reverses
+//! them: reversed twice, a line reads as it was written. The page's own
+//! direction stands in for the paragraph's, which a PDF does not record.
+
+#[cfg(test)]
+mod tests;
+
+use std::ops::Range;
+
+use crate::script::{Class, Counts, class};
+
+/// Reusable buffers for [`reading_order`].
+#[derive(Debug, Default)]
+pub struct Scratch {
+    classes: Vec<Class>,
+    levels: Vec<u8>,
+}
+
+/// 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.
+pub 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}'
+    )
+}
+
+/// Whether a line reads right to left, from its letters and its page's
+/// direction. On a right-to-left page a line does when it has a
+/// right-to-left letter at all, or only figures (a table row reads from the
+/// right); on a left-to-right page only when its letters are all, or nearly
+/// all, right to left: an Arabic name in an English line stays in an
+/// English line.
+pub const fn line_right_to_left(line: Counts, page_right_to_left: bool) -> bool {
+    if page_right_to_left {
+        line.right > 0 || line.left == 0 && line.numbers > 0
+    } else {
+        line.right > 0 && line.right >= 4 * line.left
+    }
+}
+
+/// Puts a line's pieces, drawn left to right, in reading order. Lines
+/// with nothing right to left in them are left as they are.
+pub fn reading_order(pieces: &mut [&str], page_right_to_left: bool, scratch: &mut Scratch) {
+    let mut counts = Counts::default();
+    for piece in pieces.iter() {
+        counts.add(piece);
+    }
+    let right_to_left = line_right_to_left(counts, page_right_to_left);
+    if right_to_left || counts.right > 0 {
+        reorder(pieces, right_to_left, scratch);
+    }
+}
+
+/// UAX #9 on pieces in drawn order: classes, numbers (W2, W7, W4, W5),
+/// neutrals (N1, N2), levels (I1, I2), then the runs reversed (L2).
+fn reorder(pieces: &mut [&str], right_to_left: bool, scratch: &mut Scratch) {
+    let Scratch { classes, levels } = scratch;
+    classes.clear();
+    classes.extend(pieces.iter().map(|piece| {
+        piece.chars().map(class).find(|&class| class != Class::Neutral).unwrap_or(Class::Neutral)
+    }));
+    resolve_numbers(classes, right_to_left);
+    join_numbers(pieces, classes);
+    resolve_neutrals(classes, right_to_left);
+    levels.clear();
+    levels.extend(classes.iter().map(|class| match class {
+        Class::Right | Class::Arabic => 1,
+        Class::Number | Class::ArabicNumber => 2,
+        Class::Left | Class::Neutral => {
+            if right_to_left {
+                2
+            } else {
+                0
+            }
+        }
+    }));
+    // From the highest level to the lowest odd one, every run at that
+    // level or above reversed.
+    for level in [2, 1] {
+        let mut from = 0;
+        while let Some(run) = run(levels, from, |&piece| piece >= level) {
+            from = run.end;
+            pieces[run].reverse();
+        }
+    }
+}
+
+/// The next run of items, from `from` on, that `wanted` picks.
+fn run<T>(items: &[T], from: usize, wanted: impl Fn(&T) -> bool) -> Option<Range<usize>> {
+    let start = from + items.get(from..)?.iter().position(&wanted)?;
+    let length = items[start..].iter().position(|item| !wanted(item));
+    Some(start..length.map_or(items.len(), |length| start + length))
+}
+
+/// What joins two digits into one number, Arabic numbers included:
+/// `1,234.5`, `9:30`, `3/4`.
+const SEPARATORS: [&str; 8] = [",", ".", ":", "/", "\u{00A0}", "\u{060C}", "\u{066B}", "\u{066C}"];
+
+/// What joins two digits into one number in any but Arabic text:
+/// `2024-03-15`, `+966`.
+const SIGNS_BETWEEN: [&str; 3] = ["+", "-", "\u{2212}"];
+
+/// Signs that go with the number next to them, in any but Arabic text:
+/// `50%`, `$5`.
+const SIGNS: [&str; 11] = ["%", "‰", "‱", "°", "$", "€", "£", "¥", "¢", "#", "\u{066A}"];
+
+/// What kind of number each run of digits is. A number touching a letter
+/// (`ISO9001`) goes with its word. In a right-to-left line, a number after
+/// left-to-right text, the next letter to its left, is part of that text
+/// (`ISO 9001`); in a left-to-right line, a number is part of a
+/// right-to-left run when one follows it, the next letter to its right.
+/// Digits following Arabic letters, in reading order, are Arabic numbers.
+fn resolve_numbers(classes: &mut [Class], right_to_left: bool) {
+    let mut from = 0;
+    while let Some(Range { start, end: at }) = run(classes, from, |&class| class == Class::Number) {
+        from = at;
+        let glued = (start > 0 && classes[start - 1] == Class::Left)
+            || classes.get(at) == Some(&Class::Left);
+        let before = classes[..start].iter().rev().find(|class| class.strong());
+        let after = classes[at..].iter().find(|class| class.strong());
+        let left_to_right = if right_to_left {
+            before == Some(&Class::Left)
+        } else {
+            !after.is_some_and(|class| class.right_to_left())
+        };
+        if glued || left_to_right {
+            classes[start..at].fill(Class::Left);
+        } else if after == Some(&Class::Arabic) {
+            classes[start..at].fill(Class::ArabicNumber);
+        }
+    }
+}
+
+/// Separators between two digits, and signs next to one, as part of the
+/// number, as far as its kind allows.
+fn join_numbers(pieces: &[&str], classes: &mut [Class]) {
+    for at in 1..classes.len().saturating_sub(1) {
+        let (before, after) = (classes[at - 1], classes[at + 1]);
+        let joins = classes[at] == Class::Neutral
+            && before == after
+            && match before {
+                Class::Number => {
+                    SEPARATORS.contains(&pieces[at]) || SIGNS_BETWEEN.contains(&pieces[at])
+                }
+                Class::ArabicNumber => SEPARATORS.contains(&pieces[at]),
+                _ => false,
+            };
+        if joins {
+            classes[at] = before;
+        }
+    }
+    for at in (0..classes.len()).chain((0..classes.len()).rev()) {
+        let next_to_number = (at > 0 && classes[at - 1] == Class::Number)
+            || classes.get(at + 1) == Some(&Class::Number);
+        if classes[at] == Class::Neutral && SIGNS.contains(&pieces[at]) && next_to_number {
+            classes[at] = Class::Number;
+        }
+    }
+}
+
+/// Spaces and punctuation between two pieces of one direction take it,
+/// numbers counting as right to left; others take the line's.
+fn resolve_neutrals(classes: &mut [Class], right_to_left: bool) {
+    let line = if right_to_left { Class::Right } else { Class::Left };
+    let side = |class: Class| {
+        if class.right_to_left() || class.number() { Class::Right } else { Class::Left }
+    };
+    let mut from = 0;
+    while let Some(Range { start, end: at }) = run(classes, from, |&class| class == Class::Neutral)
+    {
+        from = at;
+        let before = if start == 0 { line } else { side(classes[start - 1]) };
+        let after = classes.get(at).map_or(line, |&class| side(class));
+        classes[start..at].fill(if before == after { before } else { line });
+    }
+}

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)