imprimatur 0.1.0

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

@@ -0,0 +1,191 @@
+//! The Open Packaging Conventions side of reading: content types, and the
+//! relationships that lead from one part to the next.
+
+use std::borrow::Cow;
+
+use super::{Budget, Format};
+use crate::xml::reader::{Event, XmlReader, into_text};
+use crate::zip::reader::ZipReader;
+use crate::{Error, Result};
+
+const OFFICE_DOCUMENT: &str = "officeDocument";
+
+/// A relationship from a part: its id, its type's last segment
+/// (`worksheet`, `styles`, `hyperlink`...) and its target, resolved to a
+/// part name unless it is external.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Relationship {
+    pub id: String,
+    pub kind: String,
+    pub target: String,
+    pub external: bool,
+}
+
+pub struct Package<'a> {
+    zip: &'a ZipReader<'a>,
+    budget: &'a Budget<'a>,
+    main: String,
+    content_type: String,
+}
+
+impl<'a> Package<'a> {
+    /// Finds the main part through the package relationships.
+    pub fn open(zip: &'a ZipReader<'a>, budget: &'a Budget<'a>) -> Result<Self> {
+        let mut package = Self { zip, budget, main: String::new(), content_type: String::new() };
+        let main = package
+            .relationships("")?
+            .into_iter()
+            .find(|relationship| relationship.kind == OFFICE_DOCUMENT && !relationship.external)
+            .ok_or_else(|| {
+                Error::UnsupportedDocument("a zip that is not an Office document".to_owned())
+            })?;
+        package.content_type = package.content_type_of(&main.target)?;
+        package.main = main.target;
+        Ok(package)
+    }
+
+    pub fn main(&self) -> &str {
+        &self.main
+    }
+
+    /// What the main part's content type says the document is.
+    pub fn format(&self) -> Result<Format> {
+        let kind = &self.content_type;
+        let unsupported = || Error::UnsupportedDocument(format!("content type {kind}"));
+        if kind.contains("binary") {
+            return Err(unsupported());
+        }
+        if kind.contains("spreadsheetml") || kind.contains("ms-excel") {
+            Ok(Format::Xlsx)
+        } else if kind.contains("wordprocessingml") || kind.contains("ms-word") {
+            Ok(Format::Docx)
+        } else {
+            Err(unsupported())
+        }
+    }
+
+    /// The main part's text: the workbook, or the document.
+    pub fn main_text(&self) -> Result<String> {
+        self.text(&self.main)?.ok_or_else(|| {
+            let format = if self.format().ok() == Some(Format::Xlsx) { "XLSX" } else { "DOCX" };
+            Error::malformed(format, format!("the part {} is missing", self.main))
+        })
+    }
+
+    /// Parses the part `source` relates to as `kind`, or gives the default
+    /// when there is none: styles, shared strings, numbering.
+    pub fn parse_related<T: Default>(
+        &self,
+        relationships: &[Relationship],
+        kind: &str,
+        parse: impl FnOnce(&str) -> Result<T>,
+    ) -> Result<T> {
+        let Some(part) = relationships.iter().find(|r| r.kind == kind && !r.external) else {
+            return Ok(T::default());
+        };
+        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)
+    }
+
+    /// The relationships of `source` (`""` for the package's own), in order.
+    pub fn relationships(&self, source: &str) -> Result<Vec<Relationship>> {
+        let (folder, file) = source.rsplit_once('/').unwrap_or(("", source));
+        let rels = if folder.is_empty() {
+            format!("_rels/{file}.rels")
+        } else {
+            format!("{folder}/_rels/{file}.rels")
+        };
+        let Some(text) = self.text(&rels)? else {
+            return Ok(Vec::new());
+        };
+        let mut xml = XmlReader::new(&text, self.budget.max_depth());
+        let mut found = Vec::new();
+        while let Some(event) = xml.next()? {
+            let Event::Start(tag) = event else { continue };
+            if tag.name() != "Relationship" {
+                continue;
+            }
+            let (Some(id), Some(kind), Some(target)) =
+                (tag.attr("Id"), tag.attr("Type"), tag.attr("Target"))
+            else {
+                continue;
+            };
+            let external = tag.attr("TargetMode").is_some_and(|mode| mode == "External");
+            let kind = kind.rsplit('/').next().unwrap_or_default().to_owned();
+            let target = if external { target.into_owned() } else { resolve(folder, &target) };
+            found.push(Relationship { id: id.into_owned(), kind, target, external });
+        }
+        Ok(found)
+    }
+
+    /// The target of `source`'s first relationship of `kind`.
+    pub fn related(&self, source: &str, kind: &str) -> Result<Option<String>> {
+        Ok(self
+            .relationships(source)?
+            .into_iter()
+            .find(|relationship| relationship.kind == kind && !relationship.external)
+            .map(|relationship| relationship.target))
+    }
+
+    /// A part as text, `None` when missing.
+    pub fn text(&self, name: &str) -> Result<Option<String>> {
+        self.part(name)?.map(into_text).transpose()
+    }
+
+    fn content_type_of(&self, part: &str) -> Result<String> {
+        let text = self
+            .text("[Content_Types].xml")?
+            .ok_or_else(|| Error::UnsupportedDocument("a zip without content types".to_owned()))?;
+        let mut xml = XmlReader::new(&text, self.budget.max_depth());
+        let extension = part.rsplit_once('.').map_or("", |(_, extension)| extension);
+        let mut default = None;
+        while let Some(event) = xml.next()? {
+            let Event::Start(tag) = event else { continue };
+            match tag.name() {
+                "Override"
+                    if tag.attr("PartName").is_some_and(|name| {
+                        name.trim_start_matches('/').eq_ignore_ascii_case(part)
+                    }) =>
+                {
+                    return Ok(tag.attr("ContentType").unwrap_or_default().into_owned());
+                }
+                "Default"
+                    if tag
+                        .attr("Extension")
+                        .is_some_and(|ext| ext.eq_ignore_ascii_case(extension)) =>
+                {
+                    default = tag.attr("ContentType").map(Cow::into_owned);
+                }
+                _ => {}
+            }
+        }
+        Ok(default.unwrap_or_default())
+    }
+}
+
+/// A relationship target as a part name: relative to the source's folder,
+/// or absolute with a leading `/`.
+fn resolve(folder: &str, target: &str) -> String {
+    let (base, target) =
+        target.strip_prefix('/').map_or((folder, target), |absolute| ("", absolute));
+    let mut segments: Vec<&str> = base.split('/').filter(|segment| !segment.is_empty()).collect();
+    for segment in target.split('/') {
+        match segment {
+            "" | "." => {}
+            ".." => {
+                segments.pop();
+            }
+            segment => segments.push(segment),
+        }
+    }
+    segments.join("/")
+}

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

@@ -0,0 +1,216 @@
+//! `CMaps` (ISO 32000-1, 9.7.5 and 9.10.3): how many bytes a character code
+//! takes, which CID it is, and the text it stands for.
+
+#[cfg(test)]
+mod tests;
+
+use std::ops::Range;
+
+use super::glyphs::named;
+use super::lexer::{Lexer, Token, hex_bytes, name_bytes};
+use crate::read::span;
+
+/// Where a code range's text comes from.
+#[derive(Debug, Clone)]
+enum Target {
+    /// One text for one code, or the first of a range whose last
+    /// character counts up with the code.
+    Text(Range<u32>),
+    /// One text per code of the range.
+    List(Vec<Range<u32>>),
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct CMap {
+    /// Code space ranges: low, high and length in bytes.
+    spaces: Vec<(u32, u32, u8)>,
+    /// Code ranges to text, sorted by their low end.
+    unicode: Vec<(u32, u32, Target)>,
+    /// Code ranges to CIDs: low, high, first CID.
+    cids: Vec<(u32, u32, u32)>,
+    text: String,
+}
+
+impl CMap {
+    pub fn parse(data: &[u8]) -> Self {
+        let mut cmap = Self::default();
+        let mut lexer = Lexer::new(data, 0);
+        let mut operands: Vec<Token<'_>> = Vec::new();
+        while let Some(token) = lexer.next() {
+            let Token::Keyword(keyword) = token else {
+                if operands.len() < 1024 {
+                    operands.push(token);
+                }
+                if token == Token::ArrayStart {
+                    let items = array(&mut lexer);
+                    operands.pop();
+                    operands.push(Token::Hex(b""));
+                    cmap.push_list(&operands, items);
+                }
+                continue;
+            };
+            match keyword {
+                b"endcodespacerange" => {
+                    for pair in operands.as_chunks::<2>().0 {
+                        if let (Some((low, length)), Some((high, _))) =
+                            (code(&pair[0]), code(&pair[1]))
+                        {
+                            cmap.spaces.push((low, high, length));
+                        }
+                    }
+                }
+                b"endbfchar" => {
+                    for pair in operands.as_chunks::<2>().0 {
+                        if let Some((code, _)) = code(&pair[0]) {
+                            let target = cmap.target(&pair[1]);
+                            cmap.unicode.push((code, code, target));
+                        }
+                    }
+                }
+                b"endbfrange" => {
+                    for triple in operands.as_chunks::<3>().0 {
+                        if let (Some((low, _)), Some((high, _)), Token::Hex(raw)) =
+                            (code(&triple[0]), code(&triple[1]), triple[2])
+                            && !raw.is_empty()
+                        {
+                            let target = cmap.target(&triple[2]);
+                            cmap.unicode.push((low, high, target));
+                        }
+                    }
+                }
+                b"endcidrange" => {
+                    for triple in operands.as_chunks::<3>().0 {
+                        if let (Some((low, _)), Some((high, _)), Token::Integer(cid)) =
+                            (code(&triple[0]), code(&triple[1]), triple[2])
+                        {
+                            cmap.cids.push((low, high, u32::try_from(cid).unwrap_or(0)));
+                        }
+                    }
+                }
+                b"endcidchar" => {
+                    for pair in operands.as_chunks::<2>().0 {
+                        if let (Some((code, _)), Token::Integer(cid)) = (code(&pair[0]), pair[1]) {
+                            cmap.cids.push((code, code, u32::try_from(cid).unwrap_or(0)));
+                        }
+                    }
+                }
+                _ => {}
+            }
+            operands.clear();
+        }
+        cmap.unicode.sort_by_key(|&(low, _, _)| low);
+        cmap.cids.sort_by_key(|&(low, _, _)| low);
+        cmap
+    }
+
+    /// A `bfrange` whose destination is an array, one text per code.
+    fn push_list(&mut self, operands: &[Token<'_>], items: Vec<&[u8]>) {
+        let [.., low, high, _] = operands else { return };
+        let (Some((low, _)), Some((high, _))) = (code(low), code(high)) else { return };
+        let list = items.into_iter().map(|raw| self.store(&utf16(&hex_bytes(raw)))).collect();
+        self.unicode.push((low, high, Target::List(list)));
+    }
+
+    fn target(&mut self, token: &Token<'_>) -> Target {
+        let text = match *token {
+            Token::Hex(raw) => utf16(&hex_bytes(raw)),
+            Token::Name(raw) => std::str::from_utf8(&name_bytes(raw))
+                .ok()
+                .and_then(named)
+                .map(std::borrow::Cow::into_owned)
+                .unwrap_or_default(),
+            _ => String::new(),
+        };
+        Target::Text(self.store(&text))
+    }
+
+    fn store(&mut self, text: &str) -> Range<u32> {
+        span::append(&mut self.text, |buffer| buffer.push_str(text))
+    }
+
+    pub const fn has_spaces(&self) -> bool {
+        !self.spaces.is_empty()
+    }
+
+    /// The length of the code starting `bytes`: the code space range it
+    /// falls in, or the shortest one when it falls in none.
+    pub fn code_length(&self, bytes: &[u8]) -> usize {
+        for &(low, high, length) in &self.spaces {
+            let length = usize::from(length);
+            if let Some(prefix) = bytes.get(..length)
+                && (low..=high).contains(&be(prefix))
+            {
+                return length;
+            }
+        }
+        self.spaces.iter().map(|&(_, _, length)| usize::from(length)).min().unwrap_or(1)
+    }
+
+    /// The text of `code`, pushed onto `out`; false when unmapped.
+    pub fn push_text(&self, code: u32, out: &mut String) -> bool {
+        let at = self.unicode.partition_point(|&(low, _, _)| low <= code);
+        for (low, high, target) in self.unicode[..at].iter().rev().take(8) {
+            if code > *high {
+                continue;
+            }
+            let offset = code - low;
+            match target {
+                Target::Text(span) => {
+                    let text = span::slice(&self.text, span);
+                    let mut chars = text.chars();
+                    let Some(last) = chars.next_back() else { return false };
+                    out.push_str(chars.as_str());
+                    out.push(char::from_u32(u32::from(last) + offset).unwrap_or(last));
+                }
+                Target::List(list) => {
+                    let Some(span) = list.get(offset as usize) else { return false };
+                    out.push_str(span::slice(&self.text, span));
+                }
+            }
+            return true;
+        }
+        false
+    }
+
+    /// The CID of `code`, if the map says.
+    pub fn cid(&self, code: u32) -> Option<u32> {
+        let at = self.cids.partition_point(|&(low, _, _)| low <= code);
+        self.cids[..at]
+            .iter()
+            .rev()
+            .take(8)
+            .find(|&&(_, high, _)| code <= high)
+            .map(|&(low, _, cid)| cid + (code - low))
+    }
+}
+
+/// The hex strings of an array after its `[`.
+fn array<'a>(lexer: &mut Lexer<'a>) -> Vec<&'a [u8]> {
+    let mut items = Vec::new();
+    while let Some(token) = lexer.next() {
+        match token {
+            Token::ArrayEnd => break,
+            Token::Hex(raw) => items.push(raw),
+            _ => {}
+        }
+    }
+    items
+}
+
+/// A hex string token as a code and its length in bytes (up to 4).
+fn code(token: &Token<'_>) -> Option<(u32, u8)> {
+    let Token::Hex(raw) = *token else { return None };
+    let bytes = hex_bytes(raw);
+    let length = u8::try_from(bytes.len()).ok().filter(|&length| (1..=4).contains(&length))?;
+    Some((be(&bytes), length))
+}
+
+pub fn be(bytes: &[u8]) -> u32 {
+    bytes.iter().fold(0, |value, &byte| value << 8 | u32::from(byte))
+}
+
+/// UTF-16BE, as `ToUnicode` maps write text; lone surrogates are dropped.
+pub fn utf16(bytes: &[u8]) -> String {
+    let units = bytes.as_chunks::<2>().0.iter().map(|pair| u16::from_be_bytes([pair[0], pair[1]]));
+    char::decode_utf16(units).filter_map(Result::ok).collect()
+}

data/ext/imprimatur_native/core/src/read/pdf/content/geometry.rs

@@ -0,0 +1,79 @@
+//! Where things land on a page: transforms, and the frame a page is shown
+//! in once its rotation is applied.
+
+use super::super::document::Page;
+use crate::read::content::Bounds;
+
+/// A 2D affine transform `[a b c d e f]`, as PDF writes them.
+pub type Matrix = [f64; 6];
+pub const IDENTITY: Matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
+
+pub fn multiply(m: &Matrix, n: &Matrix) -> Matrix {
+    [
+        m[1].mul_add(n[2], m[0] * n[0]),
+        m[1].mul_add(n[3], m[0] * n[1]),
+        m[3].mul_add(n[2], m[2] * n[0]),
+        m[3].mul_add(n[3], m[2] * n[1]),
+        m[5].mul_add(n[2], m[4] * n[0]) + n[4],
+        m[5].mul_add(n[3], m[4] * n[1]) + n[5],
+    ]
+}
+
+/// How a page is shown: its rotation into the displayed frame, its size
+/// there, and its media box.
+#[derive(Debug, Clone, Copy)]
+pub struct Frame {
+    pub rotation: Matrix,
+    pub size: (f64, f64),
+    pub bounds: [f64; 4],
+}
+
+impl Frame {
+    pub fn of(page: &Page) -> Self {
+        let [x0, y0, x1, y1] = page.media_box;
+        let (left, bottom, right, top) = (x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1));
+        // Displayed frame: rotated clockwise by /Rotate, y upward from the
+        // bottom-left corner.
+        let rotation = match page.rotate.rem_euclid(360) {
+            90 => [0.0, -1.0, 1.0, 0.0, -bottom, right],
+            180 => [-1.0, 0.0, 0.0, -1.0, right, top],
+            270 => [0.0, 1.0, -1.0, 0.0, top, -left],
+            _ => [1.0, 0.0, 0.0, 1.0, -left, -bottom],
+        };
+        let (width, height) = (right - left, top - bottom);
+        let size =
+            if page.rotate.rem_euclid(180) == 90 { (height, width) } else { (width, height) };
+        Self { rotation, size, bounds: [left, bottom, right, top] }
+    }
+
+    /// Where the unit square, drawn with `ctm`, lands: in points from the
+    /// top-left corner of the page as shown.
+    pub fn place(&self, ctm: &Matrix) -> Bounds {
+        let shown = multiply(ctm, &self.rotation);
+        let corners = [(0.0_f64, 0.0_f64), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0)].map(|(x, y)| {
+            (
+                x.mul_add(shown[0], y.mul_add(shown[2], shown[4])),
+                x.mul_add(shown[1], y.mul_add(shown[3], shown[5])),
+            )
+        });
+        let (mut left, mut right, mut low, mut high) = (f64::MAX, f64::MIN, f64::MAX, f64::MIN);
+        for (x, y) in corners {
+            (left, right, low, high) = (left.min(x), right.max(x), low.min(y), high.max(y));
+        }
+        let height = self.size.1;
+        Bounds { left, top: height - high, right, bottom: height - low }
+    }
+}
+
+/// How many quarter turns, counterclockwise, a baseline along `(dx, dy)`
+/// makes from left-to-right.
+pub fn quarter_turns(dx: f64, dy: f64) -> u8 {
+    let angle = dy.atan2(dx).to_degrees().rem_euclid(360.0);
+    #[expect(
+        clippy::cast_possible_truncation,
+        clippy::cast_sign_loss,
+        reason = "0 to 4 after rounding"
+    )]
+    let turns = ((angle / 90.0).round() as u8) % 4;
+    turns
+}

data/ext/imprimatur_native/core/src/read/pdf/content/operands.rs

@@ -0,0 +1,156 @@
+//! Content stream operands, borrowed from the stream: reading a page
+//! allocates nothing per operator. `TJ`'s arrays keep their items in one
+//! buffer shared by the whole stream.
+
+use crate::read::pdf::lexer::{Lexer, Token, is_whitespace, name_bytes};
+use crate::read::pdf::object::{Dict, Name, Object, Parser};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Operand<'c> {
+    Number(f64),
+    /// A name as written, `#xx` escapes and all.
+    Name(&'c [u8]),
+    /// A string as written: a literal's bytes between its parentheses, or
+    /// a hexadecimal string's digits.
+    String {
+        raw: &'c [u8],
+        hex: bool,
+    },
+    /// An array of numbers and strings: where its items start and end in
+    /// the buffer.
+    Array(usize, usize),
+    /// Anything no operator here reads: dictionaries, nested arrays.
+    Other,
+}
+
+/// The operand a token starts; arrays fill `items`, dictionaries are skipped.
+pub fn operand<'c>(
+    token: Token<'c>,
+    lexer: &mut Lexer<'c>,
+    items: &mut Vec<Operand<'c>>,
+) -> Operand<'c> {
+    match token {
+        Token::ArrayStart => {
+            let start = items.len();
+            while let Some(token) = lexer.next() {
+                match token {
+                    Token::ArrayEnd => break,
+                    Token::ArrayStart | Token::DictStart => skip(lexer),
+                    token => match scalar(token) {
+                        Operand::Other => {}
+                        item => items.push(item),
+                    },
+                }
+            }
+            Operand::Array(start, items.len())
+        }
+        Token::DictStart => {
+            skip(lexer);
+            Operand::Other
+        }
+        token => scalar(token),
+    }
+}
+
+#[expect(clippy::cast_precision_loss, reason = "content stream numbers are small")]
+const fn scalar(token: Token<'_>) -> Operand<'_> {
+    match token {
+        Token::Integer(number) => Operand::Number(number as f64),
+        Token::Real(number) => Operand::Number(number),
+        Token::Name(raw) => Operand::Name(raw),
+        Token::String(raw) => Operand::String { raw, hex: false },
+        Token::Hex(raw) => Operand::String { raw, hex: true },
+        _ => Operand::Other,
+    }
+}
+
+/// Skips a nested array or dictionary, its opening token already read.
+fn skip(lexer: &mut Lexer<'_>) {
+    let mut depth = 1_usize;
+    while depth > 0 {
+        match lexer.next() {
+            None => return,
+            Some(Token::ArrayStart | Token::DictStart) => depth += 1,
+            Some(Token::ArrayEnd | Token::DictEnd) => depth -= 1,
+            Some(_) => {}
+        }
+    }
+}
+
+/// An inline image after its `BI`: its dictionary, abbreviations spelled
+/// out, and its data up to `EI`. The lexer moves past it either way.
+pub fn inline_image<'c>(lexer: &mut Lexer<'c>, max_depth: usize) -> Option<(Dict, &'c [u8])> {
+    let data = lexer.data();
+    let mut parser = Parser::new(data, lexer.pos, max_depth);
+    let mut entries = Vec::new();
+    let found = loop {
+        match parser.lexer.next() {
+            None => break false,
+            Some(Token::Keyword(b"ID")) => break true,
+            Some(Token::Name(key)) => {
+                let Some(token) = parser.lexer.next() else { break false };
+                if token == Token::Keyword(b"ID") {
+                    break true;
+                }
+                let Ok(value) = parser.value(token, 0) else { break false };
+                entries.push((Name::new(full_key(&name_bytes(key))), full_value(value)));
+            }
+            Some(_) => {}
+        }
+    };
+    // One whitespace byte separates `ID` from the data.
+    let start = (parser.lexer.pos + 1).min(data.len());
+    let mut at = start;
+    while at + 2 <= data.len() {
+        if &data[at..at + 2] == b"EI"
+            && data.get(at.wrapping_sub(1)).is_some_and(|&byte| is_whitespace(byte))
+            && data.get(at + 2).is_none_or(|&byte| is_whitespace(byte))
+        {
+            lexer.pos = at + 2;
+            let end = if at > start { at - 1 } else { at };
+            return found.then(|| (Dict(entries), &data[start..end]));
+        }
+        at += 1;
+    }
+    lexer.pos = data.len();
+    None
+}
+
+/// Inline images abbreviate their keys (ISO 32000-1, Table 93).
+const fn full_key(key: &[u8]) -> &[u8] {
+    match key {
+        b"BPC" => b"BitsPerComponent",
+        b"CS" => b"ColorSpace",
+        b"D" => b"Decode",
+        b"DP" => b"DecodeParms",
+        b"F" => b"Filter",
+        b"H" => b"Height",
+        b"IM" => b"ImageMask",
+        b"I" => b"Interpolate",
+        b"W" => b"Width",
+        b"L" => b"Length",
+        key => key,
+    }
+}
+
+/// And their names (Table 94): colour spaces and filters.
+fn full_value(value: Object) -> Object {
+    match value {
+        Object::Name(name) => Object::Name(match &*name {
+            b"G" => Name::new(b"DeviceGray"),
+            b"RGB" => Name::new(b"DeviceRGB"),
+            b"CMYK" => Name::new(b"DeviceCMYK"),
+            b"I" => Name::new(b"Indexed"),
+            b"AHx" => Name::new(b"ASCIIHexDecode"),
+            b"A85" => Name::new(b"ASCII85Decode"),
+            b"LZW" => Name::new(b"LZWDecode"),
+            b"Fl" => Name::new(b"FlateDecode"),
+            b"RL" => Name::new(b"RunLengthDecode"),
+            b"CCF" => Name::new(b"CCITTFaxDecode"),
+            b"DCT" => Name::new(b"DCTDecode"),
+            _ => name,
+        }),
+        Object::Array(items) => Object::Array(items.into_iter().map(full_value).collect()),
+        value => value,
+    }
+}