use crate::object_copy::{copy_objects, rewrite_refs};
use crate::outline_dest_remap::dest_page_ref_resolved;
use crate::page_closure::extend_page_object_closure;
use crate::page_rotate::resolve_inherited_rotate_with_max_depth;
use crate::page_tree_rebuild::resolve_inherited_raw;
use crate::pages::{
page_refs, resolve_inherited_resources_with_max_depth, DEFAULT_MAX_PAGE_TREE_DEPTH,
};
use crate::ref_chain::resolve_ref_chain;
use crate::subset_prune::sweep_unreachable_objects;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Cursor, Read, Seek};
const MAX_ACTION_CHAIN_DEPTH: usize = 64;
pub(crate) struct InheritedAttrs {
pub(crate) resources: Option<Dictionary>,
pub(crate) rotate: i32,
pub(crate) mediabox: Option<Object>,
pub(crate) cropbox: Option<Object>,
}
impl InheritedAttrs {
pub(crate) fn resolve<R: Read + Seek>(
source: &mut Pdf<R>,
page_ref: ObjectRef,
depth: usize,
) -> Result<Self> {
Ok(InheritedAttrs {
resources: resolve_inherited_resources_with_max_depth(source, page_ref, depth)?,
rotate: resolve_inherited_rotate_with_max_depth(source, page_ref, depth)?,
mediabox: resolve_inherited_raw(source, page_ref, "MediaBox", depth)?,
cropbox: resolve_inherited_raw(source, page_ref, "CropBox", depth)?,
})
}
}
pub fn extract_pages<R: Read + Seek>(
source: &mut Pdf<R>,
page_indices: &[usize],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if page_indices.is_empty() {
return Err(Error::Unsupported("empty page selection".to_string()));
}
let all_pages = page_refs(source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(page_indices.len());
for &idx in page_indices {
let page_ref = *all_pages.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (document has {} pages)",
all_pages.len()
))
})?;
selected.push(page_ref);
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut unique: Vec<ObjectRef> = Vec::with_capacity(selected.len());
for &page_ref in &selected {
if seen.insert(page_ref) {
unique.push(page_ref);
}
}
let depth = DEFAULT_MAX_PAGE_TREE_DEPTH;
let mut inherited: Vec<InheritedAttrs> = Vec::with_capacity(unique.len());
for &page_ref in &unique {
inherited.push(InheritedAttrs::resolve(source, page_ref, depth)?);
}
let mut closure: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &unique {
extend_page_object_closure(source, page_ref, &mut closure)?;
}
let mut target = Pdf::open_mem_owned(minimal_target_bytes())?;
let map = copy_objects(source, &mut target, &closure)?;
let pages_root_ref = target_pages_root(&mut target)?;
let mut copied_unique: Vec<ObjectRef> = Vec::with_capacity(unique.len());
for (&src_ref, attrs) in unique.iter().zip(inherited) {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
materialize_leaf(&mut target, copied_page_ref, attrs, &map, pages_root_ref)?;
copied_unique.push(copied_page_ref);
}
let keep: BTreeSet<ObjectRef> = copied_unique.iter().copied().collect();
for &copied_page_ref in &copied_unique {
neutralize_absent_dests(&mut target, copied_page_ref, &keep)?;
}
let mut kids: Vec<ObjectRef> = Vec::with_capacity(selected.len());
let mut used: BTreeSet<ObjectRef> = BTreeSet::new();
append_selection_kids(&mut target, &selected, &map, &mut used, &mut kids)?;
let mut root = resolve_dict(
&mut target,
pages_root_ref,
"target /Pages is not a dictionary",
)?;
root.insert(
"Kids",
Object::Array(kids.iter().map(|&r| Object::Reference(r)).collect()),
);
root.insert("Count", Object::Integer(kids.len() as i64));
target.set_object(pages_root_ref, Object::Dictionary(root));
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
pub fn extract_page<R: Read + Seek>(
source: &mut Pdf<R>,
page_index: usize,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
extract_pages(source, &[page_index])
}
pub(crate) fn materialize_leaf(
target: &mut Pdf<Cursor<Vec<u8>>>,
copied_page_ref: ObjectRef,
attrs: InheritedAttrs,
map: &std::collections::BTreeMap<ObjectRef, ObjectRef>,
pages_root_ref: ObjectRef,
) -> Result<()> {
let mut leaf = resolve_dict(target, copied_page_ref, "copied page is not a dictionary")?;
if !has_own(&leaf, "Resources") {
if let Some(res) = attrs.resources {
let mut value = Object::Dictionary(res);
rewrite_refs(&mut value, 0, map)?;
leaf.insert("Resources", value);
}
}
if !has_own(&leaf, "MediaBox") {
if let Some(mut mb) = attrs.mediabox {
rewrite_refs(&mut mb, 0, map)?;
leaf.insert("MediaBox", mb);
} }
if !has_own(&leaf, "CropBox") {
if let Some(mut cb) = attrs.cropbox {
rewrite_refs(&mut cb, 0, map)?;
leaf.insert("CropBox", cb);
}
}
if !has_own(&leaf, "Rotate") {
leaf.insert("Rotate", Object::Integer(attrs.rotate as i64));
}
leaf.insert("Parent", Object::Reference(pages_root_ref));
target.set_object(copied_page_ref, Object::Dictionary(leaf));
Ok(())
}
pub(crate) fn append_selection_kids(
target: &mut Pdf<Cursor<Vec<u8>>>,
selected: &[ObjectRef],
map: &std::collections::BTreeMap<ObjectRef, ObjectRef>,
used: &mut BTreeSet<ObjectRef>,
kids: &mut Vec<ObjectRef>,
) -> Result<()> {
let mut next_num: u32 = target
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
for &src_ref in selected {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
let kid = if used.insert(copied_page_ref) {
copied_page_ref
} else {
next_num = next_num.checked_add(1).ok_or_else(|| {
Error::Unsupported(
"page extract: object-number overflow allocating duplicate page".to_string(),
)
})?;
let clone_ref = ObjectRef::new(next_num, 0);
let dict = resolve_dict(target, copied_page_ref, "copied page is not a dictionary")?; target.set_object(clone_ref, Object::Dictionary(dict));
clone_ref
};
kids.push(kid);
}
Ok(())
}
fn neutralize_absent_dests(
target: &mut Pdf<Cursor<Vec<u8>>>,
page_ref: ObjectRef,
keep: &BTreeSet<ObjectRef>,
) -> Result<()> {
let (annots_val, page_aa): (Option<Object>, Option<Object>) = {
let page_obj = target.resolve_borrowed(page_ref)?;
let Some(page_dict) = page_obj.as_dict() else {
return Ok(());
};
(
page_dict.get("Annots").cloned(),
page_dict.get("AA").cloned(),
)
};
let annot_refs: Vec<ObjectRef> = match annots_val {
Some(Object::Array(arr)) => arr.iter().filter_map(Object::as_ref_id).collect(),
Some(Object::Reference(r)) => match target.resolve_borrowed(r)? {
Object::Array(arr) => arr.iter().filter_map(Object::as_ref_id).collect(),
_ => Vec::new(),
},
_ => Vec::new(),
};
for annot_ref in annot_refs {
neutralize_annot_if_absent(target, annot_ref, keep)?;
}
if let Some(aa_val) = page_aa {
if let Some(new_aa) = neutralize_aa_if_absent(target, &aa_val, keep)? {
let mut page = resolve_dict(target, page_ref, "extracted page is not a dictionary")?;
page.insert("AA", new_aa);
target.set_object(page_ref, Object::Dictionary(page));
}
}
neutralize_bead_ring(target, page_ref, keep)?;
Ok(())
}
fn neutralize_bead_ring(
target: &mut Pdf<Cursor<Vec<u8>>>,
page_ref: ObjectRef,
keep: &BTreeSet<ObjectRef>,
) -> Result<()> {
let b_val = {
let page_obj = target.resolve_borrowed(page_ref)?;
let Some(page_dict) = page_obj.as_dict() else {
return Ok(());
};
page_dict.get("B").cloned()
};
let Some(b_val) = b_val else {
return Ok(());
};
let (b_concrete, _) = resolve_ref_chain(target, &b_val)?;
let Object::Array(beads) = b_concrete else {
return Ok(());
};
let mut queue: Vec<ObjectRef> = beads.iter().filter_map(Object::as_ref_id).collect();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
while let Some(start_ref) = queue.pop() {
let (concrete, terminal) = resolve_ref_chain(target, &Object::Reference(start_ref))?;
let bead_ref = terminal.unwrap_or(start_ref);
if !visited.insert(bead_ref) {
continue;
}
let Some(mut bead) = concrete.into_dict() else {
continue;
};
for key in ["N", "V"] {
if let Some(Object::Reference(r)) = bead.get(key) {
queue.push(*r);
}
}
if let Some(p_val) = bead.get("P") {
if p_targets_absent_page(target, p_val, keep)? {
bead.remove("P");
target.set_object(bead_ref, Object::Dictionary(bead));
}
}
}
Ok(())
}
fn neutralize_annot_if_absent(
target: &mut Pdf<Cursor<Vec<u8>>>,
annot_ref: ObjectRef,
keep: &BTreeSet<ObjectRef>,
) -> Result<()> {
let Some(mut annot) = target.resolve_borrowed(annot_ref)?.as_dict().cloned() else {
return Ok(());
};
let mut changed = false;
if let Some(dest) = annot.remove("Dest") {
if dest_targets_absent_page(target, &dest, keep)? {
changed = true;
} else {
annot.insert("Dest", dest);
}
}
if let Some(a_val) = annot.remove("A") {
let mut visited = BTreeSet::new();
if let Some(new) =
neutralize_action_chain(target, &a_val, keep, &mut visited, MAX_ACTION_CHAIN_DEPTH)?
{
annot.insert("A", new);
changed = true;
} else {
annot.insert("A", a_val);
}
}
if let Some(aa_val) = annot.remove("AA") {
if let Some(new_aa) = neutralize_aa_if_absent(target, &aa_val, keep)? {
annot.insert("AA", new_aa);
changed = true;
} else {
annot.insert("AA", aa_val);
}
}
if let Some(p_val) = annot.remove("P") {
if p_targets_absent_page(target, &p_val, keep)? {
changed = true;
} else {
annot.insert("P", p_val);
}
}
if changed {
target.set_object(annot_ref, Object::Dictionary(annot));
}
Ok(())
}
fn neutralize_aa_if_absent(
target: &mut Pdf<Cursor<Vec<u8>>>,
aa_value: &Object,
keep: &BTreeSet<ObjectRef>,
) -> Result<Option<Object>> {
let (concrete, terminal_ref) = resolve_ref_chain(target, aa_value)?;
let Some(mut aa) = concrete.into_dict() else {
return Ok(None);
};
let keys: Vec<Vec<u8>> = aa.iter().map(|(k, _)| k.to_vec()).collect();
let mut changed = false;
for key in keys {
let Some(sub_val) = aa.remove(&key) else {
continue;
};
let mut visited = BTreeSet::new();
if let Some(new) =
neutralize_action_chain(target, &sub_val, keep, &mut visited, MAX_ACTION_CHAIN_DEPTH)?
{
aa.insert(&key, new);
changed = true;
} else {
aa.insert(&key, sub_val);
}
}
if !changed {
return Ok(None);
}
match terminal_ref {
Some(r) => {
target.set_object(r, Object::Dictionary(aa));
Ok(None)
}
None => Ok(Some(Object::Dictionary(aa))),
}
}
fn neutralize_action_chain(
target: &mut Pdf<Cursor<Vec<u8>>>,
action_value: &Object,
keep: &BTreeSet<ObjectRef>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<Option<Object>> {
if depth == 0 {
return Ok(None);
}
let (concrete, terminal_ref) = resolve_ref_chain(target, action_value)?;
if let Some(r) = terminal_ref {
if !visited.insert(r) {
return Ok(None);
}
}
if let Object::Array(mut elems) = concrete {
let any = neutralize_action_array(target, &mut elems, keep, visited, depth)?;
if !any {
return Ok(None);
}
return match terminal_ref {
Some(r) => {
target.set_object(r, Object::Array(elems));
Ok(None)
}
None => Ok(Some(Object::Array(elems))),
};
}
let Some(mut act) = concrete.into_dict() else {
return Ok(None);
};
let mut changed = false;
let is_goto = matches!(act.get("S"), Some(Object::Name(n)) if n == b"GoTo");
if is_goto {
if let Some(d_val) = act.remove("D") {
if dest_targets_absent_page(target, &d_val, keep)? {
changed = true;
} else {
act.insert("D", d_val);
}
}
if let Some(sd_val) = act.remove("SD") {
if sd_targets_absent_page(target, &sd_val, keep)? {
changed = true;
} else {
act.insert("SD", sd_val);
}
}
}
if let Some(next_val) = act.remove("Next") {
match next_val {
Object::Array(mut elems) => {
if neutralize_action_array(target, &mut elems, keep, visited, depth)? {
changed = true;
}
act.insert("Next", Object::Array(elems));
}
single => match neutralize_action_chain(target, &single, keep, visited, depth - 1)? {
Some(new) => {
act.insert("Next", new);
changed = true;
}
None => {
act.insert("Next", single);
}
},
}
}
if !changed {
return Ok(None);
}
match terminal_ref {
Some(r) => {
target.set_object(r, Object::Dictionary(act));
Ok(None)
}
None => Ok(Some(Object::Dictionary(act))),
}
}
fn neutralize_action_array(
target: &mut Pdf<Cursor<Vec<u8>>>,
elems: &mut [Object],
keep: &BTreeSet<ObjectRef>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<bool> {
let mut any = false;
for elem in elems.iter_mut() {
if let Some(new) = neutralize_action_chain(target, elem, keep, visited, depth - 1)? {
*elem = new;
any = true;
}
}
Ok(any)
}
fn dest_targets_absent_page(
target: &mut Pdf<Cursor<Vec<u8>>>,
dest: &Object,
keep: &BTreeSet<ObjectRef>,
) -> Result<bool> {
Ok(match dest_page_ref_resolved(target, dest)? {
Some(page_ref) => !keep.contains(&page_ref),
None => false,
})
}
fn sd_targets_absent_page(
target: &mut Pdf<Cursor<Vec<u8>>>,
sd: &Object,
keep: &BTreeSet<ObjectRef>,
) -> Result<bool> {
Ok(match sd_target_page_ref(target, sd)? {
Some(r) => !keep.contains(&r),
None => false,
})
}
pub(crate) fn sd_target_page_ref<R: Read + Seek>(
pdf: &mut Pdf<R>,
sd: &Object,
) -> Result<Option<ObjectRef>> {
let (concrete, _) = resolve_ref_chain(pdf, sd)?;
let Object::Array(arr) = concrete else {
return Ok(None); };
let Some(struct_elem) = arr.into_iter().next() else {
return Ok(None);
};
let (se, _) = resolve_ref_chain(pdf, &struct_elem)?;
let Some(se_dict) = se.into_dict() else {
return Ok(None);
};
let Some(pg) = se_dict.get("Pg").cloned() else {
return Ok(None);
};
let (pg_concrete, pg_ref) = resolve_ref_chain(pdf, &pg)?;
Ok(match pg_ref {
Some(r) if is_page_dict(&pg_concrete) => Some(r),
_ => None,
})
}
fn p_targets_absent_page(
target: &mut Pdf<Cursor<Vec<u8>>>,
p: &Object,
keep: &BTreeSet<ObjectRef>,
) -> Result<bool> {
let (concrete, p_ref) = resolve_ref_chain(target, p)?;
Ok(match p_ref {
Some(r) => !keep.contains(&r) && is_page_dict(&concrete),
None => false,
})
}
fn is_page_dict(obj: &Object) -> bool {
obj.as_dict()
.and_then(|d| d.get("Type"))
.is_some_and(|t| matches!(t, Object::Name(n) if n == b"Page"))
}
pub(crate) fn minimal_target_bytes() -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let off1 = out.len() as u64;
out.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = out.len() as u64;
out.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\n");
let xref_start = out.len() as u64;
out.extend_from_slice(
format!("xref\n0 3\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n")
.as_bytes(),
);
out.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
out
}
pub(crate) fn target_pages_root(target: &mut Pdf<Cursor<Vec<u8>>>) -> Result<ObjectRef> {
let catalog_ref = target.root_ref().ok_or(Error::Missing("/Root"))?;
let catalog = resolve_dict(target, catalog_ref, "/Root is not a dictionary")?;
catalog
.get("Pages")
.and_then(|o| match o {
Object::Reference(r) => Some(*r),
_ => None,
})
.ok_or(Error::Missing("/Pages"))
}
pub(crate) fn resolve_dict(
target: &mut Pdf<Cursor<Vec<u8>>>,
r: ObjectRef,
ctx: &'static str,
) -> Result<Dictionary> {
match target.resolve(r)? {
Object::Dictionary(d) => Ok(d),
_ => Err(Error::Missing(ctx)),
}
}
fn has_own(dict: &Dictionary, key: &str) -> bool {
!matches!(dict.get(key), None | Some(Object::Null))
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeMap;
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: BTreeMap<u32, u64> = BTreeMap::new();
let max = objects.iter().map(|(n, _)| *n).max().unwrap_or(0);
for (n, body) in objects {
offsets.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for n in 1..=max {
match offsets.get(&n) {
Some(off) => out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes()),
None => out.extend_from_slice(b"0000000000 65535 f \n"),
}
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
#[test]
fn resolve_dict_errors_on_non_dictionary() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "42"),
],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = resolve_dict(&mut pdf, ObjectRef::new(3, 0), "not a dict")
.expect_err("resolving an integer as a dict must error");
assert!(matches!(err, Error::Missing("not a dict")), "got {err:?}");
}
#[test]
fn target_pages_root_errors_when_pages_is_not_a_reference() {
let bytes = build_pdf(
&[(
1,
"<< /Type /Catalog /Pages << /Type /Pages /Kids [] /Count 0 >> >>",
)],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = target_pages_root(&mut pdf).expect_err("inline /Pages must error");
assert!(matches!(err, Error::Missing("/Pages")), "got {err:?}");
}
}