imprimatur 0.2.0 → 0.3.0

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

@@ -7,6 +7,7 @@ mod layout;
 #[rustfmt::skip]
 pub mod metrics;
 mod objects;
+mod picture;
 #[cfg(test)]
 mod tests;
 
@@ -26,12 +27,17 @@ 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::PageBreak => layout.page_break(),
         }
     }
@@ -67,6 +73,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 +97,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/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,
     })
 }
 

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