use crate::acroform_document_helper::{collect_refs_in_object, remap_refs_in_object};
use crate::acroform_field_prune::DEFAULT_MAX_ACROFORM_DEPTH;
use crate::object_copy::copy_objects;
use crate::page_closure::{extend_object_closure, extend_page_object_closure};
use crate::page_extract::{
append_selection_kids, materialize_leaf, minimal_target_bytes, null_copied_removed_pages,
resolve_dict, target_pages_root, InheritedAttrs,
};
use crate::page_label_document_helper::{merge_adjacent_ranges, LabelRange};
use crate::pages::{page_refs, 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::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
pub struct MergeInput<'a, R: Read + Seek> {
pub source: &'a mut Pdf<R>,
pub pages: Vec<usize>,
}
#[derive(Default)]
struct PrimaryDocLevel {
outlines: Option<ObjectRef>,
outlines_inline: Option<Dictionary>,
names_dests: Option<ObjectRef>,
names_dests_inline: Option<Dictionary>,
legacy_dests_ref: Option<ObjectRef>,
legacy_dests_inline: Option<Dictionary>,
open_action_ref: Option<ObjectRef>,
open_action_inline: Option<Object>,
}
fn discover_primary_doc_level<R: Read + Seek>(source: &mut Pdf<R>) -> Result<PrimaryDocLevel> {
let Some(catalog_ref) = source.root_ref() else {
return Ok(PrimaryDocLevel::default()); };
let catalog_obj = source.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(PrimaryDocLevel::default()); };
let mut doc = PrimaryDocLevel::default();
match catalog.get("Outlines") {
Some(Object::Reference(r)) => doc.outlines = Some(*r),
Some(Object::Dictionary(d)) => doc.outlines_inline = Some(d.clone()),
_ => {}
}
let names_val = catalog.get("Names").cloned();
let names_dict = match names_val {
Some(value @ Object::Reference(_)) => resolve_ref_chain(source, &value)?.0.into_dict(),
Some(Object::Dictionary(d)) => Some(d),
_ => None,
};
if let Some(names) = names_dict {
if let Some(Object::Reference(r)) = names.get("Dests") {
doc.names_dests = Some(*r);
} else if let Some(Object::Dictionary(d)) = names.get("Dests") {
doc.names_dests_inline = Some(d.clone());
}
}
let catalog_obj = source.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(doc); };
match catalog.get("Dests") {
Some(Object::Reference(r)) => doc.legacy_dests_ref = Some(*r),
Some(Object::Dictionary(d)) => doc.legacy_dests_inline = Some(d.clone()),
_ => {}
}
match catalog.get("OpenAction") {
Some(Object::Reference(r)) => doc.open_action_ref = Some(*r),
Some(other) => doc.open_action_inline = Some(other.clone()),
None => {}
}
Ok(doc)
}
fn fold_doc_level_closure<R: Read + Seek>(
source: &mut Pdf<R>,
doc: &PrimaryDocLevel,
closure: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
for root in [
doc.outlines,
doc.names_dests,
doc.legacy_dests_ref,
doc.open_action_ref,
]
.into_iter()
.flatten()
{
extend_object_closure(source, &Object::Reference(root), closure)?;
}
if let Some(inline) = &doc.open_action_inline {
extend_object_closure(source, inline, closure)?;
}
if let Some(inline) = &doc.names_dests_inline {
extend_object_closure(source, &Object::Dictionary(inline.clone()), closure)?;
}
if let Some(inline) = &doc.legacy_dests_inline {
extend_object_closure(source, &Object::Dictionary(inline.clone()), closure)?;
}
if let Some(inline) = &doc.outlines_inline {
extend_object_closure(source, &Object::Dictionary(inline.clone()), closure)?;
}
Ok(())
}
fn wire_doc_level<RTgt: Read + Seek>(
target: &mut Pdf<RTgt>,
doc: &PrimaryDocLevel,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let Some(catalog_ref) = target.root_ref() else {
return Ok(()); };
let catalog_obj = target.resolve_borrowed(catalog_ref)?;
let Some(mut catalog) = catalog_obj.as_dict().cloned() else {
return Ok(()); };
if let Some(outlines) = doc.outlines {
if let Some(&new_ref) = map.get(&outlines) {
catalog.insert("Outlines", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.outlines_inline {
catalog.insert(
"Outlines",
remap_refs_in_object(Object::Dictionary(inline.clone()), map),
);
}
if let Some(dests) = doc.names_dests {
if let Some(&new_ref) = map.get(&dests) {
let mut names = Dictionary::new();
names.insert("Dests", Object::Reference(new_ref));
catalog.insert("Names", Object::Dictionary(names));
}
} else if let Some(inline) = &doc.names_dests_inline {
let mut names = Dictionary::new();
names.insert(
"Dests",
remap_refs_in_object(Object::Dictionary(inline.clone()), map),
);
catalog.insert("Names", Object::Dictionary(names));
}
if let Some(legacy) = doc.legacy_dests_ref {
if let Some(&new_ref) = map.get(&legacy) {
catalog.insert("Dests", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.legacy_dests_inline {
catalog.insert(
"Dests",
remap_refs_in_object(Object::Dictionary(inline.clone()), map),
);
}
if let Some(oa_ref) = doc.open_action_ref {
if let Some(&new_ref) = map.get(&oa_ref) {
catalog.insert("OpenAction", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.open_action_inline {
catalog.insert("OpenAction", remap_refs_in_object(inline.clone(), map));
}
target.set_object(catalog_ref, Object::Dictionary(catalog));
Ok(())
}
pub(crate) fn unique_field_name(base: &[u8], used: &BTreeSet<Vec<u8>>) -> Vec<u8> {
if !used.contains(base) {
return base.to_vec();
}
for n in 1u32.. {
let mut candidate = base.to_vec();
candidate.extend_from_slice(format!("+{n}").as_bytes());
if !used.contains(&candidate) {
return candidate;
}
}
unreachable!("u32 candidate space exhausted") }
struct KeptField {
target_ref: ObjectRef,
partial_name: Option<Vec<u8>>,
is_primary: bool,
}
#[derive(Default)]
struct PrimaryAcroForm {
dr: Option<Object>,
da: Option<Object>,
closure_seed: BTreeSet<ObjectRef>,
}
fn discover_primary_acroform<R: Read + Seek>(source: &mut Pdf<R>) -> Result<PrimaryAcroForm> {
let entries = source.acroform().acroform_inherited_entries()?;
let mut out = PrimaryAcroForm::default();
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
for (key, value) in entries {
collect_refs_in_object(
source,
&value,
&mut out.closure_seed,
&mut seen,
0,
0,
false,
)?; match key.as_slice() {
b"DR" => out.dr = Some(value),
b"DA" => out.da = Some(value),
_ => {} }
}
Ok(out)
}
fn source_top_level_field_names<R: Read + Seek>(
source: &mut Pdf<R>,
) -> Result<Vec<(ObjectRef, Option<Vec<u8>>)>> {
let top_fields = source.acroform().top_level_fields()?;
let mut out = Vec::with_capacity(top_fields.len());
for field_ref in top_fields {
let terminal = resolve_ref_chain(source, &Object::Reference(field_ref))?
.1
.unwrap_or(field_ref);
let name = resolve_field_partial_name(source, terminal)?;
out.push((terminal, name));
}
Ok(out)
}
fn resolve_field_partial_name<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<u8>>> {
let t_value = {
let Some(field) = source.resolve_borrowed(field_ref)?.as_dict() else {
return Ok(None); };
field.get("T").cloned()
};
let resolved = match t_value {
Some(value @ Object::Reference(_)) => resolve_ref_chain(source, &value)?.0,
Some(other) => other,
None => return Ok(None),
};
Ok(resolved.as_string().map(<[u8]>::to_vec))
}
fn build_merged_acroform<R: Read + Seek>(
target: &mut Pdf<R>,
primary: &PrimaryAcroForm,
kept: &[KeptField],
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
if kept.is_empty() && primary.dr.is_none() && primary.da.is_none() {
return Ok(());
}
let acroform_ref = target.acroform().ensure_acroform_ref()?;
let mut acroform = match target.resolve_borrowed(acroform_ref)?.as_dict().cloned() {
Some(dict) => dict,
None => return Ok(()), };
if let Some(dr) = &primary.dr {
acroform.insert("DR", remap_refs_in_object(dr.clone(), map));
}
if let Some(da) = &primary.da {
acroform.insert("DA", remap_refs_in_object(da.clone(), map));
}
let mut used: BTreeSet<Vec<u8>> = BTreeSet::new();
for field in kept {
if field.is_primary {
if let Some(name) = &field.partial_name {
used.insert(name.clone());
}
}
}
let mut fields: Vec<Object> = Vec::with_capacity(kept.len());
for field in kept {
if !field.is_primary {
if let Some(name) = &field.partial_name {
let unique = unique_field_name(name, &used);
used.insert(unique.clone());
rename_field(target, field.target_ref, unique)?;
}
}
fields.push(Object::Reference(field.target_ref));
}
acroform.insert("Fields", Object::Array(fields));
target.set_object(acroform_ref, Object::Dictionary(acroform));
Ok(())
}
fn rename_field<R: Read + Seek>(
target: &mut Pdf<R>,
field_ref: ObjectRef,
name: Vec<u8>,
) -> Result<()> {
let Some(mut field) = target.resolve_borrowed(field_ref)?.as_dict().cloned() else {
return Ok(()); };
field.insert("T", Object::String(name));
target.set_object(field_ref, Object::Dictionary(field));
Ok(())
}
fn field_kid_refs<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<ObjectRef>>> {
let kids_value = {
let Some(field) = source.resolve_borrowed(field_ref)?.as_dict() else {
return Ok(None); };
match field.get("Kids") {
Some(value) => value.clone(),
None => return Ok(None),
}
};
let (resolved, _) = resolve_ref_chain(source, &kids_value)?;
let Object::Array(items) = resolved else {
return Ok(Some(Vec::new())); };
let mut refs = Vec::with_capacity(items.len());
for item in items {
if let Object::Reference(r) = item {
let (_, terminal) = resolve_ref_chain(source, &Object::Reference(r))?;
refs.push(terminal.unwrap_or(r));
} }
Ok(Some(refs))
}
fn collect_retained_widget_refs<R: Read + Seek>(
source: &mut Pdf<R>,
selected_pages: &BTreeSet<ObjectRef>,
retained: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
for &page_ref in selected_pages {
let annots_val = {
let page_obj = source.resolve_borrowed(page_ref)?;
let Some(page_dict) = page_obj.as_dict() else {
continue; };
page_dict.get("Annots").cloned()
};
let Some(annots_val) = annots_val else {
continue;
};
let (concrete, _) = resolve_ref_chain(source, &annots_val)?;
let Object::Array(elems) = concrete else {
continue; };
for elem in elems {
if let Object::Reference(r) = elem {
let (_, terminal) = resolve_ref_chain(source, &Object::Reference(r))?;
retained.insert(terminal.unwrap_or(r));
}
}
}
Ok(())
}
fn widget_page_ref<R: Read + Seek>(
source: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let p_value = {
let Some(widget) = source.resolve_borrowed(widget_ref)?.as_dict() else {
return Ok(None); };
match widget.get("P") {
Some(value) => value.clone(),
None => return Ok(None),
}
};
let (_, last_ref) = resolve_ref_chain(source, &p_value)?;
Ok(last_ref)
}
#[allow(clippy::too_many_arguments)]
fn trim_field_kids<R: Read + Seek>(
source: &mut Pdf<R>,
target: &mut Pdf<Cursor<Vec<u8>>>,
field_ref: ObjectRef,
surviving_pages: &BTreeSet<ObjectRef>,
retained_widgets: &BTreeSet<ObjectRef>,
map: &BTreeMap<ObjectRef, ObjectRef>,
orphan_pages: &mut BTreeSet<ObjectRef>,
depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<Option<Vec<ObjectRef>>> {
if depth > DEFAULT_MAX_ACROFORM_DEPTH {
return Err(Error::Unsupported(format!(
"AcroForm field tree depth exceeds maximum of {DEFAULT_MAX_ACROFORM_DEPTH}"
)));
}
if !visited.insert(field_ref) {
return Ok(Some(Vec::new())); }
let Some(kids) = field_kid_refs(source, field_ref)? else {
return Ok(None); };
let mut survivors: Vec<ObjectRef> = Vec::with_capacity(kids.len());
for kid_ref in kids {
let kid_kind = trim_field_kids(
source,
target,
kid_ref,
surviving_pages,
retained_widgets,
map,
orphan_pages,
depth + 1,
visited,
)?; match kid_kind {
Some(sub_survivors) => {
if sub_survivors.is_empty() {
continue;
}
rewrite_field_kids(target, kid_ref, &sub_survivors, map)?;
survivors.push(kid_ref);
}
None => {
if retained_widgets.contains(&kid_ref) {
survivors.push(kid_ref);
} else {
match widget_page_ref(source, kid_ref)? {
Some(page_ref) if surviving_pages.contains(&page_ref) => {
survivors.push(kid_ref)
}
Some(page_ref) => {
orphan_pages.insert(page_ref);
}
None => {} }
}
}
}
}
Ok(Some(survivors))
}
fn rewrite_field_kids<R: Read + Seek>(
target: &mut Pdf<R>,
src_field_ref: ObjectRef,
survivors: &[ObjectRef],
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let Some(target_field_ref) = map.get(&src_field_ref).copied() else {
return Ok(()); };
let Some(mut field) = target
.resolve_borrowed(target_field_ref)?
.as_dict()
.cloned()
else {
return Ok(()); };
let kids: Vec<Object> = survivors
.iter()
.filter_map(|src| map.get(src).map(|&t| Object::Reference(t)))
.collect();
field.insert("Kids", Object::Array(kids));
target.set_object(target_field_ref, Object::Dictionary(field));
Ok(())
}
pub fn merge_documents<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if inputs.is_empty() {
return Err(Error::Unsupported(
"merge requires at least one input".to_string(),
));
}
let mut target = Pdf::open_mem_owned(minimal_target_bytes())?;
let pages_root_ref = target_pages_root(&mut target)?;
let mut kids: Vec<ObjectRef> = Vec::new();
let mut used: BTreeSet<ObjectRef> = BTreeSet::new();
let mut kept_fields: Vec<KeptField> = Vec::new();
let mut primary_acroform = PrimaryAcroForm::default();
let mut primary_map: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
let total_selected: usize = inputs.iter().map(|i| i.pages.len()).sum();
let mut label_entries: Vec<(i64, LabelRange)> = Vec::with_capacity(total_selected);
let mut any_page_labels = false;
let mut out_pageno: i64 = 0;
let depth = DEFAULT_MAX_PAGE_TREE_DEPTH;
for (input_index, input) in inputs.iter_mut().enumerate() {
let is_primary = input_index == 0;
if !is_primary && input.pages.is_empty() {
continue;
}
if !input.pages.is_empty() {
let mut src_labels = input.source.page_labels();
if src_labels.has_page_labels()? {
any_page_labels = true;
}
let src_indices: Vec<i64> = input.pages.iter().map(|&i| i as i64).collect();
label_entries.extend(src_labels.labels_for_selection(&src_indices, out_pageno)?);
out_pageno = out_pageno.saturating_add(input.pages.len() as i64);
}
let doc_level = if is_primary {
discover_primary_doc_level(input.source)?
} else {
PrimaryDocLevel::default()
};
if is_primary {
primary_acroform = discover_primary_acroform(input.source)?;
}
let source_fields = source_top_level_field_names(input.source)?;
let all = page_refs(input.source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(input.pages.len());
for &idx in &input.pages {
let page_ref = *all.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (input document has {} pages)",
all.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 mut inherited: Vec<InheritedAttrs> = Vec::with_capacity(unique.len());
for &page_ref in &unique {
inherited.push(InheritedAttrs::resolve(input.source, page_ref, depth)?);
}
let mut closure: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &unique {
extend_page_object_closure(input.source, page_ref, &mut closure)?;
}
fold_doc_level_closure(input.source, &doc_level, &mut closure)?;
if is_primary {
closure.extend(primary_acroform.closure_seed.iter().copied());
}
let surviving_before: BTreeSet<ObjectRef> = target.object_refs().into_iter().collect();
let map = copy_objects(input.source, &mut target, &closure)?;
debug_assert!(
map.values().all(|new| !surviving_before.contains(new)),
"copy_objects must allocate refs disjoint from surviving target refs \
(renumbering-disjointness invariant; guards against shared-destination double-remap)"
);
null_copied_removed_pages(&mut target, &all, &seen, &map);
if is_primary {
wire_doc_level(&mut target, &doc_level, &map)?;
}
let mut orphan_pages: BTreeSet<ObjectRef> = BTreeSet::new();
let mut retained_widgets: BTreeSet<ObjectRef> = BTreeSet::new();
collect_retained_widget_refs(input.source, &seen, &mut retained_widgets)?;
for (src_field_ref, partial_name) in source_fields {
if let Some(&target_ref) = map.get(&src_field_ref) {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let trimmed = trim_field_kids(
input.source,
&mut target,
src_field_ref,
&seen,
&retained_widgets,
&map,
&mut orphan_pages,
0,
&mut visited,
)?; if let Some(survivors) = trimmed {
if survivors.is_empty() {
continue;
}
rewrite_field_kids(&mut target, src_field_ref, &survivors, &map)?;
}
kept_fields.push(KeptField {
target_ref,
partial_name,
is_primary,
});
}
}
for src_page_ref in &orphan_pages {
if let Some(&new_ref) = map.get(src_page_ref) {
target.set_object(new_ref, Object::Null);
}
}
if is_primary {
primary_map = map.clone();
}
for (&src_ref, attrs) in unique.iter().zip(inherited) {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("merged page missing from copy map"))?;
materialize_leaf(&mut target, copied_page_ref, attrs, &map, pages_root_ref)?;
}
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));
build_merged_acroform(&mut target, &primary_acroform, &kept_fields, &primary_map)?;
if any_page_labels {
let folded = merge_adjacent_ranges(label_entries);
target.page_labels().write_reconstructed_labels(&folded)?;
}
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
#[cfg(test)]
mod tests {
use super::{
discover_primary_doc_level, fold_doc_level_closure, merge_documents, unique_field_name,
MergeInput,
};
use crate::page_closure::extend_page_object_closure;
use crate::{Object, ObjectRef, Pdf};
use std::collections::{BTreeMap, BTreeSet};
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(|(number, _)| *number).max().unwrap_or(0);
for (number, body) in objects {
offsets.insert(*number, out.len() as u64);
out.extend_from_slice(format!("{number} 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 number in 1..=max {
match offsets.get(&number) {
Some(offset) => {
out.extend_from_slice(format!("{offset: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
}
fn used(names: &[&[u8]]) -> BTreeSet<Vec<u8>> {
names.iter().map(|n| n.to_vec()).collect()
}
#[test]
fn unique_field_name_keeps_unused_base() {
assert_eq!(unique_field_name(b"name", &used(&[])), b"name".to_vec());
assert_eq!(
unique_field_name(b"name", &used(&[b"email"])),
b"name".to_vec()
);
}
#[test]
fn unique_field_name_appends_plus_one_on_collision() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name"])),
b"name+1".to_vec()
);
}
#[test]
fn unique_field_name_finds_first_unused_in_sequence() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name", b"name+1"])),
b"name+2".to_vec()
);
}
#[test]
fn unique_field_name_reresolves_colliding_candidate() {
assert_eq!(
unique_field_name(b"name+1", &used(&[b"name", b"name+1"])),
b"name+1+1".to_vec()
);
}
#[test]
fn doc_level_page_root_is_null_boundary_without_contents_in_closure() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /OpenAction 4 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 10 0 R >>",
),
(10, "<< /Length 4 >>\nstream\nDROP\nendstream"),
],
1,
);
let mut merge_source = Pdf::open_mem_owned(bytes.clone()).unwrap();
let mut inputs = [MergeInput {
source: &mut merge_source,
pages: vec![0],
}];
let mut merged = merge_documents(&mut inputs).unwrap();
let catalog_ref = merged.root_ref().unwrap();
let catalog = merged.resolve(catalog_ref).unwrap().into_dict().unwrap();
let open_action_ref = catalog
.get_ref("OpenAction")
.expect("indirect /OpenAction carrier is retained");
assert_eq!(
merged.resolve(open_action_ref).unwrap(),
Object::Null,
"the unselected page root is copied and nulled"
);
let mut source = Pdf::open_mem_owned(bytes).unwrap();
let doc_level = discover_primary_doc_level(&mut source).unwrap();
let mut closure = BTreeSet::new();
extend_page_object_closure(&mut source, ObjectRef::new(3, 0), &mut closure).unwrap();
fold_doc_level_closure(&mut source, &doc_level, &mut closure).unwrap();
assert!(
closure.contains(&ObjectRef::new(4, 0)),
"the indirect /OpenAction page root must enter the copy map"
);
assert!(
!closure.contains(&ObjectRef::new(10, 0)),
"the boundary page's /Contents must not enter the copy map"
);
}
}