use std::collections::BTreeMap;
use std::fmt::Write as _;
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Dict(Vec<(String, Object)>);
impl Dict {
pub fn new() -> Dict {
Dict(Vec::new())
}
pub fn insert(&mut self, key: impl Into<String>, value: Object) {
let key = key.into();
match self.0.iter_mut().find(|(seen, _)| *seen == key) {
Some((_, slot)) => *slot = value,
None => self.0.push((key, value)),
}
}
pub fn get(&self, key: &str) -> Option<&Object> {
self.0
.iter()
.find(|(seen, _)| seen == key)
.map(|(_, value)| value)
}
pub fn iter(&self) -> impl Iterator<Item = (&String, &Object)> {
self.0.iter().map(|(key, value)| (key, value))
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn len(&self) -> usize {
self.0.len()
}
}
impl<K: Into<String>, const N: usize> From<[(K, Object); N]> for Dict {
fn from(pairs: [(K, Object); N]) -> Dict {
let mut dict = Dict::new();
for (key, value) in pairs {
dict.insert(key, value);
}
dict
}
}
impl<K: Into<String>> FromIterator<(K, Object)> for Dict {
fn from_iter<I: IntoIterator<Item = (K, Object)>>(pairs: I) -> Dict {
let mut dict = Dict::new();
for (key, value) in pairs {
dict.insert(key, value);
}
dict
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum Object {
Null,
Boolean(bool),
Integer(i64),
Real(f64),
Raw(String),
Str(String),
Hex(Vec<u8>),
Name(String),
Array(Vec<Object>),
Dict(Dict),
Stream {
dict: Dict,
data: Vec<u8>,
},
Reference(u32),
}
impl Object {
pub fn dict(pairs: impl IntoIterator<Item = (&'static str, Object)>) -> Object {
Object::Dict(
pairs
.into_iter()
.map(|(key, value)| (key.to_string(), value))
.collect(),
)
}
pub fn name(text: &str) -> Object {
Object::Name(text.to_string())
}
pub fn string(text: &str) -> Object {
Object::Str(text.to_string())
}
pub(crate) fn write_into(&self, out: &mut Vec<u8>) {
self.write(out)
}
fn write(&self, out: &mut Vec<u8>) {
match self {
Object::Null => out.extend(b"null"),
Object::Boolean(true) => out.extend(b"true"),
Object::Boolean(false) => out.extend(b"false"),
Object::Integer(value) => out.extend(value.to_string().as_bytes()),
Object::Real(value) => {
let mut text = format!("{value:.6}");
while text.contains('.') && (text.ends_with('0') || text.ends_with('.')) {
text.pop();
}
out.extend(
match text.is_empty() || text == "-0" {
true => "0".to_string(),
false => text,
}
.as_bytes(),
)
}
Object::Str(text) => {
out.push(b'(');
for byte in text.bytes() {
match byte {
b'(' | b')' | b'\\' => {
out.push(b'\\');
out.push(byte);
}
b'\n' => out.extend(b"\\n"),
b'\r' => out.extend(b"\\r"),
b'\t' => out.extend(b"\\t"),
other => out.push(other),
}
}
out.push(b')');
}
Object::Raw(text) => out.extend(text.as_bytes()),
Object::Hex(bytes) => {
out.push(b'<');
for byte in bytes {
out.extend(format!("{byte:02X}").as_bytes());
}
out.push(b'>');
}
Object::Name(text) => {
out.push(b'/');
for byte in text.bytes() {
const DELIMITERS: &[u8] = b"()<>[]{}/%#";
match byte.is_ascii_graphic() && !DELIMITERS.contains(&byte) {
true => out.push(byte),
false => out.extend(format!("#{byte:02X}").as_bytes()),
}
}
}
Object::Array(items) => {
out.push(b'[');
for item in items {
out.push(b' ');
item.write(out);
}
if !items.is_empty() {
out.push(b' ');
}
out.push(b']');
}
Object::Dict(pairs) => write_dict(pairs, out),
Object::Stream { dict, data } => {
write_stream_head(dict, data.len(), out);
out.extend(data);
out.extend(b"\nendstream");
}
Object::Reference(number) => out.extend(format!("{number} 0 R").as_bytes()),
}
}
}
fn write_stream_head(dict: &Dict, length: usize, out: &mut Vec<u8>) {
let mut dict = dict.clone();
dict.insert("Length", Object::Integer(length as i64));
write_dict(&dict, out);
out.extend(b"\nstream\n");
}
fn write_dict(pairs: &Dict, out: &mut Vec<u8>) {
out.extend(b"<<");
for (key, value) in pairs.iter() {
out.push(b' ');
Object::Name(key.clone()).write(out);
out.push(b' ');
value.write(out);
}
out.extend(b" >>");
}
#[derive(Clone, Copy)]
enum Where {
File(usize),
Packed(usize),
Nowhere,
}
fn deflate(data: &[u8]) -> Vec<u8> {
use std::io::Write as _;
let mut out = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
out.write_all(data).expect("deflate into a vector");
out.finish().expect("deflate into a vector")
}
fn file_identifier(digest: sha2::Sha256) -> Vec<u8> {
use sha2::Digest as _;
digest.finalize()[..16].to_vec()
}
pub(crate) fn stamp() -> i64 {
std::env::var("SOURCE_DATE_EPOCH")
.ok()
.and_then(|text| text.trim().parse::<i64>().ok())
.unwrap_or_else(|| {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0)
})
}
pub(crate) fn pdf_date(epoch: i64) -> String {
let (days, seconds) = (epoch.div_euclid(86_400), epoch.rem_euclid(86_400));
let (year, month, day) = civil_from_days(days);
let (hour, minute, second) = (seconds / 3600, (seconds / 60) % 60, seconds % 60);
format!("D:{year:04}{month:02}{day:02}{hour:02}{minute:02}{second:02}Z")
}
pub(crate) fn civil(days: i64) -> (i64, i64, i64) {
civil_from_days(days)
}
fn civil_from_days(days: i64) -> (i64, i64, i64) {
let z = days + 719_468;
let era = z.div_euclid(146_097);
let day_of_era = z - era * 146_097;
let year_of_era =
(day_of_era - day_of_era / 1460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
let year = year_of_era + era * 400;
let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
let shifted = (5 * day_of_year + 2) / 153;
let day = day_of_year - (153 * shifted + 2) / 5 + 1;
let month = match shifted < 10 {
true => shifted + 3,
false => shifted - 9,
};
(year + i64::from(month <= 2), month, day)
}
fn bytes_for(value: usize) -> usize {
((usize::BITS - value.leading_zeros()) as usize)
.div_ceil(8)
.max(1)
}
fn put(out: &mut Vec<u8>, value: usize, width: usize) {
for shift in (0..width).rev() {
out.push((value >> (shift * 8)) as u8);
}
}
pub fn inflate_streams(pdf: &[u8]) -> Vec<u8> {
use std::io::Read;
let mut out = Vec::with_capacity(pdf.len());
let mut i = 0;
while i < pdf.len() {
let Some(at) = find(&pdf[i..], b"stream").map(|a| i + a) else {
out.extend_from_slice(&pdf[i..]);
break;
};
let mut data = at + b"stream".len();
if pdf.get(data) == Some(&b'\r') {
data += 1;
}
if pdf.get(data) == Some(&b'\n') {
data += 1;
}
let Some(end) = find(&pdf[data..], b"endstream").map(|e| data + e) else {
out.extend_from_slice(&pdf[i..]);
break;
};
out.extend_from_slice(&pdf[i..data]);
let raw = &pdf[data..end];
let mut plain = Vec::new();
match flate2::read::ZlibDecoder::new(raw).read_to_end(&mut plain) {
Ok(_) => out.extend_from_slice(&plain),
Err(_) => out.extend_from_slice(raw),
}
out.extend_from_slice(b"endstream");
i = end + b"endstream".len();
}
out
}
fn find(hay: &[u8], needle: &[u8]) -> Option<usize> {
hay.windows(needle.len()).position(|w| w == needle)
}
pub fn unpacked(pdf: &[u8]) -> Vec<u8> {
let plain = inflate_streams(pdf);
let mut out = Vec::with_capacity(plain.len());
let mut i = 0;
while i < plain.len() {
let Some(key) = find(&plain[i..], b"/Type /ObjStm").map(|at| i + at) else {
out.extend_from_slice(&plain[i..]);
break;
};
let head = find_last(&plain[i..key], b" 0 obj").map(|at| i + at);
let data = find(&plain[key..], b"stream\n").map(|at| key + at + 7);
let (Some(head), Some(data)) = (head, data) else {
out.extend_from_slice(&plain[i..]);
break;
};
let Some(end) = find(&plain[data..], b"endstream").map(|at| data + at) else {
out.extend_from_slice(&plain[i..]);
break;
};
let start = find_last(&plain[i..head], b"\n")
.map(|at| i + at + 1)
.unwrap_or(head);
out.extend_from_slice(&plain[i..start]);
let dict = String::from_utf8_lossy(&plain[head..data]).into_owned();
let first: usize = match number_after(&dict, "/First ") {
Some(first) => first,
None => {
out.extend_from_slice(&plain[start..]);
break;
}
};
let body = &plain[data..end];
let pairs: Vec<usize> = String::from_utf8_lossy(&body[..first.min(body.len())])
.split_whitespace()
.filter_map(|word| word.parse().ok())
.collect();
for (index, pair) in pairs.chunks(2).enumerate() {
let [number, at] = pair else { continue };
let from = first + at;
let to = match pairs.get(index * 2 + 3) {
Some(next) => first + next,
None => body.len(),
};
if from > to || to > body.len() {
continue;
}
out.extend(format!("{number} 0 obj\n").as_bytes());
out.extend_from_slice(trim_end(&body[from..to]));
out.extend(b"\nendobj\n");
}
i = match find(&plain[end..], b"endobj") {
Some(at) => end + at + b"endobj".len(),
None => plain.len(),
};
}
out
}
fn find_last(hay: &[u8], needle: &[u8]) -> Option<usize> {
hay.windows(needle.len()).rposition(|w| w == needle)
}
fn trim_end(body: &[u8]) -> &[u8] {
let mut end = body.len();
while end > 0 && body[end - 1].is_ascii_whitespace() {
end -= 1;
}
&body[..end]
}
fn number_after(text: &str, key: &str) -> Option<usize> {
text.split_once(key)?
.1
.chars()
.take_while(char::is_ascii_digit)
.collect::<String>()
.parse()
.ok()
}
pub struct Pdf {
objects: Vec<Object>,
catalog: Option<u32>,
info: Option<u32>,
}
impl Default for Pdf {
fn default() -> Self {
Pdf::new()
}
}
impl Pdf {
pub fn new() -> Pdf {
Pdf {
objects: Vec::new(),
catalog: None,
info: None,
}
}
pub fn add(&mut self, object: Object) -> Object {
self.objects.push(object);
Object::Reference(self.objects.len() as u32)
}
pub fn reserve(&mut self) -> u32 {
self.objects.push(Object::Null);
self.objects.len() as u32
}
pub fn fill(&mut self, number: u32, object: Object) {
if let Some(slot) = self.objects.get_mut(number as usize - 1) {
*slot = object;
}
}
pub fn set_catalog(&mut self, number: u32) {
self.catalog = Some(number);
}
pub fn set_info(&mut self, number: u32) {
self.info = Some(number);
}
pub fn finish(&self) -> Vec<u8> {
let mut out = Vec::new();
out.extend(b"%PDF-1.7\n");
out.extend([
b'%', 0xcc, 0xd5, 0xc1, 0xd4, 0xc5, 0xd8, 0xd0, 0xc4, 0xc6, b'\n',
]);
let packable: Vec<bool> = self
.objects
.iter()
.map(|object| !matches!(object, Object::Stream { .. }))
.collect();
let objects = self.objects.len() as u32;
let objstm = packable.iter().any(|&yes| yes).then_some(objects + 1);
let table_number = objstm.unwrap_or(objects) + 1;
const STREAM_TAIL: &[u8] = b"\nendstream\nendobj\n";
let streams: Vec<(usize, Vec<u8>, &[u8])> = self
.objects
.iter()
.enumerate()
.filter_map(|(i, object)| match object {
Object::Stream { dict, data } => {
let mut head = format!("{} 0 obj\n", i + 1).into_bytes();
write_stream_head(dict, data.len(), &mut head);
Some((i, head, data.as_slice()))
}
_ => None,
})
.collect();
let mut located: Vec<Where> = vec![Where::Nowhere; self.objects.len()];
let mut at = out.len();
for (i, head, data) in &streams {
located[*i] = Where::File(at);
at += head.len() + data.len() + STREAM_TAIL.len();
}
let mut in_objstm = 0usize;
for (i, place) in located.iter_mut().enumerate() {
if packable[i] {
*place = Where::Packed(in_objstm);
in_objstm += 1;
}
}
let pack = || -> Vec<u8> {
let Some(number) = objstm else {
return Vec::new();
};
let mut head = String::new();
let mut body = Vec::new();
for (i, object) in self.objects.iter().enumerate() {
if !packable[i] {
continue;
}
let space = match body.is_empty() {
true => "",
false => " ",
};
let _ = write!(head, "{space}{} {}", i + 1, body.len());
object.write(&mut body);
body.push(b'\n');
}
head.push('\n');
let first = head.len();
let mut data = head.into_bytes();
data.append(&mut body);
let mut written = format!("{number} 0 obj\n").into_bytes();
Object::Stream {
dict: Dict::from([
("Type".to_string(), Object::name("ObjStm")),
("N".to_string(), Object::Integer(in_objstm as i64)),
("First".to_string(), Object::Integer(first as i64)),
("Filter".to_string(), Object::name("FlateDecode")),
]),
data: deflate(&data),
}
.write(&mut written);
written.extend(b"\nendobj\n");
written
};
let mut digest = <sha2::Sha256 as sha2::Digest>::new();
sha2::Digest::update(&mut digest, &out);
let ((mut digest, ()), packed) = rayon::join(
|| {
rayon::join(
|| {
for (_, head, data) in &streams {
sha2::Digest::update(&mut digest, head);
sha2::Digest::update(&mut digest, data);
sha2::Digest::update(&mut digest, STREAM_TAIL);
}
digest
},
|| {
out.reserve(at - out.len());
for (_, head, data) in &streams {
out.extend(head);
out.extend(*data);
out.extend(STREAM_TAIL);
}
},
)
},
pack,
);
let objstm_offset = out.len();
out.extend(&packed);
sha2::Digest::update(&mut digest, &packed);
let mut rows: Vec<(u8, usize, usize)> = vec![(0, 0, 0xffff)];
for place in &located {
rows.push(match place {
Where::File(offset) => (1, *offset, 0),
Where::Packed(index) => (2, objstm.unwrap_or(0) as usize, *index),
Where::Nowhere => (0, 0, 0xffff),
});
}
if objstm.is_some() {
rows.push((1, objstm_offset, 0));
}
let table_offset = out.len();
rows.push((1, table_offset, 0));
let widest = |field: fn(&(u8, usize, usize)) -> Option<usize>| {
rows.iter().filter_map(field).max().unwrap_or(0)
};
let second = widest(|row| (row.0 != 0).then_some(row.1)).max(0xffff);
let third = widest(|row| (row.0 == 2).then_some(row.2));
let (second, third) = (bytes_for(second), bytes_for(third));
let mut data = Vec::with_capacity(rows.len() * (1 + second + third));
for (kind, one, two) in &rows {
data.push(*kind);
put(&mut data, *one, second);
put(&mut data, *two, third);
}
let mut dict = Dict::from([
("Type".to_string(), Object::name("XRef")),
(
"Index".to_string(),
Object::Array(vec![Object::Integer(0), Object::Integer(rows.len() as i64)]),
),
("Size".to_string(), Object::Integer(rows.len() as i64)),
(
"W".to_string(),
Object::Array(vec![
Object::Integer(1),
Object::Integer(second as i64),
Object::Integer(third as i64),
]),
),
]);
if let Some(catalog) = self.catalog {
dict.insert("Root".to_string(), Object::Reference(catalog));
}
if let Some(info) = self.info {
dict.insert("Info".to_string(), Object::Reference(info));
}
let id = file_identifier(digest);
dict.insert(
"ID".to_string(),
Object::Array(vec![Object::Hex(id.clone()), Object::Hex(id)]),
);
dict.insert("Filter".to_string(), Object::name("FlateDecode"));
out.extend(format!("{table_number} 0 obj\n").as_bytes());
Object::Stream {
dict,
data: deflate(&data),
}
.write(&mut out);
out.extend(b"\nendobj\n");
let mut tail = String::new();
let _ = write!(tail, "startxref\n{table_offset}\n%%EOF\n");
out.extend(tail.as_bytes());
out
}
pub fn len(&self) -> usize {
self.objects.len()
}
pub fn is_empty(&self) -> bool {
self.objects.is_empty()
}
}
pub(crate) trait Sink {
fn add(&mut self, object: Object) -> Object;
}
impl Sink for Pdf {
fn add(&mut self, object: Object) -> Object {
Pdf::add(self, object)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TexFont {
pub tfm_name: String,
pub program_file: String,
pub program: crate::type1::Type1,
pub size: i64,
pub widths: Vec<Option<i64>>,
pub ascent: i64,
pub cap_height: i64,
pub descent: i64,
pub stem_v: i64,
pub x_height: i64,
}
impl TexFont {
pub fn open(tfm_name: &str, program_file: &str) -> Option<TexFont> {
let tfm = crate::tfm::Tfm::open(crate::kpse::locate(&format!("{tfm_name}.tfm"))?).ok()?;
let program = crate::type1::Type1::open(crate::type1::installed(program_file)?).ok()?;
let (size, widths, [ascent, cap_height, descent, stem_v, x_height]) =
crate::pdfdoc::tex_metrics(&tfm);
Some(TexFont {
tfm_name: tfm_name.to_string(),
program_file: program_file.to_string(),
program,
size,
widths,
ascent,
cap_height,
descent,
stem_v,
x_height,
})
}
pub fn glyph_for(&self, code: u8) -> Option<String> {
glyph_for_code(&self.program, code)
}
fn tfm_speaks_for(&self, code: u8) -> bool {
self.widths[usize::from(code)].is_some()
&& self.program.encoded(code).map(|g| &g.name) == self.glyph_for(code).as_ref()
}
pub fn exists(&self, code: u8) -> bool {
match self.tfm_speaks_for(code) {
true => true,
false => self
.glyph_for(code)
.is_some_and(|g| self.program.glyph(&g).is_some()),
}
}
pub fn char_width_e1(&self, code: u8) -> i64 {
if self.tfm_speaks_for(code) {
let w = self.widths[usize::from(code)].unwrap_or(0);
return (w as f64 / self.size as f64 * 10_000.0).round() as i64;
}
self.glyph_for(code)
.and_then(|g| {
self.program
.glyph(&g)
.map(|g| (g.width * 10.0).round() as i64)
})
.unwrap_or(0)
}
}
pub(crate) fn glyph_for_code(font: &crate::type1::Type1, code: u8) -> Option<String> {
if code == b' ' {
if let Some(glyph) = font.glyph("space") {
return Some(glyph.name.clone());
}
}
if let Some(glyph) = font.encoded(code) {
return Some(glyph.name.clone());
}
let character = crate::typeset::winansi_unicode(code)?.to_string();
font.glyph_names()
.into_iter()
.find(|name| crate::agl::unicode(name).as_deref() == Some(character.as_str()))
.map(str::to_string)
}
#[derive(Debug, Clone, PartialEq)]
pub enum Font {
Base14(String),
Embedded(Box<crate::type1::Type1>),
Tex(Box<TexFont>),
TrueType {
name: String,
bytes: Vec<u8>,
widths: Vec<i64>,
bbox: [i64; 4],
ascent: i64,
descent: i64,
},
Glyphs {
name: String,
bytes: Vec<u8>,
glyphs: Vec<(u16, char, i64)>,
bbox: [i64; 4],
ascent: i64,
descent: i64,
},
}
impl Font {
pub fn name(&self) -> String {
match self {
Font::Base14(name) => name.clone(),
Font::Embedded(font) => font.font_name.clone(),
Font::Tex(font) => font.program.font_name.clone(),
Font::TrueType { name, .. } | Font::Glyphs { name, .. } => name.clone(),
}
}
pub fn is_composite(&self) -> bool {
matches!(self, Font::Glyphs { .. })
}
pub fn computer_modern() -> Option<Font> {
static FACE: std::sync::OnceLock<Option<Font>> = std::sync::OnceLock::new();
FACE.get_or_init(|| {
let font = TexFont::open("cmr10", "cmr10.pfb")?;
Some(Font::Tex(Box::new(font)))
})
.clone()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Set {
pub natural: f64,
pub width: f64,
}
#[derive(Debug, Clone)]
pub struct Page {
pub width: f64,
pub height: f64,
pub content: String,
pub images: Vec<(String, std::sync::Arc<crate::image::Image>)>,
pub fonts: Vec<(String, std::sync::Arc<Font>)>,
pub used: BTreeMap<String, std::collections::BTreeSet<u8>>,
pub ext_gstates: Vec<(String, String, f64)>,
pub shadings: Vec<(String, String)>,
}
impl Page {
pub fn letter() -> Page {
Page {
width: 612.0,
height: 792.0,
content: String::new(),
fonts: Vec::new(),
images: Vec::new(),
used: BTreeMap::new(),
ext_gstates: Vec::new(),
shadings: Vec::new(),
}
}
pub fn ext_gstate(&mut self, name: &str, key: &str, value: f64) {
if self.ext_gstates.iter().any(|(used, _, _)| used == name) {
return;
}
self.ext_gstates
.push((name.to_string(), key.to_string(), value));
}
pub fn shading(&mut self, name: &str, dictionary: &str) {
if self.shadings.iter().any(|(used, _)| used == name) {
return;
}
self.shadings
.push((name.to_string(), dictionary.to_string()));
}
pub fn text(&mut self, font: &str, size: f64, x: f64, y: f64, text: &str) {
self.text_in(Font::Base14(font.to_string()), size, x, y, text);
}
pub fn text_in(
&mut self,
font: impl Into<std::sync::Arc<Font>>,
size: f64,
x: f64,
y: f64,
text: &str,
) {
self.draw(font, size, x, y, text, 0.0);
}
pub fn text_set(
&mut self,
font: impl Into<std::sync::Arc<Font>>,
size: f64,
x: f64,
y: f64,
text: &str,
set: Set,
) {
let font = font.into();
let spaces = match font.is_composite() {
true => 0,
false => text.chars().filter(|c| *c == ' ').count(),
};
let word_space = match spaces {
0 => 0.0,
n => (set.width - set.natural) / n as f64,
};
self.draw(font, size, x, y, text, word_space);
}
fn draw(
&mut self,
font: impl Into<std::sync::Arc<Font>>,
size: f64,
x: f64,
y: f64,
text: &str,
word_space: f64,
) {
let font = font.into();
let name = format!("F{}", self.fonts.len() + 1);
let name = match self
.fonts
.iter()
.find(|(_, used)| std::sync::Arc::ptr_eq(used, &font) || **used == *font)
{
Some((existing, _)) => existing.clone(),
None => {
self.fonts.push((name.clone(), font));
name
}
};
self.used
.entry(name.clone())
.or_default()
.extend(text.chars().map(|c| (c as u32 & 0xFF) as u8));
let escaped: String = text
.chars()
.flat_map(|c| match c {
'(' | ')' | '\\' => vec!['\\', c],
c if (c as u32) < 32 || (c as u32) > 126 => {
format!("\\{:03o}", (c as u32) & 0xFF).chars().collect()
}
other => vec![other],
})
.collect();
let (open, close) = match word_space == 0.0 {
true => (String::new(), String::new()),
false => (format!("{word_space} Tw "), " 0 Tw".to_string()),
};
let _ = writeln!(
self.content,
"BT /{name} {size} Tf 1 0 0 1 {x} {y} Tm {open}({escaped}) Tj{close} ET"
);
}
pub fn image(
&mut self,
image: impl Into<std::sync::Arc<crate::image::Image>>,
x: f64,
y: f64,
width: f64,
height: f64,
) {
let image = image.into();
let name = match self.images.iter().find(|(_, used)| same(&**used, &*image)) {
Some((existing, _)) => existing.clone(),
None => {
let name = format!("I{}", self.images.len() + 1);
self.images.push((name.clone(), image));
name
}
};
let _ = writeln!(
self.content,
"q {width} 0 0 {height} {x} {y} cm /{name} Do Q"
);
}
pub fn rule(&mut self, x: f64, y: f64, width: f64, height: f64) {
let _ = writeln!(self.content, "{x} {y} {width} {height} re f");
}
}
pub(crate) fn same<T: PartialEq>(a: &T, b: &T) -> bool {
std::ptr::eq(a, b) || a == b
}
pub(crate) const PARALLEL_PAGES: usize = 8;
pub(crate) fn picture_classes(pages: &[Page]) -> Vec<Vec<usize>> {
use crate::image::Image;
use rayon::prelude::*;
let key = |image: &Image| {
(
image.width,
image.height,
image.bits,
image.data.len(),
image.alpha.as_ref().map(Vec::len),
image.palette.as_ref().map(Vec::len),
)
};
let mut firsts: Vec<&Image> = Vec::new();
let mut by_key = std::collections::HashMap::new();
let classes: Vec<Vec<usize>> = pages
.iter()
.map(|page| {
page.images
.iter()
.map(|(_, image)| {
*by_key.entry(key(image)).or_insert_with(|| {
firsts.push(image);
firsts.len() - 1
})
})
.collect()
})
.collect();
let uses: Vec<(&Image, usize)> = pages
.iter()
.zip(&classes)
.flat_map(|(page, classes)| {
page.images
.iter()
.map(|(_, image)| &**image)
.zip(classes.iter().copied())
})
.collect();
let confirmed = match uses.len() >= PARALLEL_PAGES {
true => uses
.par_iter()
.all(|&(image, class)| same(firsts[class], image)),
false => uses
.iter()
.all(|&(image, class)| same(firsts[class], image)),
};
if confirmed {
return classes;
}
let mut firsts: Vec<&Image> = Vec::new();
pages
.iter()
.map(|page| {
page.images
.iter()
.map(
|(_, image)| match firsts.iter().position(|seen| same(*seen, image)) {
Some(class) => class,
None => {
firsts.push(image);
firsts.len() - 1
}
},
)
.collect()
})
.collect()
}
pub fn document(pages: &[Page]) -> Vec<u8> {
let contents = pages.iter().map(|page| page.content.clone()).collect();
assemble(pages, contents)
}
pub fn document_from(mut pages: Vec<Page>) -> Vec<u8> {
let contents = pages
.iter_mut()
.map(|page| std::mem::take(&mut page.content))
.collect();
assemble(&pages, contents)
}
fn assemble(pages: &[Page], contents: Vec<String>) -> Vec<u8> {
let prepared = crate::pdfdoc::take_prepared().unwrap_or_default();
crate::pdfdoc::write(pages, contents, prepared)
}
pub(crate) fn extra_resources(page: &Page) -> Dict {
let mut resources = Dict::new();
if !page.ext_gstates.is_empty() {
let states: Dict = page
.ext_gstates
.iter()
.map(|(name, key, value)| {
(
name.clone(),
Object::Dict(Dict::from([(key.clone(), Object::Real(*value))])),
)
})
.collect();
resources.insert("ExtGState".to_string(), Object::Dict(states));
}
if !page.shadings.is_empty() {
let shades: Dict = page
.shadings
.iter()
.map(|(name, dictionary)| (name.clone(), Object::Raw(dictionary.clone())))
.collect();
resources.insert("Shading".to_string(), Object::Dict(shades));
}
resources
}
pub(crate) fn write_image_as(
w: &mut crate::pdfdoc::Writer,
number: u32,
image: &crate::image::Image,
) {
let Object::Stream { dict, data } = image_object(w, image) else {
return;
};
let own_filter = dict.get("Filter").is_some();
let keys: String = {
let mut body = Vec::new();
Object::Dict(dict).write(&mut body);
String::from_utf8_lossy(&body)
.trim_start_matches("<<")
.trim_end_matches(">>")
.trim()
.to_string()
};
w.stream(number, &keys, &data, !own_filter);
}
pub(crate) fn write_font_as(
w: &mut crate::pdfdoc::Writer,
number: u32,
font: &Font,
codes: &std::collections::BTreeSet<u8>,
) {
let dict = build_font(w, font, codes);
let mut body = Vec::new();
dict.write(&mut body);
w.object(number, 1, &body);
}
fn image_object(pdf: &mut impl Sink, image: &crate::image::Image) -> Object {
use crate::image::{Colours, Compression};
let space = match (image.colours, &image.palette) {
(Colours::Indexed, Some(palette)) => Object::Array(vec![
Object::name("Indexed"),
Object::name("DeviceRGB"),
Object::Integer(palette.len() as i64 / 3 - 1),
Object::Str(palette.iter().map(|&b| b as char).collect()),
]),
(Colours::Gray, _) => Object::name("DeviceGray"),
(Colours::Cmyk, _) => Object::name("DeviceCMYK"),
_ => Object::name("DeviceRGB"),
};
let mut dict = Dict::from([
("Type".to_string(), Object::name("XObject")),
("Subtype".to_string(), Object::name("Image")),
("Width".to_string(), Object::Integer(image.width as i64)),
("Height".to_string(), Object::Integer(image.height as i64)),
(
"BitsPerComponent".to_string(),
Object::Integer(image.bits as i64),
),
("ColorSpace".to_string(), space),
]);
match image.compression {
Compression::Dct => {
dict.insert("Filter".to_string(), Object::name("DCTDecode"));
}
Compression::Flate => {
dict.insert("Filter".to_string(), Object::name("FlateDecode"));
dict.insert(
"DecodeParms".to_string(),
Object::dict([
("Predictor", Object::Integer(15)),
("Colors", Object::Integer(image.colours.components() as i64)),
("BitsPerComponent", Object::Integer(image.bits as i64)),
("Columns", Object::Integer(image.width as i64)),
]),
);
}
}
if let Some(alpha) = &image.alpha {
let mask = pdf.add(Object::Stream {
dict: Dict::from([
("Type".to_string(), Object::name("XObject")),
("Subtype".to_string(), Object::name("Image")),
("Width".to_string(), Object::Integer(image.width as i64)),
("Height".to_string(), Object::Integer(image.height as i64)),
(
"BitsPerComponent".to_string(),
Object::Integer(image.bits as i64),
),
("ColorSpace".to_string(), Object::name("DeviceGray")),
("Filter".to_string(), Object::name("FlateDecode")),
(
"DecodeParms".to_string(),
Object::dict([
("Predictor", Object::Integer(15)),
("Colors", Object::Integer(1)),
("BitsPerComponent", Object::Integer(image.bits as i64)),
("Columns", Object::Integer(image.width as i64)),
]),
),
]),
data: alpha.clone(),
});
dict.insert("SMask".to_string(), mask);
}
Object::Stream {
dict,
data: image.data.clone(),
}
}
fn subset_tag(name: &str, glyphs: impl IntoIterator<Item = u16>) -> String {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
let mut eat = |byte: u8| {
hash ^= u64::from(byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
};
for byte in name.bytes() {
eat(byte);
}
for glyph in glyphs {
eat((glyph >> 8) as u8);
eat((glyph & 0xFF) as u8);
}
(0..6)
.map(|i| (b'A' + ((hash >> (i * 5)) % 26) as u8) as char)
.collect()
}
fn cut_to_codes(
name: &str,
bytes: &[u8],
codes: &std::collections::BTreeSet<u8>,
) -> Option<(String, Vec<u8>)> {
let sfnt = crate::sfnt::Sfnt::parse(bytes.to_vec()).ok()?;
let cmap = sfnt.cmap().ok()?;
let keep: std::collections::BTreeSet<u16> = codes
.iter()
.filter_map(|code| crate::typeset::winansi_unicode(*code))
.filter_map(|ch| cmap.get(&(ch as u32)).copied())
.collect();
if keep.is_empty() {
return None;
}
let cut = sfnt.subset_encoded(&keep).ok()?;
Some((subset_tag(name, keep.iter().copied()), cut))
}
fn base14_font(pdf: &mut impl Sink, font: &Font) -> Object {
let name = font.name();
let built_in = name == "Symbol" || name == "ZapfDingbats";
let mut entries = vec![
("Type", Object::name("Font")),
("Subtype", Object::name("Type1")),
("BaseFont", Object::name(&name)),
];
if !built_in {
entries.push(("Encoding", Object::name("WinAnsiEncoding")));
}
if name == "Symbol" {
let meanings: Vec<(u8, String)> = (0u8..=255)
.filter_map(|code| Some((code, crate::typeset::symbol_unicode(code)?.to_string())))
.collect();
let map = pdf.add(Object::Stream {
dict: Dict::new(),
data: crate::agl::to_unicode(&name, &meanings).into_bytes(),
});
entries.push(("ToUnicode", map));
}
Object::dict(entries)
}
fn build_font(pdf: &mut impl Sink, font: &Font, codes: &std::collections::BTreeSet<u8>) -> Object {
if let Font::Glyphs {
name,
bytes,
glyphs,
bbox,
ascent,
descent,
} = font
{
let name = &format!(
"{}+{name}",
subset_tag(name, glyphs.iter().map(|(gid, _, _)| *gid))
);
let file = pdf.add(Object::Stream {
dict: Dict::from([("Length1".to_string(), Object::Integer(bytes.len() as i64))]),
data: bytes.clone(),
});
let descriptor = pdf.add(Object::dict([
("Type", Object::name("FontDescriptor")),
("FontName", Object::name(name)),
("Flags", Object::Integer(4)),
(
"FontBBox",
Object::Array(bbox.iter().map(|v| Object::Integer(*v)).collect()),
),
("ItalicAngle", Object::Integer(0)),
("Ascent", Object::Integer(*ascent)),
("Descent", Object::Integer(*descent)),
("CapHeight", Object::Integer(*ascent)),
("StemV", Object::Integer(80)),
("FontFile2", file),
]));
let widths: Vec<Object> = glyphs
.iter()
.flat_map(|(gid, _, w)| {
[
Object::Integer(i64::from(*gid)),
Object::Array(vec![Object::Integer(*w)]),
]
})
.collect();
let descendant = pdf.add(Object::dict([
("Type", Object::name("Font")),
("Subtype", Object::name("CIDFontType2")),
("BaseFont", Object::name(name)),
(
"CIDSystemInfo",
Object::dict([
("Registry", Object::string("Adobe")),
("Ordering", Object::string("Identity")),
("Supplement", Object::Integer(0)),
]),
),
("FontDescriptor", descriptor),
("DW", Object::Integer(1000)),
("W", Object::Array(widths)),
("CIDToGIDMap", Object::name("Identity")),
]));
let meanings: Vec<(u16, String)> = glyphs
.iter()
.map(|(gid, ch, _)| (*gid, ch.to_string()))
.collect();
let to_unicode = pdf.add(Object::Stream {
dict: Dict::new(),
data: crate::agl::to_unicode_wide(name, &meanings).into_bytes(),
});
return Object::dict([
("Type", Object::name("Font")),
("Subtype", Object::name("Type0")),
("BaseFont", Object::name(name)),
("Encoding", Object::name("Identity-H")),
("DescendantFonts", Object::Array(vec![descendant])),
("ToUnicode", to_unicode),
]);
}
if let Font::TrueType {
name,
bytes,
widths,
bbox,
ascent,
descent,
} = font
{
let (tag, program) = match cut_to_codes(name, bytes, codes) {
Some((tag, cut)) => (format!("{tag}+"), cut),
None => (String::new(), bytes.clone()),
};
let name = &format!("{tag}{name}");
let file = pdf.add(Object::Stream {
dict: Dict::from([("Length1".to_string(), Object::Integer(program.len() as i64))]),
data: program,
});
let descriptor = pdf.add(Object::dict([
("Type", Object::name("FontDescriptor")),
("FontName", Object::name(name)),
("Flags", Object::Integer(32)),
(
"FontBBox",
Object::Array(bbox.iter().map(|v| Object::Integer(*v)).collect()),
),
("ItalicAngle", Object::Integer(0)),
("Ascent", Object::Integer(*ascent)),
("Descent", Object::Integer(*descent)),
("CapHeight", Object::Integer(*ascent)),
("StemV", Object::Integer(80)),
("FontFile2", file),
]));
return Object::dict([
("Type", Object::name("Font")),
("Subtype", Object::name("TrueType")),
("BaseFont", Object::name(name)),
("FirstChar", Object::Integer(32)),
("LastChar", Object::Integer(255)),
(
"Widths",
Object::Array(widths.iter().map(|w| Object::Integer(*w)).collect()),
),
("Encoding", Object::name("WinAnsiEncoding")),
("FontDescriptor", descriptor),
]);
}
let type1: &crate::type1::Type1 = match font {
Font::Embedded(type1) => type1,
Font::Tex(tex) => &tex.program,
_ => return base14_font(pdf, font),
};
let wanted = |font: &crate::type1::Type1, code: u8| glyph_for_code(font, code);
let keep: std::collections::BTreeSet<String> = codes
.iter()
.filter_map(|&code| wanted(type1, code))
.collect();
let cut = match keep.is_empty() {
true => None,
false => {
let tag = subset_tag(&type1.font_name, codes.iter().map(|&c| u16::from(c)));
type1.subset(&keep, &tag)
}
};
let subsetted = cut.is_some();
let type1 = cut.as_ref().unwrap_or(type1);
let (bytes, clear, binary, trailer) = type1.embeddable();
let file = pdf.add(Object::Stream {
dict: Dict::from([
("Length1".to_string(), Object::Integer(clear as i64)),
("Length2".to_string(), Object::Integer(binary as i64)),
("Length3".to_string(), Object::Integer(trailer as i64)),
]),
data: bytes,
});
let bbox = type1.font_bbox;
let heights = type1.afm_metrics;
let mut entries = vec![
("Type", Object::name("FontDescriptor")),
("FontName", Object::name(&type1.font_name)),
("Flags", Object::Integer(4)),
(
"FontBBox",
Object::Array(bbox.iter().map(|&n| Object::Real(n)).collect()),
),
(
"Ascent",
Object::Real(heights.map(|m| m.ascender).unwrap_or(bbox[3])),
),
(
"CapHeight",
Object::Real(heights.map(|m| m.cap_height).unwrap_or(bbox[3])),
),
(
"Descent",
Object::Real(heights.map(|m| m.descender).unwrap_or(bbox[1])),
),
("ItalicAngle", Object::Real(type1.italic_angle)),
("StemV", Object::Real(type1.stem_v.unwrap_or(80.0))),
];
if let Some(metrics) = heights {
entries.push(("XHeight", Object::Real(metrics.x_height)));
}
entries.push((
"CharSet",
Object::string(
&type1
.glyph_names()
.iter()
.map(|name| format!(" /{name}"))
.collect::<String>(),
),
));
entries.push(("FontFile", file));
let descriptor = pdf.add(Object::dict(entries));
let addressed: Vec<u8> = match subsetted {
true => codes.iter().copied().collect(),
false => (0..=255u8).collect(),
};
let encoded: BTreeMap<u8, &crate::type1::Glyph> = addressed
.into_iter()
.filter_map(|code| Some((code, type1.glyph(&wanted(type1, code)?)?)))
.collect();
let first = encoded.keys().next().copied().unwrap_or(0) as usize;
let last = encoded.keys().next_back().copied().unwrap_or(0) as usize;
let mut differences = Vec::new();
let mut expected = usize::MAX;
for code in first..=last {
let Some(glyph) = encoded.get(&(code as u8)) else {
continue;
};
if code != expected {
differences.push(Object::Integer(code as i64));
}
differences.push(Object::name(&glyph.name));
expected = code + 1;
}
let encoding = pdf.add(Object::dict([
("Type", Object::name("Encoding")),
("Differences", Object::Array(differences)),
]));
let widths: Vec<Object> = (first..=last)
.map(|code| {
Object::Real(
encoded
.get(&(code as u8))
.map(|glyph| glyph.width)
.unwrap_or(0.0),
)
})
.collect();
let meanings: Vec<(u8, String)> = (first..=last)
.filter_map(|code| {
let glyph = encoded.get(&(code as u8))?;
Some((code as u8, crate::agl::unicode(&glyph.name)?))
})
.collect();
let to_unicode = pdf.add(Object::Stream {
dict: Dict::new(),
data: crate::agl::to_unicode(&type1.font_name, &meanings).into_bytes(),
});
Object::dict([
("Type", Object::name("Font")),
("Subtype", Object::name("Type1")),
("BaseFont", Object::name(&type1.font_name)),
("FontDescriptor", descriptor),
("FirstChar", Object::Integer(first as i64)),
("LastChar", Object::Integer(last as i64)),
("Widths", Object::Array(widths)),
("Encoding", encoding),
("ToUnicode", to_unicode),
])
}
#[cfg(test)]
mod tests {
use super::*;
fn written(object: Object) -> String {
let mut out = Vec::new();
object.write(&mut out);
String::from_utf8_lossy(&out).into_owned()
}
#[test]
fn an_object_is_written_the_way_the_specification_says() {
assert_eq!(written(Object::Null), "null");
assert_eq!(written(Object::Boolean(true)), "true");
assert_eq!(written(Object::Integer(-42)), "-42");
assert_eq!(written(Object::Reference(12)), "12 0 R");
assert_eq!(written(Object::Real(1.5)), "1.5");
assert_eq!(written(Object::Real(612.0)), "612");
assert_eq!(written(Object::Real(0.0000001)), "0");
assert_eq!(written(Object::Real(-0.25)), "-0.25");
assert_eq!(written(Object::string("plain")), "(plain)");
assert_eq!(written(Object::string("a (b) c")), "(a \\(b\\) c)");
assert_eq!(written(Object::string("back\\slash")), "(back\\\\slash)");
assert_eq!(written(Object::string("two\nlines")), "(two\\nlines)");
assert_eq!(written(Object::name("Helvetica")), "/Helvetica");
assert_eq!(written(Object::name("a b")), "/a#20b");
assert_eq!(written(Object::name("A#B")), "/A#23B");
assert_eq!(
written(Object::Array(vec![Object::Integer(1), Object::name("x")])),
"[ 1 /x ]"
);
assert_eq!(
written(Object::dict([
("Type", Object::name("Page")),
("Count", Object::Integer(2))
])),
"<< /Type /Page /Count 2 >>"
);
assert_eq!(written(Object::Dict(Dict::new())), "<< >>");
}
#[test]
fn a_stream_carries_the_length_of_what_it_holds() {
let text = written(Object::Stream {
dict: Dict::from([("Length".to_string(), Object::Integer(9999))]),
data: b"12345".to_vec(),
});
assert!(text.starts_with("<< /Length 5 >>"), "{text}");
assert!(text.contains("\nstream\n12345\nendstream"), "{text}");
}
#[test]
fn every_entry_in_the_table_lands_where_it_says() {
let mut pdf = Pdf::new();
pdf.add(Object::Integer(1));
pdf.add(Object::string(
"a longer object, to move the next one along",
));
let third = pdf.add(Object::dict([("Type", Object::name("Catalog"))]));
if let Object::Reference(number) = third {
pdf.set_catalog(number);
}
let bytes = pdf.finish();
let text = String::from_utf8_lossy(&bytes);
assert!(bytes.starts_with(b"%PDF-1.7\n"), "{text}");
assert!(bytes.ends_with(b"%%EOF\n"), "{text}");
assert!(text.contains("/Root 3 0 R"), "{text}");
assert!(text.contains("/Size 6"), "{text}");
assert_eq!(text.matches(" 0 obj\n").count(), 2, "{text}");
let at = text.rfind("startxref\n").expect("a startxref");
let start: usize = text[at + 10..]
.lines()
.next()
.expect("an offset")
.trim()
.parse()
.expect("a number");
assert!(bytes[start..].starts_with(b"5 0 obj\n"), "{text}");
let dict =
String::from_utf8_lossy(&bytes[start..(start + 200).min(bytes.len())]).into_owned();
assert!(dict.contains("/Type /XRef"), "{dict}");
assert!(dict.contains("/W [ 1 2 1 ]"), "{dict}");
let table = inflated_stream(&bytes, start);
assert_eq!(table.len(), 6 * 4, "six entries of four bytes");
let entry = |number: usize| {
let row = &table[number * 4..number * 4 + 4];
(
row[0] as usize,
(row[1] as usize) << 8 | row[2] as usize,
row[3] as usize,
)
};
assert_eq!(entry(0), (0, 0, 255), "object zero heads the free list");
for number in 1..=3 {
assert_eq!(
entry(number),
(2, 4, number - 1),
"object {number} is not packed where the table says"
);
}
assert_eq!(entry(5), (1, start, 0), "the table's own entry");
let (kind, offset, _) = entry(4);
assert_eq!(kind, 1, "an object stream cannot be inside one");
assert!(bytes[offset..].starts_with(b"4 0 obj\n"), "{text}");
let head =
String::from_utf8_lossy(&bytes[offset..(offset + 200).min(bytes.len())]).into_owned();
assert!(head.contains("/Type /ObjStm"), "{head}");
assert!(head.contains("/N 3"), "{head}");
let data = inflated_stream(&bytes, offset);
let first: usize = head
.split("/First ")
.nth(1)
.expect("a /First")
.chars()
.take_while(char::is_ascii_digit)
.collect::<String>()
.parse()
.expect("a number");
let plain = String::from_utf8_lossy(&data).into_owned();
let pairs: Vec<usize> = plain[..first]
.split_whitespace()
.map(|word| word.parse().expect("a number"))
.collect();
assert_eq!(pairs.len(), 6, "three objects, each a number and an offset");
for (i, want) in ["1", "(a longer", "<< /Type /Catalog >>"]
.iter()
.enumerate()
{
assert_eq!(pairs[i * 2], i + 1, "the objects are in order");
let at = first + pairs[i * 2 + 1];
assert!(
plain[at..].starts_with(want),
"object {} is not at {at}: {:?}",
i + 1,
&plain[at..(at + 24).min(plain.len())]
);
}
}
fn inflated_stream(pdf: &[u8], start: usize) -> Vec<u8> {
let at = find(&pdf[start..], b"stream\n").expect("a stream") + start + 7;
let end = find(&pdf[at..], b"\nendstream").expect("an endstream") + at;
let mut out = Vec::new();
std::io::Read::read_to_end(&mut flate2::read::ZlibDecoder::new(&pdf[at..end]), &mut out)
.expect("the stream inflates");
out
}
#[test]
fn a_page_holds_its_text_and_its_fonts() {
let mut page = Page::letter();
page.text("Helvetica", 12.0, 72.0, 700.0, "Hello (world)");
page.text("Helvetica", 12.0, 72.0, 680.0, "again");
page.text("Times-Roman", 10.0, 72.0, 660.0, "and again");
page.rule(72.0, 650.0, 100.0, 1.0);
assert_eq!(page.fonts.len(), 2);
assert_eq!(
page.fonts[0],
(
"F1".to_string(),
Font::Base14("Helvetica".to_string()).into()
)
);
assert_eq!(page.content.matches("/F1").count(), 2);
assert!(
page.content.contains("(Hello \\(world\\)) Tj"),
"{}",
page.content
);
assert!(
page.content.contains("72 650 100 1 re f"),
"{}",
page.content
);
}
#[test]
fn unpacking_gives_back_every_object_the_file_holds() {
let mut first = Page::letter();
first.text("Helvetica", 12.0, 72.0, 700.0, "one");
let mut second = Page::letter();
second.text("Times-Roman", 12.0, 72.0, 700.0, "two");
let bytes = document(&[first, second]);
let plain = String::from_utf8_lossy(&unpacked(&bytes)).into_owned();
let numbers: Vec<u32> = plain
.match_indices(" 0 obj\n")
.filter_map(|(at, _)| plain[..at].rsplit('\n').next()?.parse().ok())
.collect();
let mut sorted = numbers.clone();
sorted.sort_unstable();
sorted.dedup();
assert_eq!(sorted.len(), numbers.len(), "an object came back twice");
assert_eq!(
sorted,
vec![1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13],
"{plain}"
);
assert!(!plain.contains("/Type /ObjStm"), "{plain}");
assert_eq!(plain.matches("/Type /Page ").count(), 2, "{plain}");
assert_eq!(plain.matches("/Type /Pages").count(), 1, "{plain}");
let catalog = plain
.split("endobj")
.find(|body| body.contains("/Type /Catalog"))
.expect("a catalogue");
let tree = number_after(catalog, "/Pages ").expect("a reference");
let body = plain
.split("endobj")
.find(|body| body.contains(&format!("\n{tree} 0 obj\n")))
.unwrap_or_else(|| panic!("object {tree} did not come back: {plain}"));
assert!(body.contains("/Type /Pages"), "{body}");
}
}