imprimatur 0.1.0 → 0.3.0

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

@@ -0,0 +1,244 @@
+//! Compound files (MS-CFB): the container legacy Office documents are, a
+//! small FAT file system inside one file. Reading a stream of the root
+//! storage by name is all the readers need.
+
+#[cfg(test)]
+mod tests;
+
+use crate::read::Budget;
+use crate::{Error, Result};
+
+/// The first eight bytes of every compound file.
+pub const SIGNATURE: [u8; 8] = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+/// Sector numbers above this are markers: end of chain, free, FAT, DIFAT.
+const MAX_SECTOR: u32 = 0xFFFF_FFFA;
+/// No sibling or child in the directory tree.
+const NO_STREAM: u32 = 0xFFFF_FFFF;
+const MINI_SECTOR: usize = 64;
+const ENTRY: usize = 128;
+
+/// A compound file's allocation tables and the root storage's entries.
+pub struct Ole<'a> {
+    data: &'a [u8],
+    sector: usize,
+    fat: Vec<u32>,
+    mini_fat: Vec<u32>,
+    mini_stream: Vec<u8>,
+    mini_cutoff: u64,
+    /// The root storage's children: name, whether a stream, start, size.
+    entries: Vec<(String, bool, u32, u64)>,
+}
+
+fn malformed(reason: &str) -> Error {
+    Error::malformed("compound file", reason)
+}
+
+/// An allocation table's sector numbers.
+fn words(bytes: &[u8]) -> impl Iterator<Item = u32> + '_ {
+    bytes.as_chunks::<4>().0.iter().map(|word| u32::from_le_bytes(*word))
+}
+
+fn u16_at(bytes: &[u8], at: usize) -> Option<u16> {
+    Some(u16::from_le_bytes(bytes.get(at..at.checked_add(2)?)?.try_into().ok()?))
+}
+
+fn u32_at(bytes: &[u8], at: usize) -> Option<u32> {
+    Some(u32::from_le_bytes(bytes.get(at..at.checked_add(4)?)?.try_into().ok()?))
+}
+
+impl<'a> Ole<'a> {
+    /// Reads the header, the allocation tables and the directory.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a file that is not a compound file or whose
+    /// tables point outside it or in circles.
+    pub fn open(data: &'a [u8], budget: &Budget<'_>) -> Result<Self> {
+        if !data.starts_with(&SIGNATURE) || data.len() < 512 {
+            return Err(malformed("no compound file header"));
+        }
+        let header = |at| u32_at(data, at).ok_or_else(|| malformed("a short header"));
+        let sector = match u16_at(data, 0x1E) {
+            Some(9) => 512,
+            Some(12) => 4096,
+            _ => return Err(malformed("an unknown sector size")),
+        };
+        let mut ole = Self {
+            data,
+            sector,
+            fat: Vec::new(),
+            mini_fat: Vec::new(),
+            mini_stream: Vec::new(),
+            mini_cutoff: u64::from(header(0x38)?),
+            entries: Vec::new(),
+        };
+        // The FAT's own sectors: 109 listed in the header, the rest in a
+        // chain of DIFAT sectors, each ending with the next one's number.
+        let mut fat_sectors: Vec<u32> = (0..109)
+            .filter_map(|index| u32_at(data, 0x4C + index * 4))
+            .filter(|&s| s <= MAX_SECTOR)
+            .collect();
+        let mut next = header(0x44)?;
+        let per_sector = sector / 4;
+        for _ in 0..=data.len() / sector {
+            if next > MAX_SECTOR {
+                break;
+            }
+            let bytes = ole.sector_bytes(next)?;
+            fat_sectors.extend(
+                (0..per_sector - 1)
+                    .filter_map(|index| u32_at(bytes, index * 4))
+                    .filter(|&s| s <= MAX_SECTOR),
+            );
+            next = u32_at(bytes, (per_sector - 1) * 4).unwrap_or(NO_STREAM);
+        }
+        budget.inflate(fat_sectors.len().saturating_mul(sector))?;
+        for number in fat_sectors {
+            budget.tick()?;
+            let bytes = ole.sector_bytes(number)?;
+            ole.fat.extend(words(bytes));
+        }
+        let directory = ole.chain(header(0x30)?, None, budget)?;
+        let first_mini_fat = header(0x3C)?;
+        if first_mini_fat <= MAX_SECTOR {
+            let table = ole.chain(first_mini_fat, None, budget)?;
+            ole.mini_fat = words(&table).collect();
+        }
+        let root = directory.get(..ENTRY).ok_or_else(|| malformed("no root entry"))?;
+        if root[0x42] != 5 {
+            return Err(malformed("the first entry is not the root"));
+        }
+        // The whole chain: some writers give the root the size of the one
+        // stream in it, short of the last mini sector it fills.
+        let (start, _) = location(root, sector);
+        ole.mini_stream =
+            if start <= MAX_SECTOR { ole.chain(start, None, budget)? } else { Vec::new() };
+        ole.entries = children(&directory, sector, budget)?;
+        Ok(ole)
+    }
+
+    /// The bytes of the stream `name` in the root storage, its name
+    /// compared regardless of case; `None` when there is none.
+    ///
+    /// # Errors
+    /// [`Error::Malformed`] for a stream whose sectors are missing or loop.
+    pub fn stream(&self, name: &str, budget: &Budget<'_>) -> Result<Option<Vec<u8>>> {
+        let Some(&(_, _, start, size)) = self
+            .entries
+            .iter()
+            .find(|(entry, stream, ..)| *stream && entry.eq_ignore_ascii_case(name))
+        else {
+            return Ok(None);
+        };
+        if size < self.mini_cutoff {
+            return self.mini_chain(start, size, budget).map(Some);
+        }
+        self.chain(start, Some(size), budget).map(Some)
+    }
+
+    fn sector_bytes(&self, number: u32) -> Result<&'a [u8]> {
+        let start = (number as usize + 1)
+            .checked_mul(self.sector)
+            .ok_or_else(|| malformed("a sector out of range"))?;
+        self.data
+            .get(start..start + self.sector)
+            .ok_or_else(|| malformed("a sector past the end of the file"))
+    }
+
+    /// The sectors chained from `start`, cut to `size` when given.
+    fn chain(&self, start: u32, size: Option<u64>, budget: &Budget<'_>) -> Result<Vec<u8>> {
+        let limit = size.map_or(usize::MAX, |size| usize::try_from(size).unwrap_or(usize::MAX));
+        if limit != usize::MAX && limit > self.data.len() {
+            return Err(malformed("a stream larger than the file"));
+        }
+        let mut out = Vec::with_capacity(limit.min(self.data.len()));
+        let mut seen = vec![false; self.fat.len()];
+        let mut next = start;
+        while next <= MAX_SECTOR && out.len() < limit {
+            budget.tick()?;
+            let visited =
+                seen.get_mut(next as usize).ok_or_else(|| malformed("a sector beyond the FAT"))?;
+            if std::mem::replace(visited, true) {
+                return Err(malformed("a sector chain that loops"));
+            }
+            out.extend_from_slice(self.sector_bytes(next)?);
+            next = self.fat[next as usize];
+        }
+        out.truncate(limit);
+        budget.inflate(out.len())?;
+        Ok(out)
+    }
+
+    /// A small stream, kept in the root's mini stream in 64-byte sectors.
+    fn mini_chain(&self, start: u32, size: u64, budget: &Budget<'_>) -> Result<Vec<u8>> {
+        let limit = usize::try_from(size).unwrap_or(usize::MAX);
+        let mut out = Vec::with_capacity(limit.min(self.mini_stream.len()));
+        let mut seen = vec![false; self.mini_fat.len()];
+        let mut next = start;
+        while next <= MAX_SECTOR && out.len() < limit {
+            budget.tick()?;
+            let visited = seen
+                .get_mut(next as usize)
+                .ok_or_else(|| malformed("a sector beyond the mini FAT"))?;
+            if std::mem::replace(visited, true) {
+                return Err(malformed("a mini sector chain that loops"));
+            }
+            let at = next as usize * MINI_SECTOR;
+            let bytes = self
+                .mini_stream
+                .get(at..at + MINI_SECTOR)
+                .ok_or_else(|| malformed("a mini sector past the mini stream"))?;
+            out.extend_from_slice(bytes);
+            next = self.mini_fat[next as usize];
+        }
+        out.truncate(limit);
+        budget.inflate(out.len())?;
+        Ok(out)
+    }
+}
+
+/// An entry's first sector and size; files of 512-byte sectors (version 3)
+/// leave the size's high half undefined.
+fn location(entry: &[u8], sector: usize) -> (u32, u64) {
+    let start = u32_at(entry, 0x74).unwrap_or(NO_STREAM);
+    let low = u64::from(u32_at(entry, 0x78).unwrap_or(0));
+    let high = if sector == 512 { 0 } else { u64::from(u32_at(entry, 0x7C).unwrap_or(0)) };
+    (start, high << 32 | low)
+}
+
+/// The root storage's children, from the red-black tree under its child
+/// pointer: name, whether a stream, first sector, size.
+fn children(
+    directory: &[u8],
+    sector: usize,
+    budget: &Budget<'_>,
+) -> Result<Vec<(String, bool, u32, u64)>> {
+    let entry = |index: u32| directory.get(index as usize * ENTRY..(index as usize + 1) * ENTRY);
+    let mut found = Vec::new();
+    let mut pending = vec![u32_at(directory, 0x4C).unwrap_or(NO_STREAM)];
+    let mut visits = 0_usize;
+    while let Some(index) = pending.pop() {
+        if index == NO_STREAM {
+            continue;
+        }
+        visits += 1;
+        if visits > directory.len() / ENTRY {
+            return Err(malformed("a directory tree that loops"));
+        }
+        budget.tick()?;
+        let Some(bytes) = entry(index) else {
+            return Err(malformed("a directory entry past the end"));
+        };
+        let length = usize::from(u16_at(bytes, 0x40).unwrap_or(0)).min(64).saturating_sub(2);
+        let units: Vec<u16> = bytes[..length]
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .map(|unit| u16::from_le_bytes(*unit))
+            .collect();
+        let (start, size) = location(bytes, sector);
+        found.push((String::from_utf16_lossy(&units), bytes[0x42] == 2, start, size));
+        pending.push(u32_at(bytes, 0x44).unwrap_or(NO_STREAM));
+        pending.push(u32_at(bytes, 0x48).unwrap_or(NO_STREAM));
+    }
+    Ok(found)
+}

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

@@ -86,11 +86,6 @@ impl<'a> Package<'a> {
         self.text(&part.target)?.map_or_else(|| Ok(T::default()), |text| parse(&text))
     }
 
-    /// The parts' names.
-    pub fn parts(&self) -> impl Iterator<Item = &'a str> + '_ {
-        self.zip.names()
-    }
-
     /// A part's bytes, `None` when the package has no such part.
     pub fn part(&self, name: &str) -> Result<Option<Vec<u8>>> {
         self.zip.read(name, self.budget)

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> {