use crate::page_tree_rebuild::RebuildResult;
use crate::ref_chain::resolve_ref_chain;
use crate::{Error, Object, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
const DEFAULT_MAX_OUTLINE_REMAP_DEPTH: usize = 100;
#[derive(Default)]
struct Surviving {
map: BTreeMap<ObjectRef, ObjectRef>,
new_refs: BTreeSet<ObjectRef>,
}
impl Surviving {
fn from_rebuild(result: &RebuildResult) -> Self {
let map = result
.ref_map
.iter()
.filter_map(|(&old, new_refs)| new_refs.first().map(|&new| (old, new)))
.collect();
let new_refs = result.new_kids.iter().copied().collect();
Surviving { map, new_refs }
}
fn remap(&self, old: ObjectRef) -> Option<ObjectRef> {
self.map.get(&old).copied()
}
fn is_surviving_target(&self, page_ref: ObjectRef) -> bool {
self.map.contains_key(&page_ref) || self.new_refs.contains(&page_ref)
}
}
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, DEFAULT_MAX_OUTLINE_REMAP_DEPTH)
}
pub fn remap_outline_and_dests_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
max_depth: usize,
) -> Result<()> {
null_removed_pages(pdf, result);
let surviving = Surviving::from_rebuild(result);
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()), };
let catalog_obj = pdf.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(());
};
let outlines_ref = catalog.get_ref("Outlines");
enum NamesLoc {
Indirect(ObjectRef),
DirectInCatalog,
}
let (names_loc, mut names_dict) = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve_borrowed(r)? {
Object::Dictionary(d) => (Some(NamesLoc::Indirect(r)), d.clone()),
_ => (None, crate::Dictionary::default()),
},
Some(Object::Dictionary(d)) => (Some(NamesLoc::DirectInCatalog), d),
_ => (None, crate::Dictionary::default()),
};
if let Some(names_loc) = names_loc {
match names_dict.get("Dests").cloned() {
Some(Object::Reference(dr)) => {
let mut nt_visited: BTreeSet<ObjectRef> = BTreeSet::new();
remap_name_tree(pdf, dr, &surviving, 0, max_depth, &mut nt_visited)?;
}
Some(Object::Dictionary(node)) => {
let new_node = remap_name_tree_node_dict(pdf, node, &surviving, max_depth)?;
names_dict.insert("Dests", Object::Dictionary(new_node));
match names_loc {
NamesLoc::Indirect(r) => pdf.set_object(r, Object::Dictionary(names_dict)),
NamesLoc::DirectInCatalog => {
let cat_obj = pdf.resolve_borrowed(catalog_ref)?;
if let Some(mut cat) = cat_obj.as_dict().cloned() {
cat.insert("Names", Object::Dictionary(names_dict));
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
}
}
}
_ => {}
}
}
let catalog_obj2 = pdf.resolve_borrowed(catalog_ref)?;
let Some(catalog2) = catalog_obj2.as_dict() else {
return Ok(());
};
match catalog2.get("Dests").cloned() {
Some(Object::Reference(dests_obj_ref)) => {
remap_legacy_dests(pdf, dests_obj_ref, &surviving)?;
}
Some(Object::Dictionary(dests)) => {
let new_dests = remap_dests_dict(pdf, dests, &surviving)?;
let catalog_obj3 = pdf.resolve_borrowed(catalog_ref)?;
if let Some(mut cat) = catalog_obj3.as_dict().cloned() {
cat.insert("Dests", Object::Dictionary(new_dests));
pdf.set_object(catalog_ref, Object::Dictionary(cat));
}
}
_ => {}
}
if let Some(outlines_obj_ref) = outlines_ref {
let first_ref = {
let outline_root_obj = pdf.resolve_borrowed(outlines_obj_ref)?;
outline_root_obj.as_dict().and_then(|d| d.get_ref("First"))
};
if let Some(first_ref) = first_ref {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
remap_outline_tree(pdf, first_ref, 0, max_depth, &surviving, &mut visited)?;
}
}
remap_annot_dests(pdf, result, &surviving)?;
remap_open_action_dest(pdf, catalog_ref, &surviving)?;
Ok(())
}
fn remap_annot_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
surviving: &Surviving,
) -> Result<()> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &result.new_kids {
let annots_val = {
let page_obj = pdf.resolve_borrowed(page_ref)?;
let Some(page) = page_obj.as_dict() else {
continue;
};
page.get("Annots").cloned()
};
match annots_val {
Some(Object::Array(arr)) => {
if let Some(new_arr) = remap_annot_array(pdf, arr, surviving, &mut visited)? {
let page_obj = pdf.resolve_borrowed(page_ref)?;
if let Some(mut page) = page_obj.as_dict().cloned() {
page.insert("Annots", Object::Array(new_arr));
pdf.set_object(page_ref, Object::Dictionary(page));
}
}
}
Some(Object::Reference(r)) => {
let (resolved, terminal) = resolve_ref_chain(pdf, &Object::Reference(r))?;
let array_ref = terminal.unwrap_or(r);
if !visited.insert(array_ref) {
continue;
}
let Object::Array(arr) = resolved else {
continue;
};
if let Some(new_arr) = remap_annot_array(pdf, arr, surviving, &mut visited)? {
pdf.set_object(array_ref, Object::Array(new_arr));
}
}
_ => {}
}
}
Ok(())
}
fn remap_annot_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
arr: Vec<Object>,
surviving: &Surviving,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<Option<Vec<Object>>> {
let mut out: Vec<Object> = Vec::with_capacity(arr.len());
let mut changed = false;
for elem in arr {
match elem {
Object::Reference(r) => {
if visited.insert(r) {
remap_item_dest(pdf, r, surviving)?;
}
out.push(Object::Reference(r));
}
Object::Dictionary(annot) => {
let (new_annot, ch) = remap_inline_annot(pdf, annot, surviving)?;
changed |= ch;
out.push(Object::Dictionary(new_annot));
}
other => out.push(other),
}
}
Ok(if changed { Some(out) } else { None })
}
fn remap_inline_annot<R: Read + Seek>(
pdf: &mut Pdf<R>,
mut annot: crate::Dictionary,
surviving: &Surviving,
) -> Result<(crate::Dictionary, bool)> {
let mut changed = false;
if let Some(dest) = annot.remove("Dest") {
annot.insert("Dest", remap_dest(pdf, dest, surviving)?);
changed = true;
}
if let Some(action) = annot.remove("A") {
annot.insert("A", remap_action_dest(pdf, action, surviving)?);
changed = true;
}
Ok((annot, changed))
}
fn remap_open_action_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
catalog_ref: ObjectRef,
surviving: &Surviving,
) -> Result<()> {
let oa = {
let catalog_obj = pdf.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(());
};
catalog.get("OpenAction").cloned()
};
let Some(oa) = oa else {
return Ok(());
};
let updated = remap_action_dest(pdf, oa.clone(), surviving)?;
if updated != oa {
let catalog_obj = pdf.resolve_borrowed(catalog_ref)?;
if let Some(mut catalog) = catalog_obj.as_dict().cloned() {
catalog.insert("OpenAction", updated);
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
}
}
Ok(())
}
fn remap_action_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
value: Object,
surviving: &Surviving,
) -> Result<Object> {
let (concrete, _) = resolve_ref_chain(pdf, &value)?;
if let Some(dict) = concrete.as_dict() {
if matches!(dict.get("S"), Some(Object::Name(n)) if n != b"GoTo") {
return Ok(value);
}
}
remap_dest(pdf, value, surviving)
}
fn null_removed_pages<R: Read + Seek>(pdf: &mut Pdf<R>, result: &RebuildResult) {
for &removed in &result.removed_pages {
pdf.set_object(removed, Object::Null);
}
}
fn remap_name_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
surviving: &Surviving,
depth: usize,
max_depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
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(()); }
let node_obj = pdf.resolve_borrowed(node_ref)?;
let Some(node) = node_obj.as_dict() else {
return Ok(()); };
if node.get("Names").is_some() {
if let Some(pairs) = node.get("Names").cloned().and_then(Object::into_array) {
let new_pairs = remap_name_pairs(pdf, pairs, surviving)?;
let node_obj2 = pdf.resolve_borrowed(node_ref)?;
if let Some(mut d) = node_obj2.as_dict().cloned() {
d.insert("Names", Object::Array(new_pairs));
pdf.set_object(node_ref, Object::Dictionary(d));
}
}
return Ok(());
}
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();
for child_ref in child_refs {
remap_name_tree(pdf, child_ref, surviving, depth + 1, max_depth, visited)?;
}
}
Ok(())
}
fn remap_name_tree_node_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: crate::Dictionary,
surviving: &Surviving,
max_depth: usize,
) -> Result<crate::Dictionary> {
if let Some(Object::Array(pairs)) = node.get("Names").cloned() {
let new_pairs = remap_name_pairs(pdf, pairs, surviving)?;
let mut d = node;
d.insert("Names", Object::Array(new_pairs));
return Ok(d);
}
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 visited: BTreeSet<ObjectRef> = BTreeSet::new();
for child_ref in child_refs {
remap_name_tree(pdf, child_ref, surviving, 1, max_depth, &mut visited)?;
}
}
Ok(node)
}
fn remap_name_pairs<R: Read + Seek>(
pdf: &mut Pdf<R>,
pairs: Vec<Object>,
surviving: &Surviving,
) -> Result<Vec<Object>> {
let mut result: Vec<Object> = Vec::with_capacity(pairs.len());
let mut i = 0;
while i + 1 < pairs.len() {
let name_obj = pairs[i].clone();
let dest_obj = pairs[i + 1].clone();
i += 2;
result.push(name_obj);
result.push(remap_dest(pdf, dest_obj, surviving)?);
}
Ok(result)
}
fn remap_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest_obj: Object,
surviving: &Surviving,
) -> Result<Object> {
match dest_page_ref_resolved(pdf, &dest_obj)? {
Some(page_ref) if surviving.is_surviving_target(page_ref) => {
Ok(remap_dest_value(pdf, &dest_obj, surviving)?.unwrap_or(dest_obj))
}
_ => Ok(dest_obj),
}
}
fn remap_legacy_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
dests_ref: ObjectRef,
surviving: &Surviving,
) -> Result<()> {
let dests_obj = pdf.resolve_borrowed(dests_ref)?;
let Some(dests) = dests_obj.as_dict().cloned() else {
return Ok(());
};
let new_dests = remap_dests_dict(pdf, dests, surviving)?;
pdf.set_object(dests_ref, Object::Dictionary(new_dests));
Ok(())
}
fn remap_dests_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
dests: crate::Dictionary,
surviving: &Surviving,
) -> 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 Some(val) = dests.get(&key).cloned() else {
continue;
};
let updated = remap_dest(pdf, val, surviving)?;
new_dests.insert(key, updated);
}
Ok(new_dests)
}
fn remap_outline_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
first_ref: ObjectRef,
depth: usize,
max_depth: usize,
surviving: &Surviving,
visited: &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 current = Some(first_ref);
while let Some(item_ref) = current {
if !visited.insert(item_ref) {
break; }
let (next_ref, first_child) = {
let item_obj = pdf.resolve_borrowed(item_ref)?;
let Some(item) = item_obj.as_dict() else {
break; };
(item.get_ref("Next"), item.get_ref("First"))
};
remap_item_dest(pdf, item_ref, surviving)?;
if let Some(child_first) = first_child {
remap_outline_tree(pdf, child_first, depth + 1, max_depth, surviving, visited)?;
}
current = next_ref;
}
Ok(())
}
fn remap_item_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
item_ref: ObjectRef,
surviving: &Surviving,
) -> Result<()> {
let item_obj = pdf.resolve_borrowed(item_ref)?;
let Some(mut d) = item_obj.as_dict().cloned() 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: &Surviving,
) -> 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: &Surviving,
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.remap(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),
}
}
pub(crate) 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_borrowed(*r)?.clone();
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),
}
}
#[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)
}
fn synthetic_result(
pdf: &mut Pdf<Cursor<Vec<u8>>>,
new_kids: Vec<ObjectRef>,
ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>>,
) -> RebuildResult {
let new_set: BTreeSet<ObjectRef> = new_kids.iter().copied().collect();
let removed_pages = crate::pages::page_refs(pdf)
.unwrap()
.into_iter()
.filter(|p| !ref_map.contains_key(p) && !new_set.contains(p))
.collect();
RebuildResult {
new_kids,
ref_map,
removed_pages,
}
}
#[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 removed_pages_keep_items_and_links() {
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 (unchanged)"
);
assert_eq!(
root.get_ref("Last"),
Some(ObjectRef::new(23, 0)),
"outline root /Last should be item 23 (unchanged)"
);
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert_eq!(
get_ref(&item20, "Next"),
Some(ObjectRef::new(21, 0)),
"item 20 /Next stays item 21 (chain not stitched)"
);
assert!(
get_ref(&item20, "Prev").is_none(),
"item 20 keeps no /Prev (it was already first)"
);
let item21 = dict_of(&mut pdf, ObjectRef::new(21, 0));
assert_eq!(get_ref(&item21, "Prev"), Some(ObjectRef::new(20, 0)));
assert_eq!(get_ref(&item21, "Next"), Some(ObjectRef::new(22, 0)));
let item22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(get_ref(&item22, "Prev"), Some(ObjectRef::new(21, 0)));
assert_eq!(get_ref(&item22, "Next"), Some(ObjectRef::new(23, 0)));
assert_eq!(
get_ref(&item22, "First"),
Some(ObjectRef::new(24, 0)),
"item 22 should still have child 24"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page 2 (obj4) nulled"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(6, 0)).unwrap(), Object::Null),
"removed page 4 (obj6) nulled"
);
}
#[test]
fn count_left_unchanged() {
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(5)),
"outline root /Count should be unchanged (5)"
);
let item22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(
item22.get("Count"),
Some(&Object::Integer(1)),
"item 22 /Count should be unchanged (1)"
);
}
#[test]
fn all_pages_removed_keeps_outlines_and_nulls_targets() {
let mut pdf = open(build_outline_pdf());
let result = synthetic_result(&mut pdf, vec![], BTreeMap::new());
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 retain /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(23, 0)));
for n in [20u32, 21, 22, 23, 24] {
let item = dict_of(&mut pdf, ObjectRef::new(n, 0));
assert!(item.get("Title").is_some(), "item {n} should still exist");
}
for n in [3u32, 4, 5, 6] {
assert!(
matches!(pdf.resolve(ObjectRef::new(n, 0)).unwrap(), Object::Null),
"removed page obj{n} should be nulled"
);
}
}
#[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();
for k in ["dest_p1", "dest_p2", "dest_p3", "dest_named_p4"] {
assert!(name_strs.contains(&k.to_string()), "{k} should be kept");
}
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
let new_p3 = result.ref_map[&ObjectRef::new(5, 0)][0];
let dest_first = |key: &[u8]| -> ObjectRef {
let idx = names
.iter()
.step_by(2)
.position(|o| matches!(o, Object::String(b) if b == key))
.expect("named dest present");
names[idx * 2 + 1]
.as_array()
.expect("array dest")
.first()
.unwrap()
.as_ref_id()
.unwrap()
};
assert_eq!(dest_first(b"dest_p1"), new_p1, "dest_p1 remapped");
assert_eq!(dest_first(b"dest_p3"), new_p3, "dest_p3 remapped");
assert_eq!(
dest_first(b"dest_p2"),
ObjectRef::new(4, 0),
"dest_p2 keeps its removed-page ref"
);
assert_eq!(
dest_first(b"dest_named_p4"),
ObjectRef::new(6, 0),
"dest_named_p4 keeps its removed-page ref"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(6, 0)).unwrap(), Object::Null),
"page 4 (obj6) nulled"
);
}
#[test]
fn string_dest_item_kept_when_named_dest_target_nulled() {
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_ref("Last"),
Some(ObjectRef::new(23, 0)),
"item 23 should be kept (string-dest item not dropped)"
);
let item23 = dict_of(&mut pdf, ObjectRef::new(23, 0));
assert_eq!(item23.get_ref("Prev"), Some(ObjectRef::new(22, 0)));
assert!(
matches!(item23.get("Dest"), Some(Object::String(b)) if b == b"dest_named_p4"),
"item 23 keeps its string /Dest"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(6, 0)).unwrap(), Object::Null),
"page 4 (obj6) nulled"
);
}
#[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_pages_removed_keeps_named_dests_nulls_targets() {
let mut pdf = open(build_outline_pdf());
let result = synthetic_result(&mut pdf, vec![], BTreeMap::new());
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let names_ref = cat
.get_ref("Names")
.expect("catalog /Names should be retained");
let names_dict = dict_of(&mut pdf, names_ref);
assert!(
names_dict.get_ref("Dests").is_some(),
"/Dests should be retained in the /Names dict"
);
let leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names") else {
panic!("/Names array expected");
};
let keys: Vec<&[u8]> = names
.iter()
.step_by(2)
.filter_map(|o| match o {
Object::String(b) | Object::Name(b) => Some(b.as_slice()),
_ => None,
})
.collect();
assert_eq!(keys.len(), 4, "all 4 named dests kept");
for n in [3u32, 4, 5, 6] {
assert!(
matches!(pdf.resolve(ObjectRef::new(n, 0)).unwrap(), Object::Null),
"page obj{n} nulled"
);
}
}
#[test]
fn parent_with_removed_target_kept_and_nulled() {
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(23, 0)));
let item22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(item22.get_ref("First"), Some(ObjectRef::new(24, 0)));
assert_eq!(item22.get("Count"), Some(&Object::Integer(1)));
let item24 = dict_of(&mut pdf, ObjectRef::new(24, 0));
assert!(item24.get("Title").is_some(), "child 24 should be kept");
assert!(
matches!(pdf.resolve(ObjectRef::new(5, 0)).unwrap(), Object::Null),
"page 3 (obj5) nulled"
);
}
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_nulled() {
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(), b"d2".as_slice()]);
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr40) = dest40.into_array() else {
panic!("obj 40 should remain a dest array");
};
assert_eq!(arr40.first(), Some(&Object::Reference(new_p1)));
let dest41 = pdf.resolve(ObjectRef::new(41, 0)).unwrap();
let Some(arr41) = dest41.into_array() else {
panic!("obj 41 should remain a dest array (holder not nulled)");
};
assert_eq!(
arr41.first(),
Some(&Object::Reference(ObjectRef::new(4, 0)))
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled, holder obj41 untouched"
);
}
#[test]
fn malformed_named_dest_to_non_page_dict_is_not_nulled() {
let bytes = build_min_pdf(
&[
(
1,
"<< /Type /Catalog /Pages 2 0 R /Names 11 0 R /AcroForm 6 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] >>"),
(6, "<< /Fields [7 0 R] /SigFlags 3 >>"),
(7, "<< /FT /Sig /T (sig) /V 8 0 R >>"),
(8, "<< /Type /Sig /Filter /Adobe.PPKLite >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Names [(evil) [7 0 R /Fit] (removed) [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 sig_field = dict_of(&mut pdf, ObjectRef::new(7, 0));
assert_eq!(sig_field.get("FT"), Some(&Object::Name(b"Sig".to_vec())));
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page obj4 is still nulled"
);
}
#[test]
fn malformed_outline_dest_to_non_page_dict_is_not_nulled() {
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] >>"),
(7, "<< /FT /Sig /T (sig) /V 8 0 R >>"),
(8, "<< /Type /Sig /Filter /Adobe.PPKLite >>"),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 21 0 R /Count 2 >>",
),
(
20,
"<< /Title (evil) /Parent 10 0 R /Next 21 0 R /Dest [7 0 R /Fit] >>",
),
(
21,
"<< /Title (removed) /Parent 10 0 R /Prev 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 sig_field = dict_of(&mut pdf, ObjectRef::new(7, 0));
assert_eq!(sig_field.get("FT"), Some(&Object::Name(b"Sig".to_vec())));
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page obj4 is still nulled"
);
}
#[test]
fn malformed_dest_to_fake_type_page_outside_tree_is_not_nulled() {
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] >>"),
(7, "<< /FT /Sig /Type /Page /T (sig) /V 8 0 R >>"),
(8, "<< /Type /Sig /Filter /Adobe.PPKLite >>"),
(11, "<< /Dests 30 0 R >>"),
(
30,
"<< /Names [(evil) [7 0 R /Fit] (removed) [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 forged = dict_of(&mut pdf, ObjectRef::new(7, 0));
assert_eq!(forged.get("FT"), Some(&Object::Name(b"Sig".to_vec())));
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page obj4 is still nulled"
);
}
#[test]
fn removed_page_behind_reference_holder_is_nulled() {
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] /Secret (S4) >>",
),
(11, "<< /Dests 30 0 R >>"),
(30, "<< /Names [(evil) [40 0 R /Fit]] >>"),
(40, "4 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();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page obj4 reached only through a reference holder must be nulled"
);
}
#[test]
fn removed_page_behind_non_page_wrapper_is_nulled() {
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] /Secret (S4) >>",
),
(11, "<< /Dests 30 0 R >>"),
(30, "<< /Names [(evil) [40 0 R /Fit]] >>"),
(40, "<< /X 4 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();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page obj4 reached only through a non-page wrapper must be nulled"
);
let wrapper = dict_of(&mut pdf, ObjectRef::new(40, 0));
assert_eq!(
wrapper.get("X"),
Some(&Object::Reference(ObjectRef::new(4, 0)))
);
}
#[test]
fn malformed_dest_to_non_dict_object_is_not_nulled() {
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] >>"),
(9, "42"),
(11, "<< /Dests 30 0 R >>"),
(30, "<< /Names [(evil) [9 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();
assert_eq!(
pdf.resolve(ObjectRef::new(9, 0)).unwrap(),
Object::Integer(42),
"non-dict dest target obj9 is left untouched",
);
}
#[test]
fn surviving_parent_with_removed_child_kept_and_nulled() {
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_eq!(item20.get_ref("First"), Some(ObjectRef::new(21, 0)));
assert_eq!(item20.get_ref("Last"), Some(ObjectRef::new(21, 0)));
assert_eq!(
item20.get("Count"),
Some(&Object::Integer(-1)),
"item 20 keeps its /Count -1 unchanged"
);
let item21 = dict_of(&mut pdf, ObjectRef::new(21, 0));
assert!(item21.get("Title").is_some(), "child 21 kept");
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[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_nulled() {
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(21, 0)));
let item20 = dict_of(&mut pdf, ObjectRef::new(20, 0));
assert_eq!(item20.get_ref("Next"), Some(ObjectRef::new(21, 0)));
assert_eq!(item20.get_ref("Dest"), Some(ObjectRef::new(40, 0)));
let item21 = dict_of(&mut pdf, ObjectRef::new(21, 0));
assert_eq!(item21.get_ref("Dest"), Some(ObjectRef::new(41, 0)));
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr40) = dest40.into_array() else {
panic!("obj 40 should stay a dest array");
};
assert_eq!(arr40.first(), Some(&Object::Reference(new_p1)));
let dest41 = pdf.resolve(ObjectRef::new(41, 0)).unwrap();
let Some(arr41) = dest41.into_array() else {
panic!("obj 41 should stay a dest array (holder not nulled)");
};
assert_eq!(
arr41.first(),
Some(&Object::Reference(ObjectRef::new(4, 0)))
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[test]
fn indirect_goto_action_remapped_and_nulled() {
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(21, 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(arr50)) = action50.get("D") else {
panic!("/D array expected on action 50");
};
assert_eq!(arr50.first(), Some(&Object::Reference(new_p1)));
let action51 = dict_of(&mut pdf, ObjectRef::new(51, 0));
let Some(Object::Array(arr51)) = action51.get("D") else {
panic!("/D array expected on action 51 (holder not nulled)");
};
assert_eq!(
arr51.first(),
Some(&Object::Reference(ObjectRef::new(4, 0)))
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[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_remapped() {
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");
};
let Some(Object::Array(arr1)) = dests.get("d1") else {
panic!("d1 should be an array dest");
};
assert_eq!(arr1.first(), Some(&Object::Reference(new_p1)));
let Some(Object::Array(arr2)) = dests.get("d2") else {
panic!("d2 should be kept as an array dest");
};
assert_eq!(arr2.first(), Some(&Object::Reference(ObjectRef::new(4, 0))));
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[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(), b"d2".as_slice()], "both kept");
let dest40 = pdf.resolve(ObjectRef::new(40, 0)).unwrap();
let Some(arr40) = dest40.into_array() else {
panic!("obj 40 should remain a dest array");
};
assert_eq!(arr40.first(), Some(&Object::Reference(new_p1)));
let dest41 = pdf.resolve(ObjectRef::new(41, 0)).unwrap();
let Some(arr41) = dest41.into_array() else {
panic!("obj 41 should remain a dest array (holder not nulled)");
};
assert_eq!(
arr41.first(),
Some(&Object::Reference(ObjectRef::new(4, 0)))
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[test]
fn names_direct_dictionary_on_catalog_is_remapped() {
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(), b"d2".as_slice()], "both kept");
let pos1 = names
.iter()
.position(|o| matches!(o, Object::String(b) | Object::Name(b) if b == b"d1"))
.unwrap();
let Object::Array(arr1) = &names[pos1 + 1] else {
panic!("d1 dest array expected");
};
assert_eq!(arr1.first(), Some(&Object::Reference(new_p1)));
let pos2 = names
.iter()
.position(|o| matches!(o, Object::String(b) | Object::Name(b) if b == b"d2"))
.unwrap();
let Object::Array(arr2) = &names[pos2 + 1] else {
panic!("d2 dest array expected");
};
assert_eq!(arr2.first(), Some(&Object::Reference(ObjectRef::new(4, 0))));
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"page 2 (obj4) nulled"
);
}
#[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")));
}
#[test]
fn remap_outline_tree_cycle_terminates() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(40, "<< /Title (a) /Next 41 0 R >>"),
(41, "<< /Title (b) /Next 40 0 R >>"),
],
"",
);
let mut pdf = open(bytes);
let surviving = Surviving::default();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
remap_outline_tree(
&mut pdf,
ObjectRef::new(40, 0),
0,
100,
&surviving,
&mut visited,
)
.expect("cyclic /Next chain must terminate gracefully");
assert!(visited.contains(&ObjectRef::new(40, 0)));
assert!(visited.contains(&ObjectRef::new(41, 0)));
}
#[test]
fn remap_outline_tree_deep_first_chain_hits_depth_limit() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(40, "<< /Title (a) /First 41 0 R >>"),
(41, "<< /Title (b) /First 42 0 R >>"),
(42, "<< /Title (c) /First 43 0 R >>"),
(43, "<< /Title (d) >>"),
],
"",
);
let mut pdf = open(bytes);
let surviving = Surviving::default();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let err = remap_outline_tree(
&mut pdf,
ObjectRef::new(40, 0),
0,
3,
&surviving,
&mut visited,
)
.expect_err("depth limit must be enforced");
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn remap_name_tree_kids_cycle_terminates() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(50, "<< /Kids [51 0 R] >>"),
(51, "<< /Kids [50 0 R] >>"),
],
"",
);
let mut pdf = open(bytes);
let surviving = Surviving::default();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
remap_name_tree(
&mut pdf,
ObjectRef::new(50, 0),
&surviving,
0,
100,
&mut visited,
)
.expect("cyclic /Kids chain must terminate gracefully");
assert!(visited.contains(&ObjectRef::new(50, 0)));
assert!(visited.contains(&ObjectRef::new(51, 0)));
}
#[test]
fn remap_name_tree_deep_kids_chain_hits_depth_limit() {
let bytes = build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(50, "<< /Kids [51 0 R] >>"),
(51, "<< /Kids [52 0 R] >>"),
(52, "<< /Kids [53 0 R] >>"),
(53, "<< /Names [(z) [3 0 R /Fit]] >>"),
],
"",
);
let mut pdf = open(bytes);
let surviving = Surviving::default();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let err = remap_name_tree(
&mut pdf,
ObjectRef::new(50, 0),
&surviving,
0,
3,
&mut visited,
)
.expect_err("depth limit must be enforced");
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn nullout_named_dests_kept_removed_pages_nulled() {
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 leaf = dict_of(&mut pdf, ObjectRef::new(30, 0));
let Some(Object::Array(names)) = leaf.get("Names") else {
panic!("/Names array");
};
let keys: Vec<&[u8]> = names
.iter()
.step_by(2)
.filter_map(|o| match o {
Object::String(b) | Object::Name(b) => Some(b.as_slice()),
_ => None,
})
.collect();
assert_eq!(
keys,
vec![
b"dest_named_p4".as_slice(),
b"dest_p1",
b"dest_p2",
b"dest_p3"
],
"all named dests kept in original order"
);
assert!(leaf.get("Limits").is_some(), "/Limits not removed");
let new_p1 = result.ref_map[&ObjectRef::new(3, 0)][0];
let new_p3 = result.ref_map[&ObjectRef::new(5, 0)][0];
let dest_of = |names: &[Object], k: &[u8]| -> Object {
let i = names
.iter()
.step_by(2)
.position(|o| matches!(o, Object::String(b) | Object::Name(b) if b == k))
.unwrap();
names[i * 2 + 1].clone()
};
let arr_first = |o: &Object| -> ObjectRef {
o.as_array().unwrap().first().unwrap().as_ref_id().unwrap()
};
assert_eq!(arr_first(&dest_of(names, b"dest_p1")), new_p1);
assert_eq!(arr_first(&dest_of(names, b"dest_p3")), new_p3);
assert_eq!(
arr_first(&dest_of(names, b"dest_p2")),
ObjectRef::new(4, 0),
"removed-page dest keeps its original ref"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page 2 (obj4) nulled"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(6, 0)).unwrap(), Object::Null),
"removed page 4 (obj6) nulled (referenced by dest_named_p4)"
);
}
#[test]
fn nullout_outline_items_all_kept_count_and_links_unchanged() {
let mut pdf = open(build_outline_pdf());
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let root = dict_of(
&mut pdf,
cat.get_ref("Outlines").expect("/Outlines retained"),
);
assert_eq!(
root.get("Count"),
Some(&Object::Integer(5)),
"root /Count unchanged"
);
assert_eq!(root.get_ref("First"), Some(ObjectRef::new(20, 0)));
assert_eq!(root.get_ref("Last"), Some(ObjectRef::new(23, 0)));
let i21 = dict_of(&mut pdf, ObjectRef::new(21, 0));
assert_eq!(i21.get_ref("Prev"), Some(ObjectRef::new(20, 0)));
assert_eq!(i21.get_ref("Next"), Some(ObjectRef::new(22, 0)));
assert!(matches!(
pdf.resolve(ObjectRef::new(4, 0)).unwrap(),
Object::Null
));
let i23 = dict_of(&mut pdf, ObjectRef::new(23, 0));
assert_eq!(i23.get_ref("Prev"), Some(ObjectRef::new(22, 0)));
let i22 = dict_of(&mut pdf, ObjectRef::new(22, 0));
assert_eq!(i22.get("Count"), Some(&Object::Integer(1)));
assert_eq!(i22.get_ref("First"), Some(ObjectRef::new(24, 0)));
}
fn build_annot_pdf(
annot_body: &str,
catalog_extra: &str,
extra_objs: &[(u32, &str)],
) -> Vec<u8> {
let mut objs: Vec<(u32, String)> = vec![
(
1,
format!("<< /Type /Catalog /Pages 2 0 R {catalog_extra} >>"),
),
(
2,
"<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R] /Count 3 >>".to_string(),
),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [50 0 R] >>"
.to_string(),
),
(
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>".to_string(),
),
(
5,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>".to_string(),
),
(50, annot_body.to_string()),
];
for (n, body) in extra_objs {
objs.push((*n, (*body).to_string()));
}
let refs: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
build_min_pdf(&refs, "")
}
fn build_inline_annot_pdf(annot_inline: &str, catalog_extra: &str) -> Vec<u8> {
let catalog = format!("<< /Type /Catalog /Pages 2 0 R {catalog_extra} >>");
let page1 = format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [ {annot_inline} ] >>"
);
build_min_pdf(
&[
(1, catalog.as_str()),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R] /Count 3 >>"),
(3, page1.as_str()),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
],
"",
)
}
fn dest_array_first(pdf: &mut Pdf<Cursor<Vec<u8>>>, r: ObjectRef, key: &str) -> ObjectRef {
let d = dict_of(pdf, r);
d.get(key)
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.unwrap_or_else(|| panic!("{r} /{key} should be an array dest with a page ref"))
}
#[test]
fn annot_dest_to_removed_page_is_nulled() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [4 0 R /Fit] >>",
"",
&[],
));
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) should be nulled"
);
assert_eq!(
dest_array_first(&mut pdf, ObjectRef::new(50, 0), "Dest"),
ObjectRef::new(4, 0),
"annot /Dest keeps the now-null page ref verbatim"
);
}
#[test]
fn annot_goto_action_to_removed_page_is_nulled() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] \
/A << /S /GoTo /D [4 0 R /Fit] >> >>",
"",
&[],
));
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) should be nulled"
);
let annot = dict_of(&mut pdf, ObjectRef::new(50, 0));
let action = annot
.get("A")
.and_then(Object::as_dict)
.expect("annot /A should be an action dict");
let d_first = action
.get("D")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.expect("/A /D should be an array dest");
assert_eq!(
d_first,
ObjectRef::new(4, 0),
"annot /A /D keeps the now-null page ref verbatim"
);
}
#[test]
fn open_action_goto_to_removed_page_is_nulled() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] >>",
"/OpenAction << /S /GoTo /D [4 0 R /Fit] >>",
&[],
));
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) reached only via /OpenAction should be nulled"
);
}
#[test]
fn open_action_dest_array_to_removed_page_is_nulled() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] >>",
"/OpenAction [4 0 R /Fit]",
&[],
));
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) reached only via /OpenAction array should be nulled"
);
}
#[test]
fn annot_dest_to_surviving_page_is_remapped() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [5 0 R /Fit] >>",
"",
&[],
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(3, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert_eq!(
dest_array_first(&mut pdf, ObjectRef::new(50, 0), "Dest"),
ObjectRef::new(99, 0),
"annot /Dest to a surviving page should be remapped to its new ref"
);
}
#[test]
fn inline_annot_dest_to_removed_page_is_nulled() {
let mut pdf = open(build_inline_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [4 0 R /Fit] >>",
"",
));
let result =
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(5, 0)]).unwrap();
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) reached only via an inline annot should be nulled"
);
let page = dict_of(&mut pdf, ObjectRef::new(3, 0));
let inline = page
.get("Annots")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_dict)
.expect("inline annot dict in /Annots");
let d_first = inline
.get("Dest")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.expect("inline annot /Dest array");
assert_eq!(
d_first,
ObjectRef::new(4, 0),
"inline annot /Dest keeps the now-null page ref verbatim"
);
}
#[test]
fn inline_annot_dest_to_surviving_page_is_remapped() {
let mut pdf = open(build_inline_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [5 0 R /Fit] >>",
"",
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(3, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
let page = dict_of(&mut pdf, ObjectRef::new(3, 0));
let inline = page
.get("Annots")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_dict)
.expect("inline annot dict in /Annots");
let d_first = inline
.get("Dest")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.expect("inline annot /Dest array");
assert_eq!(
d_first,
ObjectRef::new(99, 0),
"inline annot /Dest to a surviving page should be remapped to its new ref"
);
}
#[test]
fn shared_indirect_annot_array_processed_once() {
let mut pdf = open(build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R] /Count 3 >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots 60 0 R >>",
),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(
60,
"[ << /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [5 0 R /Fit] >> ]",
),
],
"",
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(3, 0)]);
let result = synthetic_result(
&mut pdf,
vec![ObjectRef::new(3, 0), ObjectRef::new(3, 0)],
ref_map,
);
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
pdf.resolve(ObjectRef::new(3, 0))
.unwrap()
.as_dict()
.is_some(),
"surviving page obj3 must stay a dictionary (shared indirect /Annots array deduped)"
);
}
#[test]
fn open_action_goto_to_surviving_page_is_remapped() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] >>",
"/OpenAction << /S /GoTo /D [5 0 R /Fit] >>",
&[],
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(3, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
let cat = dict_of(&mut pdf, ObjectRef::new(1, 0));
let action = cat
.get("OpenAction")
.and_then(Object::as_dict)
.expect("catalog /OpenAction should be an action dict");
let d_first = action
.get("D")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.expect("/OpenAction /D should be an array dest");
assert_eq!(
d_first,
ObjectRef::new(99, 0),
"/OpenAction /D to a surviving page should be remapped to its new ref"
);
}
#[test]
fn inline_annot_non_goto_action_d_is_not_treated_as_dest() {
let mut pdf = open(build_inline_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] \
/A << /S /Launch /D [5 0 R /Fit] >> >>",
"",
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(3, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
let page = dict_of(&mut pdf, ObjectRef::new(3, 0));
let d_first = page
.get("Annots")
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_dict)
.and_then(|annot| annot.get("A"))
.and_then(Object::as_dict)
.and_then(|a| a.get("D"))
.and_then(Object::as_array)
.and_then(|arr| arr.first())
.and_then(Object::as_ref_id)
.expect("inline annot /A /D array first ref");
assert_eq!(
d_first,
ObjectRef::new(5, 0),
"a non-GoTo inline-annot /A /D must be left verbatim (not remapped)"
);
}
#[test]
fn open_action_non_goto_d_is_not_treated_as_dest() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] >>",
"/OpenAction << /S /Launch /D [5 0 R /Fit] >>",
&[],
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(3, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
let catalog = dict_of(&mut pdf, ObjectRef::new(1, 0));
let d_first = catalog
.get("OpenAction")
.and_then(Object::as_dict)
.and_then(|oa| oa.get("D"))
.and_then(Object::as_array)
.and_then(|a| a.first())
.and_then(Object::as_ref_id)
.expect("/OpenAction /D array first ref");
assert_eq!(
d_first,
ObjectRef::new(5, 0),
"a non-GoTo /OpenAction /D must be left verbatim (not remapped)"
);
}
#[test]
fn shared_annot_on_duplicated_page_processed_once() {
let mut pdf = open(build_annot_pdf(
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /Dest [5 0 R /Fit] >>",
"",
&[],
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(5, 0), vec![ObjectRef::new(3, 0)]);
let result = synthetic_result(
&mut pdf,
vec![ObjectRef::new(3, 0), ObjectRef::new(3, 0)],
ref_map,
);
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
pdf.resolve(ObjectRef::new(3, 0))
.unwrap()
.as_dict()
.is_some(),
"surviving page obj3 must stay a dictionary; a shared annot reached \
from two duplicated pages must be processed once, never nulling it"
);
}
#[test]
fn shared_goto_action_across_outline_and_annot_does_not_null_remapped_page() {
let mut pdf = open(build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Outlines 10 0 R >>"),
(2, "<< /Type /Pages /Kids [99 0 R] /Count 1 >>"),
(
99,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [60 0 R] >>",
),
(
10,
"<< /Type /Outlines /First 20 0 R /Last 20 0 R /Count 1 >>",
),
(20, "<< /Title (Shared) /Parent 10 0 R /A 50 0 R >>"),
(
60,
"<< /Type /Annot /Subtype /Link /Rect [0 0 10 10] /A 50 0 R >>",
),
(50, "<< /S /GoTo /D [3 0 R /Fit] >>"),
],
"",
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(3, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(99, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
pdf.resolve(ObjectRef::new(99, 0))
.unwrap()
.as_dict()
.is_some(),
"surviving remapped page obj99 must stay a dictionary; a GoTo action \
shared by an outline item and an annotation must not let the Step-4 \
null-pass null an already-remapped (new-ref) destination"
);
}
#[test]
fn genuinely_removed_page_is_still_nulled_under_surviving_target_guard() {
let mut pdf = open(build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /Outlines 10 0 R >>"),
(2, "<< /Type /Pages /Kids [99 0 R 7 0 R] /Count 2 >>"),
(
99,
"<< /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 (Removed) /Parent 10 0 R /Dest [7 0 R /Fit] >>",
),
(7, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
],
"",
));
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
ref_map.insert(ObjectRef::new(99, 0), vec![ObjectRef::new(99, 0)]);
let result = synthetic_result(&mut pdf, vec![ObjectRef::new(99, 0)], ref_map);
remap_outline_and_dests(&mut pdf, &result).unwrap();
assert!(
matches!(pdf.resolve(ObjectRef::new(7, 0)).unwrap(), Object::Null),
"a removed page (neither a remap key nor a rebuilt output ref) must \
still be nulled by the null-pass"
);
assert!(
pdf.resolve(ObjectRef::new(99, 0))
.unwrap()
.as_dict()
.is_some(),
"the surviving page obj99 must be untouched"
);
}
#[test]
fn direct_dict_dests_node_under_names_remapped_and_nulled() {
let mut pdf = open(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 << /Names [(d1) [3 0 R /Fit] (d2) [4 0 R /Fit]] >> >>",
),
],
"",
));
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 names_dict = dict_of(&mut pdf, ObjectRef::new(11, 0));
let dests = names_dict
.get("Dests")
.and_then(Object::as_dict)
.expect("/Dests direct dict retained");
let pairs = dests
.get("Names")
.and_then(Object::as_array)
.expect("/Dests leaf /Names array expected");
assert_eq!(
pairs[1]
.as_array()
.and_then(|a| a.first())
.and_then(Object::as_ref_id),
Some(new_p1),
"d1 dest should be remapped to the new page1 ref"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) should be nulled"
);
}
#[test]
fn legacy_indirect_catalog_dests_remapped_and_nulled() {
let mut pdf = open(build_min_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /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, "<< /d1 [3 0 R /Fit] /d2 [4 0 R /Fit] >>"),
],
"",
));
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();
assert_eq!(
dest_array_first(&mut pdf, ObjectRef::new(30, 0), "d1"),
new_p1,
"legacy /Dests d1 should be remapped to the new page1 ref"
);
assert!(
matches!(pdf.resolve(ObjectRef::new(4, 0)).unwrap(), Object::Null),
"removed page2 (obj4) should be nulled"
);
}
}