use crate::backend::ooxml::Package;
use crate::backend::{
keynote, keynote_iwa, keynote_xml, numbers, numbers_iwa, numbers_xml, pages, pages_iwa,
pages_xml, DeclarativeBackend,
};
use crate::error::ConversionError;
use crate::source::SourceDocument;
use docling_core::{DoclingDocument, Table, TableCell};
pub(crate) struct Archive {
pub(crate) id: u64,
pub(crate) ty: u32,
pub(crate) payload: Vec<u8>,
}
#[derive(Default)]
pub struct IworkBackend {
pub page_range: Option<(usize, usize)>,
}
impl DeclarativeBackend for IworkBackend {
fn convert(&self, source: &SourceDocument) -> Result<DoclingDocument, ConversionError> {
let mut pkg = Package::open(&source.bytes)
.ok_or_else(|| ConversionError::Parse("iwork: not a zip package".into()))?;
let flavor = Flavor::of(source.format);
let page_range = self.page_range;
if pkg.any_encrypted() {
return Err(ConversionError::encrypted_with_message(
"iwork",
crate::EncryptionError::NotDecryptable("iWork package encryption".into()),
format!(
"the document is password-protected; docling.rs cannot read encrypted \
iWork documents. Remove the password in {} and save again",
flavor.app()
),
));
}
if flavor == Flavor::Keynote {
let mut doc = DoclingDocument::new(&source.name);
keynote::emit(read_keynote(&mut pkg)?, &mut doc);
return Ok(doc);
}
if !pkg.names().any(|n| n.ends_with(".iwa")) {
let inner = pkg
.names()
.find(|n| *n == "Index.zip" || n.ends_with("/Index.zip"))
.map(str::to_string);
if let Some(inner) = inner {
if let Some(bytes) = pkg.read_bytes(&inner) {
pkg = Package::open(&bytes).ok_or_else(|| {
ConversionError::Parse("iwork: Index.zip is not a zip".into())
})?;
}
}
}
let has_iwa = pkg
.names()
.any(|n| n.ends_with(".iwa") && n.contains("Index/"));
let mut doc = DoclingDocument::new(&source.name);
let legacy = ["index.xml", "index.xml.gz"]
.into_iter()
.find(|m| pkg.names().any(|n| n == *m));
let kind = flavor.app();
if !has_iwa && legacy.is_none() {
return Err(ConversionError::Parse(format!(
"iwork: a ZIP archive, but not a {kind} document — it has neither an \
Index/ directory nor an index.xml"
)));
}
match (flavor, legacy) {
(Flavor::Pages, Some(member)) if !has_iwa => {
pages::emit(pages_xml::read_content(&mut pkg, member)?, &mut doc)
}
(Flavor::Pages, _) => pages::emit(pages_iwa::read_content(&mut pkg)?, &mut doc),
(_, Some(member)) if !has_iwa => {
let sheets = numbers_xml::read_content(&mut pkg, member)?;
numbers::emit(sheets, page_range, &mut doc);
}
_ => {
let sheets = numbers_iwa::read_content(&mut pkg)?;
numbers::emit(sheets, page_range, &mut doc);
}
}
Ok(doc)
}
}
fn read_keynote(pkg: &mut Package) -> Result<keynote::Presentation, ConversionError> {
let names: Vec<String> = pkg.names().map(str::to_string).collect();
if names
.iter()
.any(|n| n.starts_with("Index/") && n.ends_with(".iwa"))
{
let archives = pages_iwa::read_archives(pkg)?;
return keynote_iwa::read_content(&archives, pkg, "");
}
let nested = names
.iter()
.filter(|n| {
n.strip_suffix("Index.zip").is_some_and(|dir| {
dir.is_empty() || (dir.ends_with('/') && dir.matches('/').count() == 1)
})
})
.min()
.cloned();
if let Some(member) = nested {
let bytes = pkg
.read_bytes(&member)
.ok_or_else(|| ConversionError::Parse(format!("iwork: could not read '{member}'")))?;
let mut index = Package::open(&bytes)
.ok_or_else(|| ConversionError::Parse("iwork: Index.zip is not a zip".into()))?;
let archives = pages_iwa::read_archives(&mut index)?;
let prefix = &member[..member.len() - "Index.zip".len()];
return keynote_iwa::read_content(&archives, pkg, prefix);
}
if let Some(member) = ["index.apxl", "index.apxl.gz"]
.into_iter()
.find(|m| names.iter().any(|n| n == m))
{
return keynote_xml::read_content(pkg, member);
}
Err(ConversionError::Parse(
"iwork: a ZIP archive, but not a Keynote document — it has neither an Index/ \
directory nor an Index.zip nor an index.apxl"
.into(),
))
}
#[derive(Clone, Copy, PartialEq)]
enum Flavor {
Pages,
Numbers,
Keynote,
}
impl Flavor {
fn app(self) -> &'static str {
match self {
Flavor::Pages => "Pages",
Flavor::Numbers => "Numbers",
Flavor::Keynote => "Keynote",
}
}
fn of(format: crate::InputFormat) -> Self {
match format {
crate::InputFormat::Numbers => Flavor::Numbers,
crate::InputFormat::Keynote => Flavor::Keynote,
_ => Flavor::Pages,
}
}
}
pub(crate) fn decode_iwa(bytes: &[u8]) -> Result<Vec<u8>, ConversionError> {
let mut out = Vec::with_capacity(bytes.len() * 3);
let mut pos = 0usize;
let mut snappy = snap::raw::Decoder::new();
while pos + 4 <= bytes.len() {
let len = u32::from_le_bytes([bytes[pos + 1], bytes[pos + 2], bytes[pos + 3], 0]) as usize;
let ty = bytes[pos];
pos += 4;
let Some(block) = bytes.get(pos..pos + len) else {
return Err(ConversionError::Parse("iwork: truncated IWA chunk".into()));
};
pos += len;
match ty {
0 => out.extend_from_slice(
&snappy
.decompress_vec(block)
.map_err(|e| ConversionError::Parse(format!("iwork: snappy: {e}")))?,
),
1 => out.extend_from_slice(block),
other => {
return Err(ConversionError::Parse(format!(
"iwork: unknown IWA chunk type {other}"
)))
}
}
}
Ok(out)
}
pub(crate) fn parse_archives(mut stream: &[u8], out: &mut Vec<Archive>, all_messages: bool) {
while !stream.is_empty() {
let Some((info_len, rest)) = read_varint(stream) else {
return;
};
let Some(info) = rest.get(..info_len as usize) else {
return;
};
let after = &rest[info_len as usize..];
let mut id = 0u64;
let mut messages: Vec<(u32, usize)> = Vec::new();
for (field, value) in Fields::new(info) {
match (field, value) {
(1, Value::Varint(v)) => id = v,
(2, Value::Bytes(mi)) => {
let (mut ty, mut len) = (0u32, 0usize);
for (f, v) in Fields::new(mi) {
match (f, v) {
(1, Value::Varint(t)) => ty = t as u32,
(3, Value::Varint(l)) => len = l as usize,
_ => {}
}
}
messages.push((ty, len));
}
_ => {}
}
}
let mut consumed = 0usize;
for (i, (ty, len)) in messages.iter().enumerate() {
let Some(payload) = after.get(consumed..consumed + len) else {
return;
};
if i == 0 || all_messages {
out.push(Archive {
id,
ty: *ty,
payload: payload.to_vec(),
});
}
consumed += len;
}
let Some(next) = after.get(consumed..) else {
return;
};
stream = next;
}
}
pub(crate) enum Value<'a> {
Varint(u64),
Bytes(&'a [u8]),
#[allow(dead_code)]
Fixed32(u32),
#[allow(dead_code)]
Fixed64(u64),
}
pub(crate) struct Fields<'a>(&'a [u8]);
impl<'a> Fields<'a> {
pub(crate) fn new(buf: &'a [u8]) -> Self {
Fields(buf)
}
}
impl<'a> Iterator for Fields<'a> {
type Item = (u32, Value<'a>);
fn next(&mut self) -> Option<Self::Item> {
let (tag, rest) = read_varint(self.0)?;
let field = (tag >> 3) as u32;
let value = match tag & 7 {
0 => {
let (v, rest) = read_varint(rest)?;
self.0 = rest;
Value::Varint(v)
}
1 => {
let v = u64::from_le_bytes(rest.get(..8)?.try_into().ok()?);
self.0 = &rest[8..];
Value::Fixed64(v)
}
2 => {
let (len, rest) = read_varint(rest)?;
let bytes = rest.get(..len as usize)?;
self.0 = &rest[len as usize..];
Value::Bytes(bytes)
}
5 => {
let v = u32::from_le_bytes(rest.get(..4)?.try_into().ok()?);
self.0 = &rest[4..];
Value::Fixed32(v)
}
_ => return None,
};
Some((field, value))
}
}
pub(crate) fn read_varint(buf: &[u8]) -> Option<(u64, &[u8])> {
let mut value = 0u64;
for (i, &b) in buf.iter().enumerate().take(10) {
value |= u64::from(b & 0x7f) << (7 * i as u32);
if b & 0x80 == 0 {
return Some((value, &buf[i + 1..]));
}
}
None
}
pub(crate) fn reference(bytes: &[u8]) -> Option<u64> {
Fields::new(bytes).find_map(|(f, v)| match (f, v) {
(1, Value::Varint(id)) => Some(id),
_ => None,
})
}
pub(crate) fn first_bytes(payload: &[u8], field: u32) -> Option<&[u8]> {
Fields::new(payload).find_map(|(f, v)| match v {
Value::Bytes(b) if f == field => Some(b),
_ => None,
})
}
pub(crate) fn first_varint(payload: &[u8], field: u32) -> Option<u64> {
Fields::new(payload).find_map(|(f, v)| match v {
Value::Varint(n) if f == field => Some(n),
_ => None,
})
}
pub(crate) fn grid_table(num_rows: usize, num_cols: usize, cells: Vec<TableCell>) -> Table {
let mut rows = vec![vec![String::new(); num_cols]; num_rows];
for cell in &cells {
if cell.start_row < num_rows && cell.start_col < num_cols {
rows[cell.start_row][cell.start_col] = cell.text.clone();
}
}
Table {
rows,
cells: Some(cells),
..Default::default()
}
}
pub(crate) fn text_cell(text: String, row: usize, col: usize, header_rows: usize) -> TableCell {
TableCell {
text,
bbox: None,
start_row: row,
start_col: col,
row_span: 1,
col_span: 1,
column_header: row < header_rows,
row_header: false,
row_section: false,
}
}
pub(crate) fn gunzip_capped(
raw: &[u8],
cap: u64,
member: &str,
) -> Result<Vec<u8>, ConversionError> {
use std::io::Read;
let mut out = Vec::new();
flate2::read::GzDecoder::new(raw)
.take(cap + 1)
.read_to_end(&mut out)
.map_err(|_| ConversionError::Parse(format!("iwork: could not decompress '{member}'")))?;
if out.len() as u64 > cap {
return Err(ConversionError::Parse(format!(
"iwork: '{member}' expands beyond the {cap} byte limit"
)));
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn varints_and_fields_walk_defensively() {
assert_eq!(read_varint(&[0x96, 0x01]), Some((150, &[][..])));
assert_eq!(read_varint(&[0x80]), None); let msg = [0x08, 0x05, 0x12, 0x02, b'a', b'b'];
let items: Vec<u32> = Fields::new(&msg).map(|(f, _)| f).collect();
assert_eq!(items, vec![1, 2]);
let bad = [0x12, 0x0A, b'x'];
assert_eq!(Fields::new(&bad).count(), 0);
}
}