calcsheet-native 0.1.0

data/ext/calcsheet_native/src/ods.rs

@@ -0,0 +1,815 @@
+//! The cells of one table of an ODS `content.xml`, read as calcsheet's `Ods::ContentParser` reads them through Ox
+//! (`skip: :skip_off`, `convert_special: false`, names with their prefixes), for the XML subset of `xml.rs`.
+//! Anything else, and any value calcsheet would refuse, makes the table `Unsupported`: the Ruby side then reads it
+//! with calcsheet's own parser. The state machine follows `ContentParser`'s callbacks one for one; the stream starts
+//! at the table start tag, or at a row inside it (see calcsheet's `Scanner#io_at_sheet`), and ends with the table.
+
+use std::collections::HashMap;
+
+use memchr::memchr;
+
+use crate::xml::{Item, Lexer, Result, Unsupported, decode, utf8};
+
+/// The rows and columns of calcsheet's grid.
+const MAX_ROWS: u64 = 1_048_576;
+const MAX_COLUMNS: u64 = 16_384;
+/// Cast::MAX_NUMBER_BYTES.
+const MAX_NUMBER_BYTES: usize = 1_024;
+/// Odf::MAX_SPACES.
+const MAX_SPACES: u64 = 32_767;
+/// Count::MAX_DIGITS.
+const MAX_DIGITS: usize = 18;
+
+/// The elements and attributes ContentParser reads, by qualified name.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Code {
+    Table,
+    Row,
+    Cell,
+    Covered,
+    Paragraph,
+    Spaces,
+    Tab,
+    LineBreak,
+    Column,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Attribute {
+    ValueType,
+    Value,
+    DateValue,
+    TimeValue,
+    BooleanValue,
+    StringValue,
+    CalcValueType,
+    ColumnsRepeated,
+    RowsRepeated,
+    SpaceCount,
+    StyleName,
+    DefaultStyle,
+}
+
+/// The kind of a cell's value type (ContentParser::KINDS), `Text` for another one.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum ValueKind {
+    Number,
+    IsoDate,
+    Duration,
+    Boolean,
+    String,
+    Text,
+}
+
+impl ValueKind {
+    /// ContentParser::VALUE_OF: the attribute that holds the value of the kind.
+    fn value_of(self) -> Option<Attribute> {
+        match self {
+            ValueKind::Number => Some(Attribute::Value),
+            ValueKind::IsoDate => Some(Attribute::DateValue),
+            ValueKind::Duration => Some(Attribute::TimeValue),
+            ValueKind::Boolean => Some(Attribute::BooleanValue),
+            ValueKind::String => Some(Attribute::StringValue),
+            ValueKind::Text => None,
+        }
+    }
+}
+
+/// The RowBuilder kind of a cell, as the Ruby side maps it.
+#[derive(Clone, Copy)]
+pub enum Kind {
+    Text = 0,
+    Number = 1,
+    IsoDate = 2,
+    Duration = 3,
+    Boolean = 4,
+    Error = 5,
+    Missing = 6,
+}
+
+/// A cell with a value: its first column, its repeat, kind, the reason of a missing value (0 :invalid_decimal, 1
+/// :invalid_date, 2 :invalid_boolean), its raw value in `out`, and its format: the index of its style's format, -1
+/// for a style without one, -2 for no style (the format of its column).
+pub struct Cell {
+    pub column: u64,
+    pub repeat: u64,
+    pub kind: Kind,
+    pub missing: u8,
+    pub start: usize,
+    pub end: usize,
+    pub format: i64,
+}
+
+/// A row with cells: its first number, its last (a repeated row) and its cells.
+pub struct Row {
+    pub number: u64,
+    pub last: u64,
+    pub cells: Vec<Cell>,
+}
+
+pub enum Stop {
+    NeedMore,
+    End,
+    Unsupported,
+    Full,
+}
+
+pub struct TableReader {
+    lexer: Lexer,
+    max_cell_bytes: Option<usize>,
+    start_row: u64,
+    done: bool,
+    unsupported: bool,
+    just_started: bool,
+    // Few names: a scan of the byte strings costs less than hashing each name.
+    elements: Vec<(Vec<u8>, Code)>,
+    attributes: Vec<(Vec<u8>, Attribute)>,
+    text_qualifier: Vec<u8>,
+    formats: HashMap<Vec<u8>, usize>,
+    // The texts of the rows handed out, and the bytes of them the next batch drops.
+    out: Vec<u8>,
+    consumed: usize,
+    row_start: usize,
+    // ContentParser's state.
+    next_row: u64,
+    columns: u64,
+    /// `[first, last, format]` of the columns whose default cell style has a format.
+    pub column_formats: Vec<(u64, u64, usize)>,
+    element: Option<Code>,
+    column_repeated: u64,
+    column_style: Option<i64>,
+    in_row: bool,
+    row_number: u64,
+    rows_repeated: u64,
+    row_style: Option<i64>,
+    column: u64,
+    in_cell: bool,
+    covered: bool,
+    depth: u32,
+    columns_repeated: u64,
+    kind: ValueKind,
+    value: Vec<u8>,
+    value_code: Option<Attribute>,
+    cell_style: Option<i64>,
+    error: bool,
+    text: Option<usize>,
+    paragraphs: u32,
+    paragraph: bool,
+    capture: bool,
+    ignored: Option<u32>,
+    spaces: u64,
+    space_count: Option<Vec<u8>>,
+    ignore_space: bool,
+    cells: Vec<Cell>,
+}
+
+impl TableReader {
+    /// `prefixes` are those of the table, office, text and calcext namespaces; `formats` the cell style names that
+    /// have a format, in the order of the formats the Ruby side holds.
+    pub fn new(
+        prefixes: [&str; 4],
+        formats: Vec<Vec<u8>>,
+        max_cell_bytes: Option<usize>,
+        first_row: u64,
+        start_row: u64,
+    ) -> Self {
+        let qualified = |prefix: &str, local: &str| {
+            if prefix.is_empty() {
+                local.as_bytes().to_vec()
+            } else {
+                format!("{prefix}:{local}").into_bytes()
+            }
+        };
+        let [table, office, text, calcext] = prefixes;
+        let elements = [
+            (qualified(table, "table"), Code::Table),
+            (qualified(table, "table-row"), Code::Row),
+            (qualified(table, "table-cell"), Code::Cell),
+            (qualified(table, "covered-table-cell"), Code::Covered),
+            (qualified(table, "table-column"), Code::Column),
+            (qualified(text, "p"), Code::Paragraph),
+            (qualified(text, "s"), Code::Spaces),
+            (qualified(text, "tab"), Code::Tab),
+            (qualified(text, "line-break"), Code::LineBreak),
+        ]
+        .into();
+        let attributes = [
+            (
+                qualified(table, "number-rows-repeated"),
+                Attribute::RowsRepeated,
+            ),
+            (
+                qualified(table, "number-columns-repeated"),
+                Attribute::ColumnsRepeated,
+            ),
+            (qualified(office, "value-type"), Attribute::ValueType),
+            (qualified(office, "value"), Attribute::Value),
+            (qualified(office, "date-value"), Attribute::DateValue),
+            (qualified(office, "time-value"), Attribute::TimeValue),
+            (qualified(office, "boolean-value"), Attribute::BooleanValue),
+            (qualified(office, "string-value"), Attribute::StringValue),
+            (qualified(calcext, "value-type"), Attribute::CalcValueType),
+            (qualified(text, "c"), Attribute::SpaceCount),
+            (qualified(table, "style-name"), Attribute::StyleName),
+            (
+                qualified(table, "default-cell-style-name"),
+                Attribute::DefaultStyle,
+            ),
+        ]
+        .into();
+        TableReader {
+            lexer: Lexer::new(),
+            max_cell_bytes,
+            start_row,
+            done: false,
+            unsupported: false,
+            just_started: false,
+            elements,
+            attributes,
+            text_qualifier: if text.is_empty() {
+                Vec::new()
+            } else {
+                format!("{text}:").into_bytes()
+            },
+            formats: formats
+                .into_iter()
+                .enumerate()
+                .map(|(index, name)| (name, index))
+                .collect(),
+            out: Vec::new(),
+            consumed: 0,
+            row_start: 0,
+            next_row: first_row,
+            columns: 0,
+            column_formats: Vec::new(),
+            element: None,
+            column_repeated: 1,
+            column_style: None,
+            in_row: false,
+            row_number: 0,
+            rows_repeated: 1,
+            row_style: None,
+            column: 0,
+            in_cell: false,
+            covered: false,
+            depth: 0,
+            columns_repeated: 1,
+            kind: ValueKind::Text,
+            value: Vec::new(),
+            value_code: None,
+            cell_style: None,
+            error: false,
+            text: None,
+            paragraphs: 0,
+            paragraph: false,
+            capture: false,
+            ignored: None,
+            spaces: 0,
+            space_count: None,
+            ignore_space: false,
+            cells: Vec::new(),
+        }
+    }
+
+    pub fn feed(&mut self, chunk: &[u8]) {
+        self.lexer.feed(chunk);
+    }
+
+    pub fn finish(&mut self) {
+        self.lexer.eof = true;
+    }
+
+    /// The raw value of a cell of the last batch.
+    pub fn value(&self, cell: &Cell) -> &[u8] {
+        &self.out[cell.start..cell.end]
+    }
+
+    /// Reads items until `max` rows with cells are complete, the text fed so far ends, or the table ends.
+    pub fn rows(&mut self, max: usize) -> (Vec<Row>, Stop) {
+        self.drop_consumed();
+        let mut rows = Vec::new();
+        let stop = if self.unsupported {
+            Stop::Unsupported
+        } else if self.done {
+            Stop::End
+        } else {
+            self.read(max, &mut rows)
+        };
+        if matches!(stop, Stop::Unsupported) {
+            self.unsupported = true;
+        }
+        self.consumed = if self.in_row {
+            self.row_start
+        } else {
+            self.out.len()
+        };
+        (rows, stop)
+    }
+
+    fn read(&mut self, max: usize, rows: &mut Vec<Row>) -> Stop {
+        while rows.len() < max {
+            let result = match self.lexer.item() {
+                Ok(Some(item)) => self.handle(item, rows),
+                // The table ends with its end tag: an end of the text before it is left to Ox.
+                Ok(None) if self.lexer.eof => return Stop::Unsupported,
+                Ok(None) => return Stop::NeedMore,
+                Err(Unsupported) => return Stop::Unsupported,
+            };
+            match result {
+                Ok(true) => {
+                    self.done = true;
+                    return Stop::End;
+                }
+                Ok(false) => {}
+                Err(Unsupported) => return Stop::Unsupported,
+            }
+        }
+        Stop::Full
+    }
+
+    fn drop_consumed(&mut self) {
+        let consumed = self.consumed;
+        if consumed == 0 {
+            return;
+        }
+        self.out.drain(..consumed);
+        for cell in &mut self.cells {
+            cell.start -= consumed;
+            cell.end -= consumed;
+        }
+        if let Some(text) = self.text.as_mut() {
+            *text -= consumed;
+        }
+        self.row_start = self.row_start.saturating_sub(consumed);
+        self.consumed = 0;
+    }
+
+    /// Handles an item; true at the end of the table. Ox hands over an empty text for an element without content
+    /// (`<a></a>`) and the white space of an element without children twice (`<a> </a>`); the second report changes
+    /// nothing (#text drops white space after a space), so only the first is made here.
+    fn handle(&mut self, item: Item, rows: &mut Vec<Row>) -> Result<bool> {
+        let just_started = std::mem::replace(&mut self.just_started, false);
+        match item {
+            Item::Text(start, end) => {
+                self.text(start, end)?;
+                Ok(false)
+            }
+            Item::Start(name_start, name_end, empty) => {
+                self.start_element(name_start, name_end)?;
+                if empty {
+                    self.end_element(name_start, name_end, rows)
+                } else {
+                    self.just_started = true;
+                    Ok(false)
+                }
+            }
+            Item::End(name_start, name_end) => {
+                if just_started {
+                    let at = self.lexer.pos;
+                    self.text(at, at)?;
+                }
+                self.end_element(name_start, name_end, rows)
+            }
+        }
+    }
+
+    fn code(&self, start: usize, end: usize) -> Option<Code> {
+        let name = &self.lexer.buf[start..end];
+        self.elements
+            .iter()
+            .find(|(known, _)| known.as_slice() == name)
+            .map(|&(_, code)| code)
+    }
+
+    /// The format index of a style name: -1 for a style without a format.
+    fn style(&self, name: &[u8]) -> i64 {
+        self.formats.get(name).map_or(-1, |&index| index as i64)
+    }
+
+    fn start_element(&mut self, name_start: usize, name_end: usize) -> Result<()> {
+        if self.in_cell {
+            self.depth += 1;
+            self.element = None;
+            if self.paragraph {
+                self.start_in_paragraph(name_start, name_end);
+            } else if self.depth == 1 && self.code(name_start, name_end) == Some(Code::Paragraph) {
+                self.begin_paragraph()?;
+            }
+            return self.attributes();
+        }
+        let code = self.code(name_start, name_end);
+        self.element = code;
+        match code {
+            Some(Code::Row) => self.begin_row()?,
+            Some(Code::Cell | Code::Covered) => {
+                if !self.in_row {
+                    return Err(Unsupported);
+                }
+                self.begin_cell(code == Some(Code::Covered));
+            }
+            Some(Code::Column) => {
+                self.column_repeated = 1;
+                self.column_style = None;
+            }
+            _ => {}
+        }
+        self.attributes()
+    }
+
+    fn end_element(
+        &mut self,
+        name_start: usize,
+        name_end: usize,
+        rows: &mut Vec<Row>,
+    ) -> Result<bool> {
+        if self.in_cell {
+            if self.depth == 0 {
+                self.finish_cell()?;
+                return Ok(false);
+            }
+            if self.paragraph {
+                self.end_in_paragraph()?;
+            }
+            self.element = None;
+            self.depth -= 1;
+            return Ok(false);
+        }
+        match self.code(name_start, name_end) {
+            Some(Code::Row) if self.in_row => self.finish_row(rows)?,
+            Some(Code::Column) => self.finish_column(),
+            Some(Code::Table) => return Ok(true),
+            _ => {}
+        }
+        Ok(false)
+    }
+
+    /// ContentParser#attr, for the attributes of the start tag just read.
+    fn attributes(&mut self) -> Result<()> {
+        self.lexer.check_unique()?;
+        let Some(element) = self.element else {
+            return Ok(());
+        };
+        for index in 0..self.lexer.attrs.len() {
+            let (name_start, name_end, value_start, value_end) = self.lexer.attrs[index];
+            let name = &self.lexer.buf[name_start..name_end];
+            let Some(&(_, attribute)) = self
+                .attributes
+                .iter()
+                .find(|(known, _)| known.as_slice() == name)
+            else {
+                continue;
+            };
+            let value = &self.lexer.buf[value_start..value_end];
+            match (element, attribute) {
+                (Code::Cell, Attribute::ValueType) => {
+                    self.kind = match value {
+                        b"float" | b"percentage" | b"currency" => ValueKind::Number,
+                        b"date" => ValueKind::IsoDate,
+                        b"time" => ValueKind::Duration,
+                        b"boolean" => ValueKind::Boolean,
+                        b"string" => ValueKind::String,
+                        _ => ValueKind::Text,
+                    }
+                }
+                (
+                    Code::Cell,
+                    Attribute::Value
+                    | Attribute::DateValue
+                    | Attribute::TimeValue
+                    | Attribute::BooleanValue
+                    | Attribute::StringValue,
+                ) => {
+                    self.value.clear();
+                    self.value.extend_from_slice(value);
+                    self.value_code = Some(attribute);
+                }
+                (Code::Cell, Attribute::CalcValueType) => self.error = value == b"error",
+                (Code::Cell | Code::Covered, Attribute::ColumnsRepeated) => {
+                    self.columns_repeated = repeat(value)?
+                }
+                (Code::Cell, Attribute::StyleName) => self.cell_style = Some(self.style(value)),
+                (Code::Row, Attribute::RowsRepeated) => self.rows_repeated = repeat(value)?,
+                (Code::Row, Attribute::DefaultStyle) => self.row_style = Some(self.style(value)),
+                (Code::Column, Attribute::ColumnsRepeated) => self.column_repeated = repeat(value)?,
+                (Code::Column, Attribute::DefaultStyle) => {
+                    self.column_style = Some(self.style(value))
+                }
+                (Code::Spaces, Attribute::SpaceCount) => self.space_count = Some(value.to_vec()),
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+
+    /// ContentParser#text: the text of a paragraph, its references decoded, collapsed as ODF collapses white space.
+    fn text(&mut self, start: usize, end: usize) -> Result<()> {
+        if !(self.capture && self.paragraph && self.ignored.is_none()) {
+            return Ok(());
+        }
+        let piece = &self.lexer.buf[start..end];
+        let decoded;
+        let value: &[u8] = if memchr(b'&', piece).is_some() {
+            decoded = decode(piece)?;
+            &decoded
+        } else {
+            piece
+        };
+        utf8(value)?;
+        let collapsible = value.iter().any(|&c| matches!(c, b'\t' | b'\n' | b'\r'))
+            || memchr::memmem::find(value, b"  ").is_some();
+        if (self.ignore_space && value.first().copied().is_some_and(white)) || collapsible {
+            let mut collapsed = Vec::with_capacity(value.len());
+            for &c in value {
+                let c = if white(c) { b' ' } else { c };
+                if !(c == b' ' && collapsed.last() == Some(&b' ')) {
+                    collapsed.push(c);
+                }
+            }
+            if self.ignore_space && collapsed.first() == Some(&b' ') {
+                collapsed.remove(0);
+            }
+            if collapsed.is_empty() {
+                return Ok(());
+            }
+            self.ignore_space = collapsed.last() == Some(&b' ');
+            return self.append(&collapsed);
+        }
+        self.ignore_space = value.last() == Some(&b' ');
+        // `value` may borrow the lexer's buffer: #append's fields are borrowed one by one.
+        append(&mut self.out, &mut self.text, self.max_cell_bytes, value)
+    }
+
+    fn start_in_paragraph(&mut self, name_start: usize, name_end: usize) {
+        if self.ignored.is_some() {
+            return;
+        }
+        match self.code(name_start, name_end) {
+            Some(code @ (Code::Spaces | Code::Tab | Code::LineBreak)) => {
+                self.element = Some(code);
+                self.space_count = None;
+            }
+            None if !self.text_element(name_start, name_end) => self.ignored = Some(self.depth),
+            _ => {}
+        }
+    }
+
+    fn end_in_paragraph(&mut self) -> Result<()> {
+        if let Some(depth) = self.ignored {
+            if depth == self.depth {
+                self.ignored = None;
+            }
+        } else if self.depth == 1 {
+            self.paragraph = false;
+        } else if self.capture {
+            self.control()?;
+        }
+        Ok(())
+    }
+
+    fn text_element(&self, start: usize, end: usize) -> bool {
+        self.text_qualifier.is_empty()
+            || self.lexer.buf[start..end].starts_with(&self.text_qualifier)
+    }
+
+    fn begin_paragraph(&mut self) -> Result<()> {
+        self.paragraph = true;
+        if self.paragraphs == 0 {
+            self.capture = self.wants_text();
+        }
+        self.paragraphs += 1;
+        if !self.capture {
+            return Ok(());
+        }
+        if self.paragraphs > 1 {
+            self.append(b"\n")?;
+        }
+        self.ignore_space = true;
+        Ok(())
+    }
+
+    fn wants_text(&self) -> bool {
+        !self.covered
+            && (self.error || self.value_code.is_none() || self.value_code != self.kind.value_of())
+    }
+
+    /// The end of a text:s, text:tab or text:line-break element of a paragraph.
+    fn control(&mut self) -> Result<()> {
+        match self.element {
+            Some(Code::Spaces) => {
+                let count = self.space_count.as_deref().and_then(count).unwrap_or(1);
+                self.spaces += count;
+                if self.spaces > MAX_SPACES {
+                    return Err(Unsupported);
+                }
+                self.append(&vec![b' '; count as usize])?;
+            }
+            Some(Code::Tab) => self.append(b"\t")?,
+            Some(Code::LineBreak) => self.append(b"\n")?,
+            _ => return Ok(()),
+        }
+        self.ignore_space = false;
+        Ok(())
+    }
+
+    /// Joins a piece to the text, measured first: a text longer than max_cell_bytes is left to calcsheet.
+    fn append(&mut self, piece: &[u8]) -> Result<()> {
+        append(&mut self.out, &mut self.text, self.max_cell_bytes, piece)
+    }
+
+    // ---- columns, rows and cells ----
+
+    fn finish_column(&mut self) {
+        let first = self.columns;
+        self.columns = self.columns.saturating_add(self.column_repeated);
+        let Some(format) = self.column_style else {
+            return;
+        };
+        if format >= 0 && first < MAX_COLUMNS {
+            self.column_formats
+                .push((first, self.columns - 1, format as usize));
+        }
+    }
+
+    fn begin_row(&mut self) -> Result<()> {
+        if self.in_row {
+            return Err(Unsupported);
+        }
+        self.in_row = true;
+        self.row_number = self.next_row;
+        self.row_style = None;
+        self.rows_repeated = 1;
+        self.column = 0;
+        self.row_start = self.out.len();
+        Ok(())
+    }
+
+    fn finish_row(&mut self, rows: &mut Vec<Row>) -> Result<()> {
+        self.in_row = false;
+        let number = self.row_number;
+        let last = number
+            .checked_add(self.rows_repeated - 1)
+            .ok_or(Unsupported)?;
+        self.next_row = last.checked_add(1).ok_or(Unsupported)?;
+        if self.cells.is_empty() {
+            return Ok(());
+        }
+        // ContentParser refuses a non-blank row beyond the grid; the builder decides what is blank.
+        if last > MAX_ROWS && last >= self.start_row {
+            return Err(Unsupported);
+        }
+        let cells = std::mem::take(&mut self.cells);
+        rows.push(Row {
+            number,
+            last,
+            cells,
+        });
+        Ok(())
+    }
+
+    fn begin_cell(&mut self, covered: bool) {
+        self.in_cell = true;
+        self.covered = covered;
+        self.depth = 0;
+        self.columns_repeated = 1;
+        self.kind = ValueKind::Text;
+        self.value.clear();
+        self.value_code = None;
+        self.cell_style = None;
+        self.error = false;
+        self.text = None;
+        self.paragraphs = 0;
+        self.paragraph = false;
+        self.capture = false;
+        self.ignored = None;
+        self.spaces = 0;
+    }
+
+    fn finish_cell(&mut self) -> Result<()> {
+        self.in_cell = false;
+        let column = self.column;
+        let repeat = self.columns_repeated;
+        self.column = column.checked_add(repeat).ok_or(Unsupported)?;
+        let text_start = self.text.take();
+        let raw = if self.covered {
+            None
+        } else {
+            self.raw_value(text_start)?
+        };
+        let Some((kind, missing, start)) = raw else {
+            if let Some(start) = text_start {
+                self.out.truncate(start);
+            }
+            return Ok(());
+        };
+        if self.column > MAX_COLUMNS {
+            return Err(Unsupported);
+        }
+        let format = self.cell_style.or(self.row_style).unwrap_or(-2);
+        self.cells.push(Cell {
+            column,
+            repeat,
+            kind,
+            missing,
+            start,
+            end: self.out.len(),
+            format,
+        });
+        Ok(())
+    }
+
+    /// ContentParser#raw_value: the kind, the reason of a missing value and where the raw value starts in `out`;
+    /// `None` for an empty cell.
+    fn raw_value(&mut self, text_start: Option<usize>) -> Result<Option<(Kind, u8, usize)>> {
+        let text_end = self.out.len();
+        let start = text_start.unwrap_or(text_end);
+        if self.error {
+            utf8(&self.out[start..])?;
+            return Ok(Some((Kind::Error, 0, start)));
+        }
+        if self.value_code.is_some() && self.value_code == self.kind.value_of() {
+            // The value attribute replaces the text.
+            self.out.truncate(start);
+            if self.kind == ValueKind::String {
+                if self
+                    .max_cell_bytes
+                    .is_some_and(|max| self.value.len() > max)
+                {
+                    return Err(Unsupported);
+                }
+                utf8(&self.value)?;
+                if self.value.is_empty() {
+                    return Ok(None);
+                }
+                self.out.extend_from_slice(&self.value);
+                return Ok(Some((Kind::Text, 0, start)));
+            }
+            if self.value.len() > MAX_NUMBER_BYTES {
+                return Err(Unsupported);
+            }
+            utf8(&self.value)?;
+            self.out.extend_from_slice(&self.value);
+            let kind = match self.kind {
+                ValueKind::Number => Kind::Number,
+                ValueKind::IsoDate => Kind::IsoDate,
+                ValueKind::Duration => Kind::Duration,
+                _ => Kind::Boolean,
+            };
+            return Ok(Some((kind, 0, start)));
+        }
+        match self.kind {
+            ValueKind::Text | ValueKind::String => {
+                if text_start.is_none() || start == text_end {
+                    return Ok(None);
+                }
+                utf8(&self.out[start..])?;
+                Ok(Some((Kind::Text, 0, start)))
+            }
+            kind => {
+                utf8(&self.out[start..])?;
+                let missing = match kind {
+                    ValueKind::IsoDate => 1,
+                    ValueKind::Boolean => 2,
+                    _ => 0,
+                };
+                Ok(Some((Kind::Missing, missing, start)))
+            }
+        }
+    }
+}
+
+/// Joins a piece to the text that starts at `text` in `out` (or here, for the first piece), measured first.
+fn append(
+    out: &mut Vec<u8>,
+    text: &mut Option<usize>,
+    max_cell_bytes: Option<usize>,
+    piece: &[u8],
+) -> Result<()> {
+    let start = *text.get_or_insert(out.len());
+    if max_cell_bytes.is_some_and(|max| out.len() - start + piece.len() > max) {
+        return Err(Unsupported);
+    }
+    out.extend_from_slice(piece);
+    Ok(())
+}
+
+/// White space of XML: space, tab, line feed and carriage return.
+fn white(c: u8) -> bool {
+    matches!(c, b' ' | b'\t' | b'\n' | b'\r')
+}
+
+/// Count.parse: ASCII digits only, at most MAX_DIGITS of them.
+fn count(value: &[u8]) -> Option<u64> {
+    if value.is_empty() || value.len() > MAX_DIGITS || !value.iter().all(u8::is_ascii_digit) {
+        return None;
+    }
+    Some(
+        value
+            .iter()
+            .fold(0u64, |count, &digit| count * 10 + u64::from(digit - b'0')),
+    )
+}
+
+/// ContentParser#repeat: a positive count, else calcsheet raises.
+fn repeat(value: &[u8]) -> Result<u64> {
+    count(value).filter(|&count| count > 0).ok_or(Unsupported)
+}