use crate::acroform_document_helper::{collect_refs_in_object, remap_refs_in_object};
use crate::acroform_field_prune::DEFAULT_MAX_ACROFORM_DEPTH;
use crate::name_number_tree::{read_name_tree, DEFAULT_MAX_TREE_DEPTH};
use crate::object_copy::copy_objects;
use crate::outline::DEFAULT_MAX_OUTLINE_DEPTH;
use crate::outline_dest_remap::dest_page_ref_resolved;
use crate::page_closure::extend_page_object_closure;
use crate::page_extract::{
append_selection_kids, materialize_leaf, minimal_target_bytes, resolve_dict,
sd_target_page_ref, target_pages_root, InheritedAttrs,
};
use crate::pages::{page_refs, DEFAULT_MAX_PAGE_TREE_DEPTH};
use crate::ref_chain::resolve_ref_chain;
use crate::subset_prune::sweep_unreachable_objects;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
pub struct MergeInput<'a, R: Read + Seek> {
pub source: &'a mut Pdf<R>,
pub pages: Vec<usize>,
}
const MAX_ACTION_CHAIN_DEPTH: usize = 64;
fn collect_removed_dest_targets<R: Read + Seek>(
source: &mut Pdf<R>,
page_ref: ObjectRef,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let (annots_val, page_aa): (Option<Object>, Option<Object>) = {
let page_obj = source.resolve_borrowed(page_ref)?;
let Some(page_dict) = page_obj.as_dict() else {
return Ok(()); };
(
page_dict.get("Annots").cloned(),
page_dict.get("AA").cloned(),
)
};
let annot_elems: Vec<Object> = match annots_val {
Some(Object::Array(arr)) => arr,
Some(r @ Object::Reference(_)) => match resolve_ref_chain(source, &r)?.0 {
Object::Array(arr) => arr,
_ => Vec::new(),
},
_ => Vec::new(),
};
for elem in annot_elems {
match elem {
Object::Reference(annot_ref) => {
let (concrete, _) = resolve_ref_chain(source, &Object::Reference(annot_ref))?;
let Some(annot) = concrete.into_dict() else {
continue;
};
scan_annotation(source, &annot, selected, removed)?;
}
Object::Dictionary(annot) => {
scan_annotation(source, &annot, selected, removed)?;
}
_ => {} }
}
if let Some(aa_val) = page_aa {
collect_aa_dest_targets(source, &aa_val, selected, removed)?;
}
Ok(())
}
fn scan_annotation<R: Read + Seek>(
source: &mut Pdf<R>,
annot: &Dictionary,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if let Some(dest) = annot.get("Dest") {
collect_dest_target(source, dest, selected, removed)?;
}
if let Some(a_val) = annot.get("A") {
let mut visited = BTreeSet::new();
collect_action_chain_targets(
source,
a_val,
selected,
removed,
&mut visited,
MAX_ACTION_CHAIN_DEPTH,
)?; }
if let Some(aa_val) = annot.get("AA") {
collect_aa_dest_targets(source, aa_val, selected, removed)?;
}
Ok(())
}
fn collect_aa_dest_targets<R: Read + Seek>(
source: &mut Pdf<R>,
aa_value: &Object,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let (concrete, _) = resolve_ref_chain(source, aa_value)?;
if let Some(aa) = concrete.into_dict() {
for (_key, sub) in aa.iter() {
let mut visited = BTreeSet::new();
collect_action_chain_targets(
source,
sub,
selected,
removed,
&mut visited,
MAX_ACTION_CHAIN_DEPTH,
)?; }
}
Ok(())
}
fn collect_dest_target<R: Read + Seek>(
source: &mut Pdf<R>,
dest: &Object,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if let Some(target) = dest_page_ref_resolved(source, dest)? {
let target = resolve_ref_chain(source, &Object::Reference(target))?
.1
.unwrap_or(target);
if !selected.contains(&target) {
removed.insert(target);
}
}
Ok(())
}
fn collect_action_chain_targets<R: Read + Seek>(
source: &mut Pdf<R>,
action_value: &Object,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<()> {
if depth == 0 {
return Ok(()); }
let (concrete, terminal_ref) = resolve_ref_chain(source, action_value)?;
if let Some(r) = terminal_ref {
if !visited.insert(r) {
return Ok(());
}
}
if let Object::Array(elems) = concrete {
for elem in &elems {
collect_action_chain_targets(source, elem, selected, removed, visited, depth - 1)?;
}
return Ok(());
}
let Some(action) = concrete.into_dict() else {
return Ok(());
};
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") {
collect_dest_target(source, d_val, selected, removed)?;
}
if let Some(sd_val) = action.get("SD") {
collect_sd_target(source, sd_val, selected, removed)?;
}
}
if let Some(next_val) = action.get("Next") {
match next_val {
Object::Array(elems) => {
for elem in elems {
collect_action_chain_targets(
source,
elem,
selected,
removed,
visited,
depth - 1,
)?; }
}
single => {
collect_action_chain_targets(
source,
single,
selected,
removed,
visited,
depth - 1,
)?; }
}
}
Ok(())
}
fn collect_sd_target<R: Read + Seek>(
source: &mut Pdf<R>,
sd: &Object,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if let Some(target) = sd_target_page_ref(source, sd)? {
if !selected.contains(&target) {
removed.insert(target);
}
}
Ok(())
}
#[derive(Default)]
struct PrimaryDocLevel {
outlines: Option<ObjectRef>,
outlines_inline: Option<Dictionary>,
names_dests: Option<ObjectRef>,
names_dests_inline: Option<Dictionary>,
legacy_dests_ref: Option<ObjectRef>,
legacy_dests_inline: Option<Dictionary>,
open_action_ref: Option<ObjectRef>,
open_action_inline: Option<Object>,
}
fn discover_primary_doc_level<R: Read + Seek>(source: &mut Pdf<R>) -> Result<PrimaryDocLevel> {
let Some(catalog_ref) = source.root_ref() else {
return Ok(PrimaryDocLevel::default()); };
let catalog_obj = source.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(PrimaryDocLevel::default()); };
let mut doc = PrimaryDocLevel::default();
match catalog.get("Outlines") {
Some(Object::Reference(r)) => doc.outlines = Some(*r),
Some(Object::Dictionary(d)) => doc.outlines_inline = Some(d.clone()),
_ => {}
}
let names_val = catalog.get("Names").cloned();
let names_dict = match names_val {
Some(value @ Object::Reference(_)) => resolve_ref_chain(source, &value)?.0.into_dict(),
Some(Object::Dictionary(d)) => Some(d),
_ => None,
};
if let Some(names) = names_dict {
if let Some(Object::Reference(r)) = names.get("Dests") {
doc.names_dests = Some(*r);
} else if let Some(Object::Dictionary(d)) = names.get("Dests") {
doc.names_dests_inline = Some(d.clone());
}
}
let catalog_obj = source.resolve_borrowed(catalog_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(doc); };
match catalog.get("Dests") {
Some(Object::Reference(r)) => doc.legacy_dests_ref = Some(*r),
Some(Object::Dictionary(d)) => doc.legacy_dests_inline = Some(d.clone()),
_ => {}
}
match catalog.get("OpenAction") {
Some(Object::Reference(r)) => doc.open_action_ref = Some(*r),
Some(other) => doc.open_action_inline = Some(other.clone()),
None => {}
}
Ok(doc)
}
fn fold_doc_level_closure<R: Read + Seek>(
source: &mut Pdf<R>,
doc: &PrimaryDocLevel,
closure: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
for root in [
doc.outlines,
doc.names_dests,
doc.legacy_dests_ref,
doc.open_action_ref,
]
.into_iter()
.flatten()
{
extend_page_object_closure(source, root, closure)?;
}
if let Some(inline) = &doc.open_action_inline {
fold_inline_action_operands(source, inline, closure, MAX_ACTION_CHAIN_DEPTH)?;
}
if let Some(inline) = &doc.names_dests_inline {
if let Some(Object::Array(kids)) = inline.get("Kids") {
for kid in kids.iter().filter_map(Object::as_ref_id) {
extend_page_object_closure(source, kid, closure)?;
}
}
}
if let Some(inline) = &doc.outlines_inline {
for child in ["First", "Last"]
.into_iter()
.filter_map(|key| inline.get_ref(key))
{
extend_page_object_closure(source, child, closure)?;
}
}
Ok(())
}
const ACTION_DEST_KEYS: [&[u8]; 5] = [b"D", b"SD", b"Dest", b"Next", b"Parent"];
fn fold_inline_action_operands<R: Read + Seek>(
source: &mut Pdf<R>,
action: &Object,
closure: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<()> {
if depth == 0 {
return Ok(()); }
let (concrete, _) = resolve_ref_chain(source, action)?;
let Some(dict) = concrete.into_dict() else {
return Ok(()); };
let dest_bearing = !matches!(dict.get("S"), Some(Object::Name(n)) if n != b"GoTo");
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
for (key, value) in dict.iter() {
let skip_key = if key == b"D" {
dest_bearing
} else {
ACTION_DEST_KEYS.contains(&key)
};
if skip_key {
continue;
}
collect_refs_in_object(source, value, closure, &mut seen, 0, 0, true)?;
}
if let Some(next_val) = dict.get("Next") {
let (concrete, _) = resolve_ref_chain(source, next_val)?;
match concrete {
Object::Array(elems) => {
for elem in &elems {
fold_inline_action_operands(source, elem, closure, depth - 1)?;
}
}
single => fold_inline_action_operands(source, &single, closure, depth - 1)?,
}
}
Ok(())
}
fn collect_doc_level_removed_targets<R: Read + Seek>(
source: &mut Pdf<R>,
doc: &PrimaryDocLevel,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
collect_outline_doc_dests(source, doc, selected, removed)?;
let names_root = match (doc.names_dests, &doc.names_dests_inline) {
(Some(r), _) => Some(Object::Reference(r)),
(None, Some(d)) => Some(Object::Dictionary(d.clone())),
(None, None) => None,
};
if let Some(root) = names_root {
collect_name_tree_removed_targets(source, root, selected, removed)?;
}
let legacy = match (doc.legacy_dests_ref, &doc.legacy_dests_inline) {
(Some(r), _) => resolve_ref_chain(source, &Object::Reference(r))?
.0
.into_dict(),
(None, Some(d)) => Some(d.clone()),
(None, None) => None,
};
if let Some(dests) = legacy {
for (_key, dest) in dests.iter() {
collect_dest_target(source, dest, selected, removed)?;
}
}
let open_action_owned = doc.open_action_ref.map(Object::Reference);
if let Some(oa) = open_action_owned
.as_ref()
.or(doc.open_action_inline.as_ref())
{
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
collect_action_chain_targets(
source,
oa,
selected,
removed,
&mut visited,
MAX_ACTION_CHAIN_DEPTH,
)?; let (concrete, _) = resolve_ref_chain(source, oa)?;
match concrete {
Object::Array(_) => collect_dest_target(source, oa, selected, removed)?,
Object::Dictionary(ref d) if !matches!(d.get("S"), Some(Object::Name(n)) if n != b"GoTo") =>
{
let d_val = d.get("D").unwrap_or(&Object::Null);
collect_dest_target(source, d_val, selected, removed)?; }
_ => {}
}
}
Ok(())
}
fn collect_outline_doc_dests<R: Read + Seek>(
source: &mut Pdf<R>,
doc: &PrimaryDocLevel,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let first = match (doc.outlines, &doc.outlines_inline) {
(Some(outlines_ref), _) => {
let (root, _) = resolve_ref_chain(source, &Object::Reference(outlines_ref))?;
root.as_dict().and_then(|d| d.get_ref("First"))
}
(None, Some(inline)) => inline.get_ref("First"),
(None, None) => return Ok(()),
};
let Some(first) = first else {
return Ok(());
};
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
collect_outline_removed_targets(
source,
first,
selected,
removed,
&mut visited,
DEFAULT_MAX_OUTLINE_DEPTH,
)
}
fn collect_outline_removed_targets<R: Read + Seek>(
source: &mut Pdf<R>,
first: ObjectRef,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<()> {
if depth == 0 {
return Ok(()); }
let mut current = Some(first);
while let Some(item_ref) = current {
let (item_obj, terminal) = resolve_ref_chain(source, &Object::Reference(item_ref))?;
if !visited.insert(terminal.unwrap_or(item_ref)) {
break; }
let (dest_val, action_val, next_ref, first_child) = {
let Some(item) = item_obj.as_dict() else {
break; };
(
item.get("Dest").cloned(),
item.get("A").cloned(),
item.get_ref("Next"),
item.get_ref("First"),
)
};
if let Some(dest) = dest_val {
collect_dest_target(source, &dest, selected, removed)?;
}
if let Some(action) = action_val {
let mut a_visited: BTreeSet<ObjectRef> = BTreeSet::new();
collect_action_chain_targets(
source,
&action,
selected,
removed,
&mut a_visited,
MAX_ACTION_CHAIN_DEPTH,
)?; }
if let Some(child) = first_child {
collect_outline_removed_targets(source, child, selected, removed, visited, depth - 1)?;
}
current = next_ref;
}
Ok(())
}
fn collect_name_tree_removed_targets<R: Read + Seek>(
source: &mut Pdf<R>,
root: Object,
selected: &BTreeSet<ObjectRef>,
removed: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let (root, _) = resolve_ref_chain(source, &root)?;
let entries = read_name_tree(
source,
root,
|_pdf, value| Ok(Some(value)),
DEFAULT_MAX_TREE_DEPTH,
)?; for (_name, dest) in entries {
collect_dest_target(source, &dest, selected, removed)?;
}
Ok(())
}
fn wire_doc_level<RSrc: Read + Seek, RTgt: Read + Seek>(
source: &mut Pdf<RSrc>,
target: &mut Pdf<RTgt>,
doc: &PrimaryDocLevel,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let Some(catalog_ref) = target.root_ref() else {
return Ok(()); };
let catalog_obj = target.resolve_borrowed(catalog_ref)?;
let Some(mut catalog) = catalog_obj.as_dict().cloned() else {
return Ok(()); };
if let Some(outlines) = doc.outlines {
if let Some(&new_ref) = map.get(&outlines) {
catalog.insert("Outlines", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.outlines_inline {
catalog.insert(
"Outlines",
remap_refs_in_object(Object::Dictionary(inline.clone()), map),
);
}
if let Some(dests) = doc.names_dests {
if let Some(&new_ref) = map.get(&dests) {
let mut names = Dictionary::new();
names.insert("Dests", Object::Reference(new_ref));
catalog.insert("Names", Object::Dictionary(names));
}
} else if let Some(inline) = &doc.names_dests_inline {
let rebuilt = remap_inline_name_tree_root(source, inline, map)?;
let mut names = Dictionary::new();
names.insert("Dests", Object::Dictionary(rebuilt));
catalog.insert("Names", Object::Dictionary(names));
}
if let Some(legacy) = doc.legacy_dests_ref {
if let Some(&new_ref) = map.get(&legacy) {
catalog.insert("Dests", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.legacy_dests_inline {
let mut rebuilt = Dictionary::new();
for (key, dest) in inline.iter() {
rebuilt.insert(key, remap_inline_dest(source, dest, map)?);
}
catalog.insert("Dests", Object::Dictionary(rebuilt));
}
if let Some(oa_ref) = doc.open_action_ref {
if let Some(&new_ref) = map.get(&oa_ref) {
catalog.insert("OpenAction", Object::Reference(new_ref));
}
} else if let Some(inline) = &doc.open_action_inline {
catalog.insert("OpenAction", remap_inline_action(source, inline, map)?);
}
target.set_object(catalog_ref, Object::Dictionary(catalog));
Ok(())
}
const MAX_INLINE_DEST_DEPTH: usize = 64;
fn remap_inline_dest<R: Read + Seek>(
source: &mut Pdf<R>,
dest: &Object,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<Object> {
remap_inline_dest_depth(source, dest, map, MAX_INLINE_DEST_DEPTH)
}
fn remap_inline_dest_depth<R: Read + Seek>(
source: &mut Pdf<R>,
dest: &Object,
map: &BTreeMap<ObjectRef, ObjectRef>,
depth: usize,
) -> Result<Object> {
if depth == 0 {
return Ok(dest.clone()); }
let (concrete, _) = resolve_ref_chain(source, dest)?;
match concrete {
Object::Array(mut arr) => {
let first_ref = match arr.first() {
Some(Object::Reference(r)) => Some(*r),
_ => None,
};
if let Some(r) = first_ref {
if let Some(&new_ref) = map.get(&r) {
arr[0] = Object::Reference(new_ref);
} else if let Some(terminal) = resolve_ref_chain(source, &Object::Reference(r))?.1 {
if let Some(&new_ref) = map.get(&terminal) {
arr[0] = Object::Reference(new_ref);
}
}
}
Ok(Object::Array(arr))
}
Object::Dictionary(mut d) => {
if let Some(d_val) = d.remove("D") {
let remapped = remap_inline_dest_depth(source, &d_val, map, depth - 1)?;
d.insert("D", remapped);
}
Ok(Object::Dictionary(d))
}
other => Ok(other),
}
}
fn remap_inline_name_tree_root<R: Read + Seek>(
source: &mut Pdf<R>,
leaf: &Dictionary,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<Dictionary> {
let mut out = leaf.clone();
if let Some(Object::Array(names)) = leaf.get("Names") {
let mut rebuilt = names.clone();
let mut i = 1;
while i < rebuilt.len() {
rebuilt[i] = remap_inline_dest(source, &rebuilt[i], map)?;
i += 2;
}
out.insert("Names", Object::Array(rebuilt));
}
if let Some(Object::Array(kids)) = leaf.get("Kids") {
let mut rebuilt = kids.clone();
for kid in &mut rebuilt {
if let Object::Reference(r) = kid {
*kid = Object::Reference(map.get(r).copied().unwrap_or(*r));
}
}
out.insert("Kids", Object::Array(rebuilt));
}
Ok(out)
}
fn remap_inline_action<R: Read + Seek>(
source: &mut Pdf<R>,
action: &Object,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<Object> {
remap_inline_action_depth(source, action, map, MAX_ACTION_CHAIN_DEPTH)
}
fn remap_inline_action_depth<R: Read + Seek>(
source: &mut Pdf<R>,
action: &Object,
map: &BTreeMap<ObjectRef, ObjectRef>,
depth: usize,
) -> Result<Object> {
if depth == 0 {
return Ok(action.clone()); }
let (concrete, _) = resolve_ref_chain(source, action)?;
match concrete {
Object::Array(arr) => remap_inline_dest(source, &Object::Array(arr), map),
Object::Dictionary(mut out) => {
let dest = out.remove("D");
let next = out.remove("Next");
let dest_bearing = !matches!(out.get("S"), Some(Object::Name(n)) if n != b"GoTo");
if dest_bearing {
out.remove("SD");
}
out = match remap_refs_in_object(Object::Dictionary(out), map) {
Object::Dictionary(d) => d,
other => return Ok(other), };
if let Some(dest) = dest {
let remapped = if dest_bearing {
remap_inline_dest(source, &dest, map)?
} else {
remap_refs_in_object(dest, map)
};
out.insert("D", remapped);
}
if let Some(next) = next {
let remapped_next = remap_next_continuation(source, &next, map, depth)?;
out.insert("Next", remapped_next);
}
Ok(Object::Dictionary(out))
}
other => Ok(other),
}
}
fn remap_next_continuation<R: Read + Seek>(
source: &mut Pdf<R>,
next: &Object,
map: &BTreeMap<ObjectRef, ObjectRef>,
depth: usize,
) -> Result<Object> {
let (concrete, _) = resolve_ref_chain(source, next)?;
match concrete {
Object::Array(elems) => {
let mut rebuilt = Vec::with_capacity(elems.len());
for elem in &elems {
rebuilt.push(remap_inline_action_depth(source, elem, map, depth - 1)?);
}
Ok(Object::Array(rebuilt))
}
single => remap_inline_action_depth(source, &single, map, depth - 1),
}
}
pub(crate) fn unique_field_name(base: &[u8], used: &BTreeSet<Vec<u8>>) -> Vec<u8> {
if !used.contains(base) {
return base.to_vec();
}
for n in 1u32.. {
let mut candidate = base.to_vec();
candidate.extend_from_slice(format!("+{n}").as_bytes());
if !used.contains(&candidate) {
return candidate;
}
}
unreachable!("u32 candidate space exhausted") }
struct KeptField {
target_ref: ObjectRef,
partial_name: Option<Vec<u8>>,
is_primary: bool,
}
#[derive(Default)]
struct PrimaryAcroForm {
dr: Option<Object>,
da: Option<Object>,
closure_seed: BTreeSet<ObjectRef>,
}
fn discover_primary_acroform<R: Read + Seek>(source: &mut Pdf<R>) -> Result<PrimaryAcroForm> {
let entries = source.acroform().acroform_inherited_entries()?;
let mut out = PrimaryAcroForm::default();
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
for (key, value) in entries {
collect_refs_in_object(
source,
&value,
&mut out.closure_seed,
&mut seen,
0,
0,
false,
)?; match key.as_slice() {
b"DR" => out.dr = Some(value),
b"DA" => out.da = Some(value),
_ => {} }
}
Ok(out)
}
fn source_top_level_field_names<R: Read + Seek>(
source: &mut Pdf<R>,
) -> Result<Vec<(ObjectRef, Option<Vec<u8>>)>> {
let top_fields = source.acroform().top_level_fields()?;
let mut out = Vec::with_capacity(top_fields.len());
for field_ref in top_fields {
let terminal = resolve_ref_chain(source, &Object::Reference(field_ref))?
.1
.unwrap_or(field_ref);
let name = resolve_field_partial_name(source, terminal)?;
out.push((terminal, name));
}
Ok(out)
}
fn resolve_field_partial_name<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<u8>>> {
let t_value = {
let Some(field) = source.resolve_borrowed(field_ref)?.as_dict() else {
return Ok(None); };
field.get("T").cloned()
};
let resolved = match t_value {
Some(value @ Object::Reference(_)) => resolve_ref_chain(source, &value)?.0,
Some(other) => other,
None => return Ok(None),
};
Ok(resolved.as_string().map(<[u8]>::to_vec))
}
fn build_merged_acroform<R: Read + Seek>(
target: &mut Pdf<R>,
primary: &PrimaryAcroForm,
kept: &[KeptField],
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
if kept.is_empty() && primary.dr.is_none() && primary.da.is_none() {
return Ok(());
}
let acroform_ref = target.acroform().ensure_acroform_ref()?;
let mut acroform = match target.resolve_borrowed(acroform_ref)?.as_dict().cloned() {
Some(dict) => dict,
None => return Ok(()), };
if let Some(dr) = &primary.dr {
acroform.insert("DR", remap_refs_in_object(dr.clone(), map));
}
if let Some(da) = &primary.da {
acroform.insert("DA", remap_refs_in_object(da.clone(), map));
}
let mut used: BTreeSet<Vec<u8>> = BTreeSet::new();
for field in kept {
if field.is_primary {
if let Some(name) = &field.partial_name {
used.insert(name.clone());
}
}
}
let mut fields: Vec<Object> = Vec::with_capacity(kept.len());
for field in kept {
if !field.is_primary {
if let Some(name) = &field.partial_name {
let unique = unique_field_name(name, &used);
used.insert(unique.clone());
rename_field(target, field.target_ref, unique)?;
}
}
fields.push(Object::Reference(field.target_ref));
}
acroform.insert("Fields", Object::Array(fields));
target.set_object(acroform_ref, Object::Dictionary(acroform));
Ok(())
}
fn rename_field<R: Read + Seek>(
target: &mut Pdf<R>,
field_ref: ObjectRef,
name: Vec<u8>,
) -> Result<()> {
let Some(mut field) = target.resolve_borrowed(field_ref)?.as_dict().cloned() else {
return Ok(()); };
field.insert("T", Object::String(name));
target.set_object(field_ref, Object::Dictionary(field));
Ok(())
}
fn field_kid_refs<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<ObjectRef>>> {
let kids_value = {
let Some(field) = source.resolve_borrowed(field_ref)?.as_dict() else {
return Ok(None); };
match field.get("Kids") {
Some(value) => value.clone(),
None => return Ok(None),
}
};
let (resolved, _) = resolve_ref_chain(source, &kids_value)?;
let Object::Array(items) = resolved else {
return Ok(Some(Vec::new())); };
let mut refs = Vec::with_capacity(items.len());
for item in items {
if let Object::Reference(r) = item {
let (_, terminal) = resolve_ref_chain(source, &Object::Reference(r))?;
refs.push(terminal.unwrap_or(r));
} }
Ok(Some(refs))
}
fn collect_retained_widget_refs<R: Read + Seek>(
source: &mut Pdf<R>,
selected_pages: &BTreeSet<ObjectRef>,
retained: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
for &page_ref in selected_pages {
let annots_val = {
let page_obj = source.resolve_borrowed(page_ref)?;
let Some(page_dict) = page_obj.as_dict() else {
continue; };
page_dict.get("Annots").cloned()
};
let Some(annots_val) = annots_val else {
continue;
};
let (concrete, _) = resolve_ref_chain(source, &annots_val)?;
let Object::Array(elems) = concrete else {
continue; };
for elem in elems {
if let Object::Reference(r) = elem {
let (_, terminal) = resolve_ref_chain(source, &Object::Reference(r))?;
retained.insert(terminal.unwrap_or(r));
}
}
}
Ok(())
}
fn widget_page_ref<R: Read + Seek>(
source: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let p_value = {
let Some(widget) = source.resolve_borrowed(widget_ref)?.as_dict() else {
return Ok(None); };
match widget.get("P") {
Some(value) => value.clone(),
None => return Ok(None),
}
};
let (_, last_ref) = resolve_ref_chain(source, &p_value)?;
Ok(last_ref)
}
#[allow(clippy::too_many_arguments)]
fn trim_field_kids<R: Read + Seek>(
source: &mut Pdf<R>,
target: &mut Pdf<Cursor<Vec<u8>>>,
field_ref: ObjectRef,
surviving_pages: &BTreeSet<ObjectRef>,
retained_widgets: &BTreeSet<ObjectRef>,
map: &BTreeMap<ObjectRef, ObjectRef>,
orphan_pages: &mut BTreeSet<ObjectRef>,
depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<Option<Vec<ObjectRef>>> {
if depth > DEFAULT_MAX_ACROFORM_DEPTH {
return Err(Error::Unsupported(format!(
"AcroForm field tree depth exceeds maximum of {DEFAULT_MAX_ACROFORM_DEPTH}"
)));
}
if !visited.insert(field_ref) {
return Ok(Some(Vec::new())); }
let Some(kids) = field_kid_refs(source, field_ref)? else {
return Ok(None); };
let mut survivors: Vec<ObjectRef> = Vec::with_capacity(kids.len());
for kid_ref in kids {
let kid_kind = trim_field_kids(
source,
target,
kid_ref,
surviving_pages,
retained_widgets,
map,
orphan_pages,
depth + 1,
visited,
)?; match kid_kind {
Some(sub_survivors) => {
if sub_survivors.is_empty() {
continue;
}
rewrite_field_kids(target, kid_ref, &sub_survivors, map)?;
survivors.push(kid_ref);
}
None => {
if retained_widgets.contains(&kid_ref) {
survivors.push(kid_ref);
} else {
match widget_page_ref(source, kid_ref)? {
Some(page_ref) if surviving_pages.contains(&page_ref) => {
survivors.push(kid_ref)
}
Some(page_ref) => {
orphan_pages.insert(page_ref);
}
None => {} }
}
}
}
}
Ok(Some(survivors))
}
fn rewrite_field_kids<R: Read + Seek>(
target: &mut Pdf<R>,
src_field_ref: ObjectRef,
survivors: &[ObjectRef],
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let Some(target_field_ref) = map.get(&src_field_ref).copied() else {
return Ok(()); };
let Some(mut field) = target
.resolve_borrowed(target_field_ref)?
.as_dict()
.cloned()
else {
return Ok(()); };
let kids: Vec<Object> = survivors
.iter()
.filter_map(|src| map.get(src).map(|&t| Object::Reference(t)))
.collect();
field.insert("Kids", Object::Array(kids));
target.set_object(target_field_ref, Object::Dictionary(field));
Ok(())
}
pub fn merge_documents<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if inputs.is_empty() {
return Err(Error::Unsupported(
"merge requires at least one input".to_string(),
));
}
let mut target = Pdf::open_mem_owned(minimal_target_bytes())?;
let pages_root_ref = target_pages_root(&mut target)?;
let mut kids: Vec<ObjectRef> = Vec::new();
let mut used: BTreeSet<ObjectRef> = BTreeSet::new();
let mut kept_fields: Vec<KeptField> = Vec::new();
let mut primary_acroform = PrimaryAcroForm::default();
let mut primary_map: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
let depth = DEFAULT_MAX_PAGE_TREE_DEPTH;
for (input_index, input) in inputs.iter_mut().enumerate() {
let is_primary = input_index == 0;
if !is_primary && input.pages.is_empty() {
continue;
}
let doc_level = if is_primary {
discover_primary_doc_level(input.source)?
} else {
PrimaryDocLevel::default()
};
if is_primary {
primary_acroform = discover_primary_acroform(input.source)?;
}
let source_fields = source_top_level_field_names(input.source)?;
let all = page_refs(input.source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(input.pages.len());
for &idx in &input.pages {
let page_ref = *all.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (input document has {} pages)",
all.len()
))
})?;
selected.push(page_ref);
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut unique: Vec<ObjectRef> = Vec::with_capacity(selected.len());
for &page_ref in &selected {
if seen.insert(page_ref) {
unique.push(page_ref);
}
}
let mut inherited: Vec<InheritedAttrs> = Vec::with_capacity(unique.len());
for &page_ref in &unique {
inherited.push(InheritedAttrs::resolve(input.source, page_ref, depth)?);
}
let mut closure: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &unique {
extend_page_object_closure(input.source, page_ref, &mut closure)?;
}
fold_doc_level_closure(input.source, &doc_level, &mut closure)?;
if is_primary {
closure.extend(primary_acroform.closure_seed.iter().copied());
}
let unique_set: BTreeSet<ObjectRef> = unique.iter().copied().collect();
let mut removed_targets: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &unique {
collect_removed_dest_targets(
input.source,
page_ref,
&unique_set,
&mut removed_targets,
)?;
}
collect_doc_level_removed_targets(
input.source,
&doc_level,
&unique_set,
&mut removed_targets,
)?; closure.extend(removed_targets.iter().copied());
let surviving_before: BTreeSet<ObjectRef> = target.object_refs().into_iter().collect();
let map = copy_objects(input.source, &mut target, &closure)?;
debug_assert!(
map.values().all(|new| !surviving_before.contains(new)),
"copy_objects must allocate refs disjoint from surviving target refs \
(renumbering-disjointness invariant; guards against shared-destination double-remap)"
);
for src_ref in &removed_targets {
if let Some(&new_ref) = map.get(src_ref) {
target.set_object(new_ref, Object::Null);
}
}
if is_primary {
wire_doc_level(input.source, &mut target, &doc_level, &map)?;
}
let mut orphan_pages: BTreeSet<ObjectRef> = BTreeSet::new();
let mut retained_widgets: BTreeSet<ObjectRef> = BTreeSet::new();
collect_retained_widget_refs(input.source, &unique_set, &mut retained_widgets)?;
for (src_field_ref, partial_name) in source_fields {
if let Some(&target_ref) = map.get(&src_field_ref) {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let trimmed = trim_field_kids(
input.source,
&mut target,
src_field_ref,
&unique_set,
&retained_widgets,
&map,
&mut orphan_pages,
0,
&mut visited,
)?; if let Some(survivors) = trimmed {
if survivors.is_empty() {
continue;
}
rewrite_field_kids(&mut target, src_field_ref, &survivors, &map)?;
}
kept_fields.push(KeptField {
target_ref,
partial_name,
is_primary,
});
}
}
for src_page_ref in &orphan_pages {
if let Some(&new_ref) = map.get(src_page_ref) {
target.set_object(new_ref, Object::Null);
}
}
if is_primary {
primary_map = map.clone();
}
for (&src_ref, attrs) in unique.iter().zip(inherited) {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("merged page missing from copy map"))?;
materialize_leaf(&mut target, copied_page_ref, attrs, &map, pages_root_ref)?;
}
append_selection_kids(&mut target, &selected, &map, &mut used, &mut kids)?;
}
let mut root = resolve_dict(
&mut target,
pages_root_ref,
"target /Pages is not a dictionary",
)?; root.insert(
"Kids",
Object::Array(kids.iter().map(|&r| Object::Reference(r)).collect()),
);
root.insert("Count", Object::Integer(kids.len() as i64));
target.set_object(pages_root_ref, Object::Dictionary(root));
build_merged_acroform(&mut target, &primary_acroform, &kept_fields, &primary_map)?;
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
#[cfg(test)]
mod tests {
use super::unique_field_name;
use std::collections::BTreeSet;
fn used(names: &[&[u8]]) -> BTreeSet<Vec<u8>> {
names.iter().map(|n| n.to_vec()).collect()
}
#[test]
fn unique_field_name_keeps_unused_base() {
assert_eq!(unique_field_name(b"name", &used(&[])), b"name".to_vec());
assert_eq!(
unique_field_name(b"name", &used(&[b"email"])),
b"name".to_vec()
);
}
#[test]
fn unique_field_name_appends_plus_one_on_collision() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name"])),
b"name+1".to_vec()
);
}
#[test]
fn unique_field_name_finds_first_unused_in_sequence() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name", b"name+1"])),
b"name+2".to_vec()
);
}
#[test]
fn unique_field_name_reresolves_colliding_candidate() {
assert_eq!(
unique_field_name(b"name+1", &used(&[b"name", b"name+1"])),
b"name+1+1".to_vec()
);
}
}