use crate::page_tree_rebuild::RebuildResult;
use crate::{Error, Object, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
pub fn remap_outline_and_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
remap_outline_and_dests_with_max_depth(pdf, result, crate::outline::DEFAULT_MAX_OUTLINE_DEPTH)
}
pub fn remap_outline_and_dests_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
max_depth: usize,
) -> Result<()> {
let surviving: BTreeMap<ObjectRef, ObjectRef> = result
.ref_map
.iter()
.filter_map(|(&old, new_refs)| new_refs.first().map(|&new| (old, new)))
.collect();
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()), };
let catalog_obj = pdf.resolve(catalog_ref)?;
let Some(catalog) = catalog_obj.into_dict() else {
return Ok(());
};
let outlines_ref = catalog.get_ref("Outlines");
let mut surviving_names: BTreeSet<Vec<u8>> = BTreeSet::new();
enum NamesLoc {
Indirect(ObjectRef),
DirectInCatalog,
}
let (names_loc, mut names_dict) = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve(r)? {
Object::Dictionary(d) => (Some(NamesLoc::Indirect(r)), d),
_ => (None, crate::Dictionary::default()),
},
Some(Object::Dictionary(d)) => (Some(NamesLoc::DirectInCatalog), d),
_ => (None, crate::Dictionary::default()),
};
if let Some(names_loc) = names_loc {
let dests_empty = match names_dict.get("Dests").cloned() {
Some(Object::Reference(dr)) => {
let mut nt_visited: BTreeSet<ObjectRef> = BTreeSet::new();
prune_name_tree(
pdf,
dr,
&surviving,
&mut surviving_names,
0,
max_depth,
&mut nt_visited,
)?
}
Some(Object::Dictionary(node)) => {
let (new_node, empty) = prune_name_tree_node_dict(
pdf,
node,
&surviving,
&mut surviving_names,
max_depth,
)?;
if !empty {
names_dict.insert("Dests", Object::Dictionary(new_node));
}
empty
}
_ => false,
};
if dests_empty {
names_dict.remove("Dests");
}
let names_now_empty = names_dict.iter().next().is_none();
match names_loc {
NamesLoc::Indirect(r) => {
if names_now_empty {
let catalog_obj3 = pdf.resolve(catalog_ref)?;
if let Some(mut cat) = catalog_obj3.into_dict() {
cat.remove("Names");
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
} else {
pdf.set_object(r, Object::Dictionary(names_dict));
}
}
NamesLoc::DirectInCatalog => {
let catalog_obj3 = pdf.resolve(catalog_ref)?;
if let Some(mut cat) = catalog_obj3.into_dict() {
if names_now_empty {
cat.remove("Names");
} else {
cat.insert("Names", Object::Dictionary(names_dict));
}
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
}
}
}
let catalog_obj2 = pdf.resolve(catalog_ref)?;
let Some(catalog2) = catalog_obj2.into_dict() else {
return Ok(());
};
match catalog2.get("Dests").cloned() {
Some(Object::Reference(dests_obj_ref)) => {
prune_legacy_dests(pdf, dests_obj_ref, &surviving, &mut surviving_names)?;
}
Some(Object::Dictionary(dests)) => {
let new_dests = prune_dests_dict(pdf, dests, &surviving, &mut surviving_names)?;
let catalog_obj3 = pdf.resolve(catalog_ref)?;
if let Some(mut cat) = catalog_obj3.into_dict() {
cat.insert("Dests", Object::Dictionary(new_dests));
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
}
_ => {}
}
if let Some(outlines_obj_ref) = outlines_ref {
let outline_root_obj = pdf.resolve(outlines_obj_ref)?;
if let Some(outline_root) = outline_root_obj.into_dict() {
if let Some(first_ref) = outline_root.get_ref("First") {
let mut kept: Vec<ObjectRef> = Vec::new();
let mut dropped: BTreeSet<ObjectRef> = BTreeSet::new();
collect_siblings(
pdf,
first_ref,
0,
max_depth,
&surviving,
&surviving_names,
&mut kept,
&mut dropped,
)?;
if kept.is_empty() {
let catalog_obj3 = pdf.resolve(catalog_ref)?;
if let Some(mut cat) = catalog_obj3.into_dict() {
cat.remove("Outlines");
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
} else {
stitch_siblings(pdf, &kept, outlines_obj_ref)?;
let new_count = count_visible_descendants(pdf, &kept, max_depth)?;
let outline_root_obj2 = pdf.resolve(outlines_obj_ref)?;
if let Some(mut root_dict) = outline_root_obj2.into_dict() {
root_dict.insert("Count", Object::Integer(new_count));
root_dict.insert("First", Object::Reference(kept[0]));
root_dict
.insert("Last", Object::Reference(*kept.last().expect("non-empty")));
pdf.set_object(outlines_obj_ref, Object::Dictionary(root_dict));
}
}
}
}
}
Ok(())
}
fn prune_name_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &mut BTreeSet<Vec<u8>>,
depth: usize,
max_depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<bool> {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"outline_dest_remap: name-tree depth limit {max_depth} exceeded at {node_ref}"
)));
}
if !visited.insert(node_ref) {
return Ok(true);
}
let node_obj = pdf.resolve(node_ref)?;
let Some(node) = node_obj.into_dict() else {
return Ok(true); };
let has_names = node.get("Names").is_some();
let has_kids = node.get("Kids").is_some();
if has_names {
let names_val = node.get("Names").cloned();
if let Some(pairs) = names_val.and_then(Object::into_array) {
let filtered = prune_name_pairs(pdf, pairs, surviving, surviving_names)?;
if filtered.is_empty() {
return Ok(true); }
let node_obj2 = pdf.resolve(node_ref)?;
if let Some(mut d) = node_obj2.into_dict() {
let limits = compute_limits(&filtered);
d.insert("Names", Object::Array(filtered));
if let Some(lim) = limits {
d.insert("Limits", lim);
} else {
d.remove("Limits");
}
pdf.set_object(node_ref, Object::Dictionary(d));
}
return Ok(false);
}
return Ok(true);
}
if has_kids {
if let Some(kids) = node.get("Kids").and_then(Object::as_array) {
let child_refs: Vec<ObjectRef> = kids.iter().filter_map(Object::as_ref_id).collect();
let mut surviving_kids: Vec<ObjectRef> = Vec::new();
for child_ref in child_refs {
let empty = prune_name_tree(
pdf,
child_ref,
surviving,
surviving_names,
depth + 1,
max_depth,
visited,
)?;
if !empty {
surviving_kids.push(child_ref);
}
}
if surviving_kids.is_empty() {
return Ok(true);
}
let node_obj2 = pdf.resolve(node_ref)?;
if let Some(mut d) = node_obj2.into_dict() {
d.insert(
"Kids",
Object::Array(
surviving_kids
.iter()
.map(|&r| Object::Reference(r))
.collect(),
),
);
let limits = merge_node_limits(pdf, &surviving_kids)?;
if let Some(lim) = limits {
d.insert("Limits", lim);
} else {
d.remove("Limits");
}
pdf.set_object(node_ref, Object::Dictionary(d));
}
return Ok(false);
}
}
Ok(true) }
fn prune_name_tree_node_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: crate::Dictionary,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &mut BTreeSet<Vec<u8>>,
max_depth: usize,
) -> Result<(crate::Dictionary, bool)> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
if let Some(Object::Array(pairs)) = node.get("Names").cloned() {
let filtered = prune_name_pairs(pdf, pairs, surviving, surviving_names)?;
if filtered.is_empty() {
return Ok((node, true));
}
let mut d = node.clone();
let limits = compute_limits(&filtered);
d.insert("Names", Object::Array(filtered));
if let Some(lim) = limits {
d.insert("Limits", lim);
} else {
d.remove("Limits");
}
return Ok((d, false));
}
if let Some(kids) = node.get("Kids").and_then(Object::as_array) {
let child_refs: Vec<ObjectRef> = kids.iter().filter_map(Object::as_ref_id).collect();
let mut surviving_kids: Vec<ObjectRef> = Vec::new();
for child_ref in child_refs {
if !prune_name_tree(
pdf,
child_ref,
surviving,
surviving_names,
1,
max_depth,
&mut visited,
)? {
surviving_kids.push(child_ref);
}
}
if surviving_kids.is_empty() {
return Ok((node, true));
}
let mut d = node.clone();
d.insert(
"Kids",
Object::Array(
surviving_kids
.iter()
.map(|&r| Object::Reference(r))
.collect(),
),
);
if let Some(lim) = merge_node_limits(pdf, &surviving_kids)? {
d.insert("Limits", lim);
} else {
d.remove("Limits");
}
return Ok((d, false));
}
Ok((node, true))
}
fn prune_name_pairs<R: Read + Seek>(
pdf: &mut Pdf<R>,
pairs: Vec<Object>,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &mut BTreeSet<Vec<u8>>,
) -> Result<Vec<Object>> {
let mut result: Vec<Object> = Vec::new();
let mut i = 0;
while i + 1 < pairs.len() {
let name_obj = pairs[i].clone();
let dest_obj = pairs[i + 1].clone();
i += 2;
let name_bytes = match &name_obj {
Object::String(b) | Object::Name(b) => b.clone(),
_ => continue, };
match dest_page_ref_resolved(pdf, &dest_obj)? {
Some(page_ref) => {
if surviving.contains_key(&page_ref) {
surviving_names.insert(name_bytes.clone());
match remap_dest_value(pdf, &dest_obj, surviving)? {
Some(updated) => {
result.push(name_obj);
result.push(updated);
}
None => {
result.push(name_obj);
result.push(dest_obj);
}
}
}
}
None => {
surviving_names.insert(name_bytes.clone());
result.push(name_obj);
result.push(dest_obj);
}
}
}
Ok(result)
}
fn prune_legacy_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
dests_ref: ObjectRef,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &mut BTreeSet<Vec<u8>>,
) -> Result<()> {
let dests_obj = pdf.resolve(dests_ref)?;
let Some(dests) = dests_obj.into_dict() else {
return Ok(());
};
let new_dests = prune_dests_dict(pdf, dests, surviving, surviving_names)?;
pdf.set_object(dests_ref, Object::Dictionary(new_dests));
Ok(())
}
fn prune_dests_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
dests: crate::Dictionary,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &mut BTreeSet<Vec<u8>>,
) -> Result<crate::Dictionary> {
let mut new_dests = dests.clone();
let keys: Vec<Vec<u8>> = dests.iter().map(|(k, _)| k.to_vec()).collect();
for key in keys {
let val = match dests.get(&key).cloned() {
Some(v) => v,
None => continue,
};
match dest_page_ref_resolved(pdf, &val)? {
Some(page_ref) => {
if surviving.contains_key(&page_ref) {
surviving_names.insert(key.clone());
if let Some(updated) = remap_dest_value(pdf, &val, surviving)? {
new_dests.insert(key, updated);
}
} else {
new_dests.remove(&key);
}
}
None => {
surviving_names.insert(key.clone());
}
}
}
Ok(new_dests)
}
#[allow(clippy::too_many_arguments)]
fn collect_siblings<R: Read + Seek>(
pdf: &mut Pdf<R>,
first_ref: ObjectRef,
depth: usize,
max_depth: usize,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &BTreeSet<Vec<u8>>,
kept: &mut Vec<ObjectRef>,
dropped: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"outline_dest_remap: depth limit {max_depth} exceeded at {first_ref}"
)));
}
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = Some(first_ref);
while let Some(item_ref) = current {
if !visited.insert(item_ref) {
break; }
let item_obj = pdf.resolve(item_ref)?;
let Some(item) = item_obj.into_dict() else {
break; };
let next_ref = item.get_ref("Next");
let first_child = item.get_ref("First");
let dest_val = item.get("Dest").cloned();
let action_val = item.get("A").cloned();
let keep = item_survives(pdf, &dest_val, &action_val, surviving, surviving_names)?;
if keep {
if let Some(child_first) = first_child {
let mut child_kept: Vec<ObjectRef> = Vec::new();
let mut child_dropped: BTreeSet<ObjectRef> = BTreeSet::new();
collect_siblings(
pdf,
child_first,
depth + 1,
max_depth,
surviving,
surviving_names,
&mut child_kept,
&mut child_dropped,
)?;
if child_kept.is_empty() {
let item_obj2 = pdf.resolve(item_ref)?;
if let Some(mut d) = item_obj2.into_dict() {
d.remove("First");
d.remove("Last");
d.remove("Count");
pdf.set_object(item_ref, Object::Dictionary(d));
}
} else {
stitch_siblings(pdf, &child_kept, item_ref)?;
let visible = count_visible_descendants(pdf, &child_kept, max_depth)?;
let item_obj2 = pdf.resolve(item_ref)?;
if let Some(mut d) = item_obj2.into_dict() {
let count_sign = match d.get("Count") {
Some(Object::Integer(n)) if *n < 0 => -1i64,
_ => 1i64,
};
d.insert("Count", Object::Integer(count_sign * visible));
d.insert("First", Object::Reference(child_kept[0]));
d.insert(
"Last",
Object::Reference(*child_kept.last().expect("non-empty")),
);
pdf.set_object(item_ref, Object::Dictionary(d));
}
}
}
remap_item_dest(pdf, item_ref, surviving)?;
kept.push(item_ref);
} else {
dropped.insert(item_ref);
if let Some(child_first) = first_child {
drop_subtree(pdf, child_first, dropped, depth + 1, max_depth)?;
}
}
current = next_ref;
}
Ok(())
}
fn drop_subtree<R: Read + Seek>(
pdf: &mut Pdf<R>,
first_ref: ObjectRef,
dropped: &mut BTreeSet<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"outline_dest_remap: depth limit {max_depth} exceeded at {first_ref}"
)));
}
let mut current = Some(first_ref);
while let Some(item_ref) = current {
if !dropped.insert(item_ref) {
break;
}
let item_obj = pdf.resolve(item_ref)?;
let Some(item) = item_obj.into_dict() else {
break;
};
if let Some(child_first) = item.get_ref("First") {
drop_subtree(pdf, child_first, dropped, depth + 1, max_depth)?;
}
current = item.get_ref("Next");
}
Ok(())
}
fn stitch_siblings<R: Read + Seek>(
pdf: &mut Pdf<R>,
kept: &[ObjectRef],
parent_ref: ObjectRef,
) -> Result<()> {
for (i, &item_ref) in kept.iter().enumerate() {
let item_obj = pdf.resolve(item_ref)?;
let Some(mut d) = item_obj.into_dict() else {
continue;
};
d.insert("Parent", Object::Reference(parent_ref));
if i == 0 {
d.remove("Prev");
} else {
d.insert("Prev", Object::Reference(kept[i - 1]));
}
if i + 1 == kept.len() {
d.remove("Next");
} else {
d.insert("Next", Object::Reference(kept[i + 1]));
}
pdf.set_object(item_ref, Object::Dictionary(d));
}
Ok(())
}
fn count_visible_descendants<R: Read + Seek>(
pdf: &mut Pdf<R>,
items: &[ObjectRef],
max_depth: usize,
) -> Result<i64> {
count_visible_in_chain(pdf, items, max_depth, 0)
}
fn count_visible_in_chain<R: Read + Seek>(
pdf: &mut Pdf<R>,
items: &[ObjectRef],
max_depth: usize,
depth: usize,
) -> Result<i64> {
if depth >= max_depth {
return Ok(0);
}
let mut count = items.len() as i64;
for &item_ref in items {
let item_obj = pdf.resolve(item_ref)?;
let Some(d) = item_obj.into_dict() else {
continue;
};
if let Some(n) = d.get("Count").and_then(Object::as_integer) {
if n > 0 {
count += n;
}
}
}
Ok(count)
}
fn item_survives<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest_val: &Option<Object>,
action_val: &Option<Object>,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &BTreeSet<Vec<u8>>,
) -> Result<bool> {
if let Some(dest) = dest_val {
return dest_survives(pdf, dest, surviving, surviving_names);
}
if let Some(action) = action_val {
let (resolved, _) = resolve_ref_chain(pdf, action)?;
let action = &resolved;
if let Some(a) = action.as_dict() {
let is_goto = matches!(a.get("S"), Some(Object::Name(n)) if n == b"GoTo");
if is_goto {
if let Some(d) = a.get("D").cloned() {
return dest_survives(pdf, &d, surviving, surviving_names);
}
}
}
return Ok(true);
}
Ok(true)
}
fn resolve_ref_chain<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: &Object,
) -> Result<(Object, Option<ObjectRef>)> {
let mut last_ref: Option<ObjectRef> = None;
let mut cur = start.clone();
for _ in 0..MAX_DEST_RESOLVE_DEPTH {
match cur {
Object::Reference(r) => {
last_ref = Some(r);
cur = pdf.resolve(r)?;
}
_ => break,
}
}
Ok((cur, last_ref))
}
fn dest_survives<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &Object,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
surviving_names: &BTreeSet<Vec<u8>>,
) -> Result<bool> {
let (concrete, _) = resolve_ref_chain(pdf, dest)?;
if let Object::String(name) | Object::Name(name) = &concrete {
return Ok(surviving_names.contains(name.as_slice()));
}
Ok(match dest_page_ref_resolved(pdf, dest)? {
Some(page_ref) => surviving.contains_key(&page_ref),
None => true,
})
}
fn remap_item_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
item_ref: ObjectRef,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let item_obj = pdf.resolve(item_ref)?;
let Some(mut d) = item_obj.into_dict() else {
return Ok(());
};
let mut changed = false;
if let Some(dest) = d.get("Dest").cloned() {
if let Some(remapped) = remap_dest_value(pdf, &dest, surviving)? {
d.insert("Dest", remapped);
changed = true;
}
}
if let Some(a_val) = d.get("A").cloned() {
let (action_obj, action_target) = resolve_ref_chain(pdf, &a_val)?;
if let Some(mut action) = action_obj.into_dict() {
let is_goto = matches!(action.get("S"), Some(Object::Name(n)) if n == b"GoTo");
if is_goto {
if let Some(d_val) = action.get("D").cloned() {
if let Some(remapped) = remap_dest_value(pdf, &d_val, surviving)? {
action.insert("D", remapped);
match action_target {
Some(ar) => {
pdf.set_object(ar, Object::Dictionary(action));
}
None => {
d.insert("A", Object::Dictionary(action));
changed = true;
}
}
}
}
}
}
}
if changed {
pdf.set_object(item_ref, Object::Dictionary(d));
}
Ok(())
}
fn remap_dest_value<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &Object,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<Option<Object>> {
remap_dest_value_depth(pdf, dest, surviving, MAX_DEST_RESOLVE_DEPTH)
}
const MAX_DEST_RESOLVE_DEPTH: usize = 64;
fn remap_dest_value_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &Object,
surviving: &BTreeMap<ObjectRef, ObjectRef>,
depth: usize,
) -> Result<Option<Object>> {
if depth == 0 {
return Ok(None);
}
match dest {
Object::Reference(dr) => {
let concrete = pdf.resolve(*dr)?;
if let Some(updated) = remap_dest_value_depth(pdf, &concrete, surviving, depth - 1)? {
pdf.set_object(*dr, updated);
}
Ok(None)
}
Object::Array(arr) => {
if let Some(old) = arr.first().and_then(Object::as_ref_id) {
if let Some(&new_ref) = surviving.get(&old) {
let mut a = arr.clone();
a[0] = Object::Reference(new_ref);
return Ok(Some(Object::Array(a)));
}
}
Ok(None)
}
Object::Dictionary(d) => {
if let Some(d_val) = d.get("D").cloned() {
if let Some(updated) = remap_dest_value_depth(pdf, &d_val, surviving, depth - 1)? {
let mut nd = d.clone();
nd.insert("D", updated);
return Ok(Some(Object::Dictionary(nd)));
}
}
Ok(None)
}
_ => Ok(None),
}
}
fn dest_page_ref_resolved<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &Object,
) -> Result<Option<ObjectRef>> {
dest_page_ref_resolved_depth(pdf, dest, MAX_DEST_RESOLVE_DEPTH)
}
fn dest_page_ref_resolved_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &Object,
depth: usize,
) -> Result<Option<ObjectRef>> {
if depth == 0 {
return Ok(None);
}
match dest {
Object::Reference(r) => {
let c = pdf.resolve(*r)?;
dest_page_ref_resolved_depth(pdf, &c, depth - 1)
}
Object::Array(arr) => Ok(match arr.first() {
Some(Object::Reference(r)) => Some(*r),
_ => None,
}),
Object::Dictionary(d) => match d.get("D").cloned() {
Some(v) => dest_page_ref_resolved_depth(pdf, &v, depth - 1),
None => Ok(None),
},
_ => Ok(None),
}
}
fn compute_limits(pairs: &[Object]) -> Option<Object> {
if pairs.len() < 2 {
return None;
}
let first_name = pairs[0].clone();
let last_name = pairs[pairs.len() - 2].clone();
Some(Object::Array(vec![first_name, last_name]))
}
fn merge_node_limits<R: Read + Seek>(
pdf: &mut Pdf<R>,
kids: &[ObjectRef],
) -> Result<Option<Object>> {
if kids.is_empty() {
return Ok(None);
}
let first_kid_obj = pdf.resolve(kids[0])?;
let last_kid_obj = pdf.resolve(*kids.last().expect("non-empty"))?;
let first_min = if let Some(d) = first_kid_obj.as_dict() {
if let Some(lim) = d.get("Limits").and_then(Object::as_array) {
lim.first().cloned()
} else {
None
}
} else {
None
};
let last_max = if let Some(d) = last_kid_obj.as_dict() {
if let Some(lim) = d.get("Limits").and_then(Object::as_array) {
lim.last().cloned()
} else {
None
}
} else {
None
};
match (first_min, last_max) {
(Some(min), Some(max)) => Ok(Some(Object::Array(vec![min, max]))),
_ => Ok(None),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::check::check_reader;
use crate::page_tree_rebuild::rebuild_page_tree;
use crate::writer::write_pdf;
use crate::{Object, ObjectRef, Pdf};
use std::collections::BTreeMap;
use std::io::Cursor;
fn build_outline_pdf() -> Vec<u8> {
let mut raw: Vec<u8> = b"%PDF-1.5\n".to_vec();
let mut offs: BTreeMap<u32, usize> = BTreeMap::new();
let add = |raw: &mut Vec<u8>, offs: &mut BTreeMap<u32, usize>, num: u32, content: &str| {
offs.insert(num, raw.len());
raw.extend_from_slice(format!("{num} 0 obj\n{content}\nendobj\n").as_bytes());
};
add(
&mut raw,
&mut offs,
1,
"<< /Type /Catalog /Pages 2 0 R /Outlines 10 0 R /Names 11 0 R >>",
);
add(
&mut raw,
&mut offs,
2,
"<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R 6 0 R] /Count 4 >>",
);
add(
&mut raw,
&mut offs,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
add(
&mut raw,
&mut offs,
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
add(
&mut raw,
&mut offs,
5,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
add(
&mut raw,
&mut offs,
6,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
add(
&mut raw,
&mut offs,
10,
"<< /Type /Outlines /First 20 0 R /Last 23 0 R /Count 5 >>",
);
add(&mut raw, &mut offs, 11, "<< /Dests 30 0 R >>");
add(
&mut raw,
&mut offs,
30,
"<< /Limits [(dest_named_p4) (dest_p3)] \
/Names [(dest_named_p4) [6 0 R /XYZ 0 792 0] \
(dest_p1) [3 0 R /XYZ 0 792 0] \
(dest_p2) [4 0 R /XYZ 0 792 0] \
(dest_p3) [5 0 R /XYZ 0 792 0]] >>",
);
add(
&mut raw,
&mut offs,
20,
"<< /Title (Page 1) /Parent 10 0 R /Next 21 0 R /Dest [3 0 R /XYZ 0 792 0] >>",
);
add(
&mut raw,
&mut offs,
21,
"<< /Title (Page 2) /Parent 10 0 R /Prev 20 0 R /Next 22 0 R \
/A << /S /GoTo /D [4 0 R /XYZ 0 792 0] >> >>",
);
add(
&mut raw,
&mut offs,
22,
"<< /Title (Page 3) /Parent 10 0 R /Prev 21 0 R /Next 23 0 R \
/Dest [5 0 R /Fit] /First 24 0 R /Last 24 0 R /Count 1 >>",
);
add(
&mut raw,
&mut offs,
23,
"<< /Title (Page 4) /Parent 10 0 R /Prev 22 0 R /Dest (dest_named_p4) >>",
);
add(
&mut raw,
&mut offs,
24,
"<< /Title (Page 3 sub) /Parent 22 0 R /Dest [5 0 R /XYZ 0 400 0] >>",
);
let all_nums: Vec<u32> = offs.keys().cloned().collect();
let max_num = *all_nums.iter().max().unwrap_or(&0);
let xref_pos = raw.len();
raw.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", max_num + 1).as_bytes());
for i in 1..=max_num {
if let Some(&off) = offs.get(&i) {
raw.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
} else {
raw.extend_from_slice(b"0000000000 65535 f \n");
}
}
raw.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
max_num + 1,
xref_pos
)
.as_bytes(),
);
raw
}
fn open(bytes: Vec<u8>) -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(bytes)).expect("PDF should parse")
}
fn dict_of(pdf: &mut Pdf<Cursor<Vec<u8>>>, r: ObjectRef) -> crate::Dictionary {
match pdf.resolve(r).unwrap() {
Object::Dictionary(d) => d,
other => panic!("{r} is not a dictionary: {other:?}"),
}
}
fn get_ref(d: &crate::Dictionary, key: &str) -> Option<ObjectRef> {
d.get_ref(key)
}
#[test]
fn all_pages_survive_remap_only() {
let mut pdf = open(build_outline_pdf());
let pages = vec![
ObjectRef::new(3, 0),
ObjectRef::new(4, 0),
ObjectRef::new(5, 0),
ObjectRef::new(6, 0),
];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
assert!(
cat.get_ref("Outlines").is_some(),
"catalog should still have /Outlines"
);
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert_eq!(
item20.get("Dest"),
Some(&Object::Array(vec![
Object::Reference(new_p1),
Object::Name(b"XYZ".to_vec()),
Object::Integer(0),
Object::Integer(792),
Object::Integer(0),
])),
"item 20 dest should use new page ref"
);
}
#[test]
fn dropped_pages_outline_items_removed_and_stitched() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let outlines_ref = cat
.get_ref("Outlines")
.expect("catalog should have /Outlines");
let root = dict_of(&mut pdf, outlines_ref);
assert_eq!(
root.get_ref("First"),
Some(ObjectRef::new(20, 0)),
"outline root /First should be item 20 (Page 1)"
);
assert_eq!(
root.get_ref("Last"),
Some(ObjectRef::new(22, 0)),
"outline root /Last should be item 22 (Page 3)"
);
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert_eq!(
get_ref(&item20, "Next"),
Some(ObjectRef::new(22, 0)),
"item 20 /Next should jump to item 22 (dropping item 21)"
);
assert!(
get_ref(&item20, "Prev").is_none(),
"item 20 should have no /Prev (it is now first)"
);
let item22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(
get_ref(&item22, "Prev"),
Some(ObjectRef::new(20, 0)),
"item 22 /Prev should be item 20"
);
assert!(
get_ref(&item22, "Next").is_none(),
"item 22 should have no /Next (it is now last)"
);
let first_child = get_ref(&item22, "First");
assert_eq!(
first_child,
Some(ObjectRef::new(24, 0)),
"item 22 should still have child 24"
);
}
#[test]
fn count_recomputed_correctly() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let outlines_ref = cat.get_ref("Outlines").unwrap();
let root = dict_of(&mut pdf, outlines_ref);
assert_eq!(
root.get("Count"),
Some(&Object::Integer(3)),
"outline root /Count should be 3"
);
let item22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(
item22.get("Count"),
Some(&Object::Integer(1)),
"item 22 /Count should be 1"
);
}
#[test]
fn all_items_dropped_outlines_removed_from_catalog() {
let mut pdf = open(build_outline_pdf());
let fake_ref = ObjectRef::new(3, 0); let result = RebuildResult {
new_kids: vec![fake_ref],
ref_map: BTreeMap::new(), };
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
assert!(
cat.get_ref("Outlines").is_none(),
"catalog should NOT have /Outlines when all items are dropped"
);
}
#[test]
fn named_dests_pruned_and_remapped() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let name_tree = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = name_tree.get("Names") else {
panic!("name tree /Names should still be an array");
};
let name_strs: Vec<String> = names
.iter()
.step_by(2)
.map(|o| match o {
Object::String(b) => String::from_utf8_lossy(b).into_owned(),
Object::Name(b) => String::from_utf8_lossy(b).into_owned(),
_ => "<other>".into(),
})
.collect();
assert!(
name_strs.contains(&"dest_p1".to_string()),
"dest_p1 should survive"
);
assert!(
name_strs.contains(&"dest_p3".to_string()),
"dest_p3 should survive"
);
assert!(
!name_strs.contains(&"dest_p2".to_string()),
"dest_p2 should be pruned (page 2 removed)"
);
assert!(
!name_strs.contains(&"dest_named_p4".to_string()),
"dest_named_p4 should be pruned (page 4 removed)"
);
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
let new_p3 = result.ref_map[&ObjectRef::new(5, 0)][0];
let p1_idx = names
.iter()
.step_by(2)
.position(|o| matches!(o, Object::String(b) if b == b"dest_p1"));
if let Some(idx) = p1_idx {
let dest = &names[idx * 2 + 1];
if let Some(arr) = dest.as_array() {
assert_eq!(
arr.first(),
Some(&Object::Reference(new_p1)),
"dest_p1 should point at new page 1 ref"
);
} else {
panic!("dest_p1 dest should be array");
}
}
let p3_idx = names
.iter()
.step_by(2)
.position(|o| matches!(o, Object::String(b) if b == b"dest_p3"));
if let Some(idx) = p3_idx {
let dest = &names[idx * 2 + 1];
if let Some(arr) = dest.as_array() {
assert_eq!(
arr.first(),
Some(&Object::Reference(new_p3)),
"dest_p3 should point at new page 3 ref"
);
} else {
panic!("dest_p3 dest should be array");
}
}
}
#[test]
fn string_dest_outline_item_dropped_when_named_dest_pruned() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let outlines_ref = cat.get_ref("Outlines").unwrap();
let root = dict_of(&mut pdf, outlines_ref);
assert_ne!(
root.get_ref("Last"),
Some(ObjectRef::new(23, 0)),
"item 23 (string-dest pointing at removed named dest) should be dropped"
);
assert_eq!(
root.get_ref("Last"),
Some(ObjectRef::new(22, 0)),
"outline root /Last should be item 22 after dropping item 23"
);
}
#[test]
fn duplicate_selection_uses_first_new_ref() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(3, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
assert_eq!(result.ref_map[&ObjectRef::new(3, 0)].len(), 2);
let first_new = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
if let Some(arr) = item20.get("Dest").and_then(Object::as_array) {
assert_eq!(
arr.first(),
Some(&Object::Reference(first_new)),
"item 20 should be remapped to first new ref of duplicated page"
);
} else {
panic!("item 20 /Dest should be array");
}
}
#[test]
fn round_trip_produces_valid_pdf() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)];
let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let report = check_reader(Cursor::new(out)).expect("check should run");
assert!(
report.valid,
"rebuilt PDF should pass check_reader: {:?}",
report.diagnostics
);
}
#[test]
fn all_named_dests_pruned_removes_names_dests_from_catalog() {
let mut pdf = open(build_outline_pdf());
let result = RebuildResult {
new_kids: vec![ObjectRef::new(3, 0)],
ref_map: BTreeMap::new(), };
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
assert!(
cat.get_ref("Names").is_none(),
"catalog /Names should be removed when all named dests are pruned"
);
assert!(
cat.get_ref("Outlines").is_none(),
"catalog /Outlines should be removed when all outline items are dropped"
);
}
#[test]
fn parent_with_all_children_dropped_has_no_first_last() {
let mut pdf = open(build_outline_pdf());
let pages = vec![ObjectRef::new(3, 0)]; let result = rebuild_page_tree(&mut pdf, &pages).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let outlines_ref = cat
.get_ref("Outlines")
.expect("catalog should still have /Outlines");
let root = dict_of(&mut pdf, outlines_ref);
assert_eq!(root.get_ref("First"), Some(ObjectRef::new(20, 0)));
assert_eq!(root.get_ref("Last"), Some(ObjectRef::new(20, 0)));
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert!(item20.get_ref("Next").is_none());
assert!(item20.get_ref("Prev").is_none());
}
fn build_min_pdf(objs: &[(u32, &str)], trailer_extra: &str) -> Vec<u8> {
let mut raw: Vec<u8> = b"%PDF-1.5\n".to_vec();
let mut offs: BTreeMap<u32, usize> = BTreeMap::new();
for (num, body) in objs {
offs.insert(*num, raw.len());
raw.extend_from_slice(format!("{num} 0 obj\n{body}\nendobj\n").as_bytes());
}
let max_num = objs.iter().map(|(n, _)| *n).max().unwrap_or(0);
let xref_pos = raw.len();
raw.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", max_num + 1).as_bytes());
for i in 1..=max_num {
if let Some(&off) = offs.get(&i) {
raw.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
} else {
raw.extend_from_slice(b"0000000000 65535 f \n");
}
}
raw.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R {trailer_extra} >>\nstartxref\n{}\n%%EOF\n",
max_num + 1,
xref_pos
)
.as_bytes(),
);
raw
}
#[test]
fn indirect_named_dest_remapped_and_pruned() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Names 11 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] >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Limits [(d1) (d2)] /Names [(d1) 40 0 R (d2) 41 0 R] >>",
),
(40, "[3 0 R /XYZ 0 792 0]"),
(41, "[4 0 R /XYZ 0 792 0]"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names").cloned() else {
panic!("/Names array expected");
};
let kept_names: Vec<&[u8]> = names
.iter()
.filter_map(|o| match o {
Object::String(b) | Object::Name(b) => Some(b.as_slice()),
_ => None,
})
.collect();
assert_eq!(kept_names, vec![b"d1".as_slice()]);
assert!(names
.iter()
.any(|o| matches!(o, Object::Reference(r) if *r == ObjectRef::new(40, 0))));
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr) = dest40.into_array() else {
panic!("obj 40 should remain a dest array");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn surviving_parent_with_all_children_dropped_has_no_count() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Outlines 10 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] >>"),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 20 0 R /Count 1 >>",
),
(
20,
"<< /Title (P1) /Parent 10 0 R /Dest [3 0 R /Fit] \
/First 21 0 R /Last 21 0 R /Count -1 >>",
),
(
21,
"<< /Title (P2 sub) /Parent 20 0 R /Dest [4 0 R /Fit] >>",
),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert!(item20.get_ref("First").is_none());
assert!(item20.get_ref("Last").is_none());
assert!(
item20.get("Count").is_none(),
"childless item must not retain /Count (was -1), got {:?}",
item20.get("Count")
);
}
#[test]
fn dict_form_named_dest_page_ref_is_remapped() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Names 11 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] >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Limits [(d1) (d1)] /Names [(d1) << /D [3 0 R /Fit] >>] >>",
),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names").cloned() else {
panic!("/Names array expected");
};
let dest = &names[1];
let Some(dd) = dest.as_dict() else {
panic!("dict-form dest expected, got {dest:?}");
};
let Some(arr) = dd.get("D").and_then(Object::as_array) else {
panic!("/D array expected");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn indirect_outline_item_dest_remapped_and_dropped() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Outlines 10 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] >>"),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 21 0 R /Count 2 >>",
),
(
20,
"<< /Title (P1) /Parent 10 0 R /Next 21 0 R /Dest 40 0 R >>",
),
(
21,
"<< /Title (P2) /Parent 10 0 R /Prev 20 0 R /Dest 41 0 R >>",
),
(40, "[3 0 R /Fit]"),
(41, "[4 0 R /Fit]"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let root = dict_of(&mut pdf, ObjectRef::new(10, 0));
assert_eq!(root.get_ref("First"), Some(ObjectRef::new(20, 0)));
assert_eq!(root.get_ref("Last"), Some(ObjectRef::new(20, 0)));
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert!(item20.get_ref("Next").is_none());
assert_eq!(item20.get_ref("Dest"), Some(ObjectRef::new(40, 0)));
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr) = dest40.into_array() else {
panic!("obj 40 should stay a dest array");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn indirect_goto_action_remapped_and_dropped() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Outlines 10 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] >>"),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 21 0 R /Count 2 >>",
),
(
20,
"<< /Title (P1) /Parent 10 0 R /Next 21 0 R /A 50 0 R >>",
),
(
21,
"<< /Title (P2) /Parent 10 0 R /Prev 20 0 R /A 51 0 R >>",
),
(50, "<< /S /GoTo /D [3 0 R /Fit] >>"),
(51, "<< /S /GoTo /D [4 0 R /Fit] >>"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let root = dict_of(&mut pdf, ObjectRef::new(10, 0));
assert_eq!(root.get_ref("First"), Some(ObjectRef::new(20, 0)));
assert_eq!(root.get_ref("Last"), Some(ObjectRef::new(20, 0)));
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert_eq!(item20.get_ref("A"), Some(ObjectRef::new(50, 0)));
let action50 = dict_of(&mut pdf, ObjectRef::new(50, 0));
let Some(Object::Array(arr)) = action50.get("D") else {
panic!("/D array expected on action 50");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn conserved_no_page_named_dest_keeps_string_dest_outline_item() {
let bytes = build_min_pdf(
&[
(
1,
"<< /Type /Catalog /Pages 2 0 R /Outlines 10 0 R /Names 11 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] >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Limits [(ext) (ext)] \
/Names [(ext) << /S /GoTo /D (somewhere) >>] >>",
),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 20 0 R /Count 1 >>",
),
(20, "<< /Title (E) /Parent 10 0 R /Dest (ext) >>"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let outlines = cat
.get_ref("Outlines")
.expect("/Outlines should survive (item kept)");
let root = dict_of(&mut pdf, outlines);
assert_eq!(
root.get_ref("First"),
Some(ObjectRef::new(20, 0)),
"string-dest item to a conserved named dest must be kept"
);
}
#[test]
fn legacy_dests_direct_dictionary_on_catalog_is_pruned() {
let bytes = build_min_pdf(
&[
(
1,
"<< /Type /Catalog /Pages 2 0 R \
/Dests << /d1 [3 0 R /Fit] /d2 [4 0 R /Fit] >> >>",
),
(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] >>"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let Some(Object::Dictionary(dests)) = cat.get("Dests") else {
panic!("/Dests direct dict expected on catalog");
};
assert!(
dests.get("d2").is_none(),
"d2 -> removed page must be dropped"
);
let Some(Object::Array(arr)) = dests.get("d1") else {
panic!("d1 should survive as an array dest");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn dict_form_dest_with_indirect_d_is_resolved() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Names 11 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] >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Limits [(d1) (d2)] \
/Names [(d1) << /D 40 0 R >> (d2) << /D 41 0 R >>] >>",
),
(40, "[3 0 R /Fit]"),
(41, "[4 0 R /Fit]"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names").cloned() else {
panic!("/Names array expected");
};
let kept: Vec<&[u8]> = names
.iter()
.filter_map(|o| match o {
Object::String(b) | Object::Name(b) => Some(b.as_slice()),
_ => None,
})
.collect();
assert_eq!(kept, vec![b"d1".as_slice()], "d2 -> removed page dropped");
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr) = dest40.into_array() else {
panic!("obj 40 should remain a dest array");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn names_direct_dictionary_on_catalog_is_pruned() {
let bytes = build_min_pdf(
&[
(
1,
"<< /Type /Catalog /Pages 2 0 R /Names << /Dests 30 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] >>"),
(
30,
"<< /Limits [(d1) (d2)] \
/Names [(d1) [3 0 R /Fit] (d2) [4 0 R /Fit]] >>",
),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
assert!(
matches!(cat.get("Names"), Some(Object::Dictionary(_))),
"/Names should remain a direct dict on the catalog"
);
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names").cloned() else {
panic!("/Names array expected in leaf");
};
let kept: Vec<&[u8]> = names
.iter()
.filter_map(|o| match o {
Object::String(b) | Object::Name(b) => Some(b.as_slice()),
_ => None,
})
.collect();
assert_eq!(kept, vec![b"d1".as_slice()]);
let pos = names
.iter()
.position(|o| matches!(o, Object::String(b) | Object::Name(b) if b == b"d1"))
.unwrap();
let Object::Array(arr) = &names[pos + 1] else {
panic!("d1 dest array expected");
};
assert_eq!(arr.first(), Some(&Object::Reference(new_p1)));
}
#[test]
fn cyclic_indirect_dest_terminates_without_overflow() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Names 11 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(11, "<< /Dests 30 0 R >>"),
(30, "<< /Limits [(c) (c)] /Names [(c) 40 0 R] >>"),
(40, "<< /D 40 0 R >>"),
],
"",
);
let mut pdf = open(bytes);
let result = rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names").cloned() else {
panic!("/Names array expected");
};
assert!(names
.iter()
.any(|o| matches!(o, Object::String(b) | Object::Name(b) if b == b"c")));
}
}