use alloc::string::{String, ToString};
use alloc::vec::Vec;
use alloc::collections::BTreeMap;
use crate::document::Document;
use crate::encoding::Encoding;
use crate::error::{Error, Result};
use crate::lexer::Token;
use crate::object::{Dictionary, Object};
use crate::page::Page;
use crate::page::Rect;
use crate::parser::Parser;
const WORD_GAP: f64 = 200.0;
const LINE_TOLERANCE: f64 = 0.01;
#[derive(Debug, Default)]
struct Line {
x: f64,
y: f64,
text: String,
matrix: Matrix,
size: f64,
advance: f64,
advances: Vec<f64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
struct Matrix {
a: f64,
b: f64,
c: f64,
d: f64,
e: f64,
f: f64,
}
impl Matrix {
const IDENTITY: Self = Self {
a: 1.0,
b: 0.0,
c: 0.0,
d: 1.0,
e: 0.0,
f: 0.0,
};
fn multiply(self, other: Self) -> Self {
Self {
a: self.a * other.a + self.b * other.c,
b: self.a * other.b + self.b * other.d,
c: self.c * other.a + self.d * other.c,
d: self.c * other.b + self.d * other.d,
e: self.e * other.a + self.f * other.c + other.e,
f: self.e * other.b + self.f * other.d + other.f,
}
}
fn apply(self, x: f64, y: f64) -> (f64, f64) {
(
self.a * x + self.c * y + self.e,
self.b * x + self.d * y + self.f,
)
}
}
#[derive(Debug, Clone)]
pub(crate) enum CodeMap {
ToUnicode(crate::cmap::ToUnicode),
Predefined(crate::cmap::Predefined),
}
impl CodeMap {
fn text(&self, code: u32, length: u8) -> Option<alloc::string::String> {
match self {
Self::ToUnicode(map) => map.text(code, length).map(alloc::borrow::ToOwned::to_owned),
Self::Predefined(map) => map.text(code, length).map(|text| {
let mut buffer = alloc::string::String::new();
buffer.push(text);
buffer
}),
}
}
fn code_lengths(&self) -> &[u8] {
match self {
Self::ToUnicode(map) => map.code_lengths(),
Self::Predefined(map) => map.code_lengths(),
}
}
fn max_code_length(&self) -> u8 {
match self {
Self::ToUnicode(map) => map.max_code_length(),
Self::Predefined(map) => map.max_code_length(),
}
}
}
#[derive(Debug, Clone, Default)]
struct Widths {
default: f64,
runs: Vec<(u32, u32, Vec<f64>)>,
}
impl Widths {
fn width(&self, cid: u32) -> f64 {
for (first, last, widths) in &self.runs {
if cid >= *first && cid <= *last {
let index = usize::try_from(cid - first).unwrap_or(usize::MAX);
if let Some(width) = widths.get(index) {
return *width;
}
}
}
self.default
}
}
#[derive(Debug, Clone)]
enum Font {
Simple {
encoding: Encoding,
widths: Option<SimpleWidths>,
},
Composite {
map: CodeMap,
widths: Widths,
},
}
impl Font {
fn pieces(&self, bytes: &[u8]) -> (String, Vec<(usize, f64)>) {
match self {
Self::Simple { encoding, widths } => {
let mut text = String::with_capacity(bytes.len());
let mut pieces = Vec::with_capacity(bytes.len());
for code in bytes {
let Some(character) = encoding.character(*code) else {
continue;
};
text.push(character);
let em = widths
.as_ref()
.and_then(|widths| widths.advance(*code))
.unwrap_or(0.0);
pieces.push((1, em));
}
(text, pieces)
}
Self::Composite { map, widths } => {
let mut text = String::new();
let mut pieces = Vec::new();
let lengths = map.code_lengths();
let narrowest = lengths.first().map_or(1, |length| usize::from(*length));
let widest = usize::from(map.max_code_length());
let mut position = 0;
while position < bytes.len() {
let mut consumed = 0;
let mut width = if lengths.len() == 1 {
narrowest
} else {
widest
};
while width >= narrowest {
if position + width <= bytes.len() {
let code = pack(&bytes[position..position + width]);
let matched = lengths.len() == 1
|| map.text(code, u8::try_from(width).unwrap_or(2)).is_some();
if matched {
consumed = width;
break;
}
}
if width == narrowest {
break;
}
width -= 1;
}
if consumed == 0 {
if position + narrowest > bytes.len() {
break;
}
position += narrowest;
continue;
}
let code = pack(&bytes[position..position + consumed]);
let piece = map
.text(code, u8::try_from(consumed).unwrap_or(2))
.unwrap_or_default();
let characters = piece.chars().count();
text.push_str(&piece);
pieces.push((characters, widths.width(code) / 1000.0));
position += consumed;
}
(text, pieces)
}
}
}
fn decode(&self, bytes: &[u8]) -> (String, f64) {
match self {
Self::Simple { encoding, widths } => {
let text = bytes
.iter()
.filter_map(|code| encoding.character(*code))
.collect();
let advance: f64 = if let Some(widths) = widths {
bytes.iter().filter_map(|code| widths.advance(*code)).sum()
} else {
0.0
};
(text, advance)
}
Self::Composite { map, widths } => {
let mut text = String::new();
let mut advance = 0.0;
let lengths = map.code_lengths();
let narrowest = lengths.first().map_or(1, |length| usize::from(*length));
let widest = usize::from(map.max_code_length());
let mut position = 0;
while position < bytes.len() {
let mut consumed = 0;
let mut width = if lengths.len() == 1 {
narrowest
} else {
widest
};
while width >= narrowest {
if position + width <= bytes.len() {
let code = pack(&bytes[position..position + width]);
let matched = lengths.len() == 1
|| map.text(code, u8::try_from(width).unwrap_or(2)).is_some();
if matched {
consumed = width;
break;
}
}
if width == narrowest {
break;
}
width -= 1;
}
if consumed == 0 {
if position + narrowest > bytes.len() {
break;
}
position += narrowest;
continue;
}
let code = pack(&bytes[position..position + consumed]);
if let Some(mapped) = map.text(code, u8::try_from(consumed).unwrap_or(2)) {
text.push_str(&mapped);
}
advance += widths.width(code) / 1000.0;
position += consumed;
}
(text, advance)
}
}
}
fn tracks_advances(&self) -> bool {
matches!(self, Self::Composite { .. })
}
}
#[derive(Debug, Clone, Default, PartialEq)]
struct SimpleWidths {
first: i64,
widths: Vec<f64>,
missing: f64,
}
impl SimpleWidths {
fn advance(&self, code: u8) -> Option<f64> {
let index = i64::from(code) - self.first;
let width = usize::try_from(index)
.ok()
.and_then(|index| self.widths.get(index))
.copied()
.or_else(|| (self.missing > 0.0).then_some(self.missing))?;
Some(width / 1000.0)
}
}
fn pack(bytes: &[u8]) -> u32 {
bytes
.iter()
.fold(0_u32, |value, &byte| (value << 8) | u32::from(byte))
}
struct TextInterpreter<'a> {
document: &'a Document,
resources: Option<Dictionary>,
fonts: BTreeMap<Vec<u8>, Font>,
font: Option<Font>,
leading: f64,
size: f64,
line_x: f64,
line_y: f64,
pen_x: f64,
pen_tracked: bool,
lines: Vec<Line>,
ctm: Matrix,
ctm_stack: Vec<Matrix>,
text_matrix: Matrix,
captures: Vec<Option<Capture>>,
positions: bool,
}
struct Capture {
line: Option<usize>,
offset: usize,
text: String,
}
impl<'a> TextInterpreter<'a> {
fn new(document: &'a Document, resources: Option<Dictionary>) -> Self {
Self {
document,
resources,
fonts: BTreeMap::new(),
font: None,
leading: 0.0,
size: 0.0,
line_x: 0.0,
line_y: 0.0,
pen_x: 0.0,
pen_tracked: false,
lines: Vec::new(),
ctm: Matrix::IDENTITY,
ctm_stack: Vec::new(),
text_matrix: Matrix::IDENTITY,
captures: Vec::new(),
positions: false,
}
}
fn with_positions(mut self) -> Self {
self.positions = true;
self
}
fn run(mut self, content: &[u8]) -> Result<Vec<Line>> {
let mut parser = Parser::new(content);
let mut operands: Vec<Object> = Vec::new();
loop {
match parser.peek_token()? {
Token::Eof => break,
Token::Keyword(_) => {
let keyword = match parser.next_token()? {
Token::Keyword(keyword) => keyword,
_ => return Err(Error::malformed("content-stream operator")),
};
self.execute(&keyword, &mut operands, &mut parser)?;
operands.clear();
}
_ => {
let object = parser.parse_object()?;
operands.push(object);
}
}
}
Ok(self.ordered_lines())
}
fn ordered_lines(mut self) -> Vec<Line> {
self.lines.retain(|line| !line.text.is_empty());
self.lines.sort_by(|left, right| {
right
.y
.partial_cmp(&left.y)
.unwrap_or(core::cmp::Ordering::Equal)
.then(
left.x
.partial_cmp(&right.x)
.unwrap_or(core::cmp::Ordering::Equal),
)
});
self.lines
}
fn line(&mut self) -> &mut Line {
if let Some(index) = self
.lines
.iter()
.position(|line| difference(line.y, self.line_y) <= LINE_TOLERANCE)
{
return &mut self.lines[index];
}
self.lines.push(Line {
x: self.line_x,
y: self.line_y,
text: String::new(),
matrix: self.text_matrix.multiply(self.ctm),
size: self.size,
advance: 0.0,
advances: Vec::new(),
});
#[allow(clippy::unwrap_used)]
self.lines.last_mut().unwrap()
}
fn enter_marked(&mut self, properties: Option<&Object>) -> Result<()> {
let mut capture = None;
if let Some(properties) = properties {
let resolved = self
.document
.resolve(Some(properties))?
.unwrap_or(Object::Null);
if let Object::Dictionary(dict) = resolved
&& let Some(Object::String(text)) = dict.get(b"ActualText")
{
capture = Some(Capture {
line: None,
offset: 0,
text: String::from_utf8_lossy(text.as_bytes()).into_owned(),
});
}
}
self.captures.push(capture);
Ok(())
}
fn leave_marked(&mut self) {
let Some(capture) = self.captures.pop().flatten() else {
return;
};
let Some(index) = capture.line else {
return;
};
let Some(line) = self.lines.get_mut(index) else {
return;
};
let at = char_to_byte(&line.text, capture.offset);
line.text.insert_str(at, &capture.text);
}
fn execute(
&mut self,
operator: &[u8],
operands: &mut [Object],
parser: &mut Parser<'_>,
) -> Result<()> {
match operator {
b"BT" => {
self.line_x = 0.0;
self.line_y = 0.0;
}
b"ET" => {}
b"Tf" => {
let name = match operands.first() {
Some(Object::Name(name)) => name.clone(),
_ => return Err(Error::malformed("/Tf needs a font name")),
};
self.size = number(operands.get(1));
self.font = Some(self.load_font(&name)?);
self.pen_tracked = self.font.as_ref().is_some_and(Font::tracks_advances);
self.pen_x = self.line_x;
}
b"Td" | b"TD" => {
let tx = number(operands.first());
let ty = number(operands.get(1));
let previous_y = self.line_y;
self.line_x += tx;
self.line_y += ty;
self.text_matrix = Matrix {
e: self.text_matrix.e + tx * self.text_matrix.a + ty * self.text_matrix.c,
f: self.text_matrix.f + tx * self.text_matrix.b + ty * self.text_matrix.d,
..self.text_matrix
};
if difference(previous_y, self.line_y) > LINE_TOLERANCE {
self.pen_x = self.line_x;
}
if operator == b"TD" {
self.leading = -ty;
}
}
b"T*" => {
self.line_y -= self.leading;
self.pen_x = self.line_x;
self.text_matrix = Matrix {
e: self.text_matrix.e - self.leading * self.text_matrix.c,
f: self.text_matrix.f - self.leading * self.text_matrix.d,
..self.text_matrix
};
}
b"TL" => {
self.leading = number(operands.first());
}
b"q" => self.ctm_stack.push(self.ctm),
b"Q" => {
if let Some(saved) = self.ctm_stack.pop() {
self.ctm = saved;
}
}
b"cm" => {
let matrix = Matrix {
a: number(operands.first()),
b: number(operands.get(1)),
c: number(operands.get(2)),
d: number(operands.get(3)),
e: number(operands.get(4)),
f: number(operands.get(5)),
};
self.ctm = self.ctm.multiply(matrix);
}
b"Tm" => {
self.text_matrix = Matrix {
a: number(operands.first()),
b: number(operands.get(1)),
c: number(operands.get(2)),
d: number(operands.get(3)),
e: number(operands.get(4)),
f: number(operands.get(5)),
};
let previous_y = self.line_y;
self.line_x = number(operands.get(4));
self.line_y = number(operands.get(5));
if difference(previous_y, self.line_y) > LINE_TOLERANCE {
self.pen_x = self.line_x;
}
}
b"Tc" | b"Tw" | b"Tz" | b"Ts" => {}
b"Tj" => {
if let Some(Object::String(string)) = operands.first() {
self.show(string.as_bytes());
}
}
b"'" => {
self.line_y -= self.leading;
self.pen_x = self.line_x;
if let Some(Object::String(string)) = operands.first() {
self.show(string.as_bytes());
}
}
b"\"" => {
self.line_y -= self.leading;
self.pen_x = self.line_x;
if let Some(Object::String(string)) = operands.get(2) {
self.show(string.as_bytes());
}
}
b"TJ" => {
if let Some(Object::Array(items)) = operands.first() {
for item in items {
match item {
Object::String(string) => self.show(string.as_bytes()),
Object::Integer(adjustment) => self.adjust(*adjustment as f64),
Object::Real(adjustment) => self.adjust(*adjustment),
_ => return Err(Error::malformed("unsupported /TJ array entry")),
}
}
}
}
b"BDC" | b"BMC" => {
let properties = if operator == b"BDC" {
operands.get(1)
} else {
None
};
self.enter_marked(properties)?;
}
b"EMC" => self.leave_marked(),
b"BI" => {
skip_inline_image(parser)?;
}
_ => {}
}
Ok(())
}
fn adjust(&mut self, adjustment: f64) {
if -adjustment < WORD_GAP {
return;
}
let space = (-adjustment / 1000.0 * self.size).max(0.0);
let line = self.line();
if !line.text.is_empty() && !line.text.ends_with(' ') {
line.text.push(' ');
line.advances.push(space);
}
if self.pen_tracked {
self.pen_x -= adjustment / 1000.0 * self.size;
}
}
fn show(&mut self, bytes: &[u8]) {
let Some(font) = &self.font else {
return;
};
let pieces = if self.positions {
Some(font.pieces(bytes))
} else {
None
};
let (run, advance) = match &pieces {
Some((text, pieces)) => (text.clone(), pieces.iter().map(|(_, em)| em).sum()),
None => font.decode(bytes),
};
let gap =
self.pen_tracked && self.size > 0.0 && self.line_x > self.pen_x + 0.25 * self.size;
let inside_has_line = self
.captures
.iter()
.rev()
.find_map(|capture| capture.as_ref())
.is_some_and(|capture| capture.line.is_some());
let capturing = self
.captures
.iter()
.rev()
.find_map(|capture| capture.as_ref())
.is_some();
if capturing {
self.line();
let index = self.lines.len() - 1;
let offset = self.lines[index].text.len();
if !inside_has_line
&& let Some(slot) = self
.captures
.iter_mut()
.rev()
.find_map(|capture| capture.as_mut())
{
slot.line = Some(index);
slot.offset = offset;
}
if self.pen_tracked {
self.pen_x = self.line_x + advance * self.size;
}
return;
}
let gap_width = (self.line_x - self.pen_x).max(0.0);
let line = self.line();
if gap && !line.text.is_empty() && !line.text.ends_with(' ') {
line.text.push(' ');
line.advances.push(gap_width);
}
line.text.push_str(&run);
if let Some((_, pieces)) = &pieces
&& advance > 0.0
&& let Some(line) = self.lines.last_mut()
{
for (characters, em) in pieces {
let each = em * self.size / (*characters).max(1) as f64;
line.advances
.extend(core::iter::repeat_n(each, *characters));
}
}
let tracked = self.pen_tracked;
let width = advance * self.size;
if tracked {
self.pen_x = self.line_x + width;
let start = self.line_x;
if let Some(line) = self.lines.last_mut() {
line.advance = self.pen_x - start;
}
} else if width > 0.0
&& let Some(line) = self.lines.last_mut()
{
line.advance = width;
}
}
fn load_font(&mut self, name: &[u8]) -> Result<Font> {
if let Some(font) = self.fonts.get(name) {
return Ok(font.clone());
}
let font = self.read_font(name)?;
self.fonts.insert(name.to_vec(), font.clone());
Ok(font)
}
fn read_font(&self, name: &[u8]) -> Result<Font> {
let font = match self
.resources
.as_ref()
.and_then(|resources| resources.get(b"Font"))
{
Some(fonts) => {
let fonts = self.document.resolve(Some(fonts))?.unwrap_or(Object::Null);
match fonts {
Object::Dictionary(fonts) => fonts.get(name).cloned(),
_ => None,
}
}
None => None,
};
let Some(font) = font else {
return Err(Error::Malformed {
what: "content stream selects a font the page does not declare",
offset: None,
});
};
let font = self.document.resolve(Some(&font))?.unwrap_or(Object::Null);
let Object::Dictionary(dict) = font else {
return Err(Error::Malformed {
what: "font resource is not a dictionary",
offset: None,
});
};
if let Some(Object::Name(subtype)) = dict.get(b"Subtype")
&& subtype == b"Type0"
{
return self.composite_font(&dict);
}
Ok(Font::Simple {
encoding: self.encoding_of(&dict)?,
widths: self.simple_widths(&dict)?,
})
}
fn simple_widths(&self, dict: &Dictionary) -> Result<Option<SimpleWidths>> {
let Some(entries) = dict.get(b"Widths") else {
return Ok(None);
};
let entries = self
.document
.resolve(Some(entries))?
.unwrap_or(Object::Null);
let Object::Array(entries) = entries else {
return Ok(None);
};
let first = match dict.get(b"FirstChar") {
Some(Object::Integer(first)) => *first,
_ => 0,
};
let mut widths = Vec::with_capacity(entries.len());
for entry in &entries {
let value = self.document.resolve(Some(entry))?.unwrap_or(Object::Null);
widths.push(value.as_real().unwrap_or(0.0));
}
let missing = dict
.get(b"FontDescriptor")
.map(|descriptor| self.document.resolve(Some(descriptor)))
.transpose()?
.flatten()
.and_then(|descriptor| match descriptor {
Object::Dictionary(descriptor) => descriptor.get(b"MissingWidth").cloned(),
_ => None,
})
.and_then(|value| value.as_real())
.unwrap_or(0.0);
Ok(Some(SimpleWidths {
first,
widths,
missing,
}))
}
fn composite_font(&self, dict: &Dictionary) -> Result<Font> {
match dict.get(b"Encoding") {
Some(Object::Name(name)) if name == b"Identity-H" => {}
Some(Object::Name(name)) if name == b"Identity-V" => {
return Err(Error::Unsupported {
what: "vertical composite (Type0) fonts",
});
}
Some(Object::Name(name)) => {
if let Some(predefined) = crate::cmap::Predefined::by_name(name) {
return Ok(Font::Composite {
map: CodeMap::Predefined(predefined),
widths: self.widths_of(dict)?,
});
}
return Err(Error::Unsupported {
what: "CMap-encoded composite (Type0) fonts",
});
}
Some(Object::Reference(_)) | Some(Object::Stream(_)) => {
return Err(Error::Unsupported {
what: "embedded CMap-encoded composite (Type0) fonts",
});
}
_ => {
return Err(Error::Unsupported {
what: "composite (Type0) fonts without an /Encoding",
});
}
}
let Some(to_unicode) = dict.get(b"ToUnicode") else {
return Err(Error::Unsupported {
what: "composite (Type0) fonts without a /ToUnicode map",
});
};
let Object::Reference(id) = to_unicode else {
return Err(Error::Unsupported {
what: "a direct /ToUnicode stream",
});
};
let map = crate::cmap::ToUnicode::parse(&self.document.stream_data(*id)?)?;
Ok(Font::Composite {
map: CodeMap::ToUnicode(map),
widths: self.widths_of(dict)?,
})
}
fn widths_of(&self, dict: &Dictionary) -> Result<Widths> {
let mut widths = Widths {
default: 1000.0,
runs: Vec::new(),
};
let Some(descendants) = dict.get(b"DescendantFonts") else {
return Ok(widths);
};
let descendants = self
.document
.resolve(Some(descendants))?
.unwrap_or(Object::Null);
let Object::Array(descendants) = descendants else {
return Err(Error::Malformed {
what: "/DescendantFonts must be an array",
offset: None,
});
};
let Some(first) = descendants.first() else {
return Ok(widths);
};
let first = self.document.resolve(Some(first))?.unwrap_or(Object::Null);
let Object::Dictionary(descendant) = first else {
return Ok(widths);
};
if let Some(default) = descendant.get(b"DW") {
widths.default = number(Some(default));
}
let Some(w_array) = descendant.get(b"W") else {
return Ok(widths);
};
let w_array = self
.document
.resolve(Some(w_array))?
.unwrap_or(Object::Null);
let Object::Array(items) = w_array else {
return Err(Error::Malformed {
what: "/W must be an array",
offset: None,
});
};
let mut index = 0;
while index < items.len() {
let Some(Object::Integer(first)) = items.get(index) else {
return Err(Error::Malformed {
what: "/W entries start with a CID",
offset: None,
});
};
let first = u32::try_from(*first).map_err(|_| Error::Malformed {
what: "/W CIDs must not be negative",
offset: None,
})?;
match items.get(index + 1) {
Some(Object::Array(list)) => {
let run: Vec<f64> = list.iter().map(|item| number(Some(item))).collect();
let last = first.saturating_add(
u32::try_from(run.len().saturating_sub(1)).unwrap_or(u32::MAX),
);
widths.runs.push((first, last, run));
index += 2;
}
Some(Object::Integer(last)) => {
let width = number(items.get(index + 2));
let last = u32::try_from(*last).map_err(|_| Error::Malformed {
what: "/W CIDs must not be negative",
offset: None,
})?;
widths.runs.push((first, last, alloc::vec![width]));
index += 3;
}
_ => {
return Err(Error::Malformed {
what: "/W entry is neither an array nor a range",
offset: None,
});
}
}
}
Ok(widths)
}
fn encoding_of(&self, dict: &Dictionary) -> Result<Encoding> {
let Some(encoding_object) = dict.get(b"Encoding") else {
return Ok(Encoding::standard());
};
let encoding_object = self
.document
.resolve(Some(encoding_object))?
.unwrap_or(Object::Null);
let mut encoding = Encoding::from_object(Some(&encoding_object))?;
if let Object::Dictionary(differences) = &encoding_object
&& let Some(differences) = differences.get(b"Differences")
{
let differences = self
.document
.resolve(Some(differences))?
.unwrap_or(Object::Null);
let Object::Array(items) = differences else {
return Err(Error::Malformed {
what: "/Differences must be an array",
offset: None,
});
};
encoding.apply_differences(&items)?;
}
Ok(encoding)
}
}
fn skip_inline_image(parser: &mut Parser<'_>) -> Result<()> {
let search = parser.raw_position();
let found = parser
.content()
.get(search..)
.and_then(|rest| find_operator(rest, b"EI"))
.ok_or(Error::malformed("inline image without a closing EI"))?;
parser.seek(search + found + 2);
Ok(())
}
fn find_operator(haystack: &[u8], needle: &[u8]) -> Option<usize> {
let mut index = 0;
while index + needle.len() <= haystack.len() {
if &haystack[index..index + needle.len()] == needle {
let before_ok = index == 0
|| crate::lexer::is_whitespace(haystack[index - 1])
|| crate::lexer::is_delimiter(haystack[index - 1]);
let after = index + needle.len();
let after_ok = after >= haystack.len()
|| crate::lexer::is_whitespace(haystack[after])
|| crate::lexer::is_delimiter(haystack[after]);
if before_ok && after_ok {
return Some(index);
}
}
index += 1;
}
None
}
fn difference(left: f64, right: f64) -> f64 {
if left >= right {
left - right
} else {
right - left
}
}
fn number(operand: Option<&Object>) -> f64 {
match operand {
Some(Object::Integer(value)) => *value as f64,
Some(Object::Real(value)) => *value,
_ => 0.0,
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TextSpan {
pub text: String,
pub bounds: Rect,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SearchMatch {
pub text: String,
pub line: Rect,
pub bounds: Rect,
pub start: usize,
pub end: usize,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PageMatches {
pub page: usize,
pub matches: Vec<SearchMatch>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PageHits {
pub page: usize,
pub hits: Vec<SearchHit>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SearchHit {
pub text: String,
pub bounds: Rect,
}
impl Line {
fn bounds_of(&self, start: usize, end: usize) -> Rect {
let characters = self.text.chars().count();
let end = end.min(characters);
let start = start.min(end);
let total = if self.advance > 0.0 {
self.advance
} else {
self.size * 0.5 * characters as f64
};
let x_at = |index: usize| -> f64 {
if self.advances.len() == characters && characters > 0 {
self.advances[..index].iter().sum()
} else if characters > 0 {
total * index as f64 / characters as f64
} else {
0.0
}
};
let matrix = self.matrix;
let left = x_at(start);
let right = x_at(end);
let (x0, y0) = matrix.apply(left, 0.0);
let (x1, y1) = matrix.apply(right, 0.0);
let (x2, y2) = matrix.apply(left, self.size);
let (x3, y3) = matrix.apply(right, self.size);
Rect::new(
x0.min(x1).min(x2).min(x3),
y0.min(y1).min(y2).min(y3),
x0.max(x1).max(x2).max(x3),
y0.max(y1).max(y2).max(y3),
)
}
fn bounds(&self) -> Rect {
let matrix = self.matrix;
let (x0, y0) = matrix.apply(0.0, 0.0);
let advance = if self.advance > 0.0 {
self.advance
} else {
self.size * 0.5 * self.text.chars().count() as f64
};
let (x1, y1) = matrix.apply(advance, 0.0);
let (x2, y2) = matrix.apply(0.0, self.size);
let (x3, y3) = matrix.apply(advance, self.size);
Rect::new(
x0.min(x1).min(x2).min(x3),
y0.min(y1).min(y2).min(y3),
x0.max(x1).max(x2).max(x3),
y0.max(y1).max(y2).max(y3),
)
}
}
impl Document {
pub fn extract_text(&self, page: &Page) -> Result<String> {
let content = self.page_content(page)?;
self.extract_text_from(&content, page.resources.as_ref())
}
pub fn extract_text_from(
&self,
content: &[u8],
resources: Option<&Dictionary>,
) -> Result<String> {
let lines = TextInterpreter::new(self, resources.cloned()).run(content)?;
Ok(lines
.iter()
.map(|line| line.text.as_str())
.collect::<Vec<_>>()
.join("\n"))
}
pub fn spans(&self, page: &Page) -> Result<Vec<TextSpan>> {
let content = self.page_content(page)?;
self.spans_from(&content, page.resources.as_ref())
}
pub fn search(&self, needle: &str) -> Result<Vec<PageHits>> {
let folded = needle.to_lowercase();
let mut found = Vec::new();
if folded.is_empty() {
return Ok(found);
}
for (index, page) in self.pages()?.iter().enumerate() {
let content = self.page_content(page)?;
let mut hits = Vec::new();
for span in self.spans_with_positions(&content, page.resources.as_ref())? {
let haystack = span.text.to_lowercase();
let mut from = 0;
while let Some(at) = haystack[from..].find(&folded) {
let start = from + at;
let end = start + folded.len();
let first = char_boundary(&span.text, start);
let last = char_boundary(&span.text, end);
let text = span
.text
.get(first..last)
.unwrap_or(span.text.as_str())
.to_string();
hits.push(SearchHit {
text,
bounds: span.bounds,
});
from = end;
}
}
if !hits.is_empty() {
found.push(PageHits { page: index, hits });
}
}
Ok(found)
}
pub(crate) fn spans_with_positions(
&self,
content: &[u8],
resources: Option<&Dictionary>,
) -> Result<Vec<TextSpan>> {
let lines = TextInterpreter::new(self, resources.cloned())
.with_positions()
.run(content)?;
Ok(lines
.into_iter()
.map(|line| TextSpan {
bounds: line.bounds(),
text: line.text,
})
.collect())
}
pub fn search_matches(&self, needle: &str) -> Result<Vec<PageMatches>> {
let folded_needle = needle.to_lowercase();
let mut found = Vec::new();
if folded_needle.is_empty() {
return Ok(found);
}
for (index, page) in self.pages()?.iter().enumerate() {
let content = self.page_content(page)?;
let lines = TextInterpreter::new(self, page.resources.clone())
.with_positions()
.run(&content)?;
let mut matches = Vec::new();
for line in &lines {
let (folded, origin) = fold_with_origin(&line.text);
let mut from = 0;
while let Some(at) = folded[from..].find(&folded_needle) {
let start = from + at;
let end = start + folded_needle.len();
let first = origin[start];
let last = origin[end - 1] + 1;
matches.push(SearchMatch {
text: line.text.chars().skip(first).take(last - first).collect(),
line: line.bounds(),
bounds: line.bounds_of(first, last),
start: first,
end: last,
});
from = end;
}
}
if !matches.is_empty() {
found.push(PageMatches {
page: index,
matches,
});
}
}
Ok(found)
}
pub fn spans_from(
&self,
content: &[u8],
resources: Option<&Dictionary>,
) -> Result<Vec<TextSpan>> {
let lines = TextInterpreter::new(self, resources.cloned()).run(content)?;
Ok(lines
.into_iter()
.map(|line| TextSpan {
bounds: line.bounds(),
text: line.text,
})
.collect())
}
}
fn fold_with_origin(text: &str) -> (String, Vec<usize>) {
let mut folded = String::with_capacity(text.len());
let mut origin = Vec::with_capacity(text.len());
for (index, character) in text.chars().enumerate() {
for lowered in character.to_lowercase() {
let before = folded.len();
folded.push(lowered);
origin.extend(core::iter::repeat_n(index, folded.len() - before));
}
}
(folded, origin)
}
fn char_to_byte(text: &str, characters: usize) -> usize {
text.char_indices()
.nth(characters)
.map_or(text.len(), |(at, _)| at)
}
fn char_boundary(text: &str, offset: usize) -> usize {
let mut at = offset.min(text.len());
while at > 0 && !text.is_char_boundary(at) {
at -= 1;
}
at
}
#[cfg(test)]
mod tests {
use super::find_operator;
#[test]
fn inline_image_terminator_must_be_a_whole_operator() {
assert_eq!(find_operator(b"abc EI more", b"EI"), Some(4));
assert_eq!(find_operator(b"EI", b"EI"), Some(0));
assert_eq!(
find_operator(b"tailEIx", b"EI"),
None,
"EI inside a word is not the operator"
);
assert_eq!(find_operator(b"no terminator", b"EI"), None);
}
}
#[cfg(test)]
mod width_tests {
use super::{Font, SimpleWidths};
use crate::encoding::Encoding;
fn widths(first: i64, values: &[f64], missing: f64) -> SimpleWidths {
SimpleWidths {
first,
widths: values.to_vec(),
missing,
}
}
#[test]
fn a_code_takes_its_width_from_the_table_and_the_rest_from_missing_width() {
let table = widths(65, &[500.0, 1000.0], 250.0);
assert_eq!(table.advance(b'A'), Some(0.5), "the first entry is code 65");
assert_eq!(table.advance(b'B'), Some(1.0));
assert_eq!(
table.advance(b'C'),
Some(0.25),
"past the array: /MissingWidth"
);
assert_eq!(table.advance(b'@'), Some(0.25), "before the array too");
let without = widths(65, &[500.0], 0.0);
assert_eq!(without.advance(b'Z'), None, "no width, no guess");
}
#[test]
fn a_simple_font_reports_one_advance_per_code_it_states() {
let font = Font::Simple {
encoding: Encoding::win_ansi(),
widths: Some(widths(65, &[500.0, 600.0], 0.0)),
};
let (text, pieces) = font.pieces(b"AB");
assert_eq!(text, "AB");
assert_eq!(pieces.len(), 2);
assert_eq!(pieces[0].0, 1, "one character per code");
assert!((pieces[0].1 - 0.5).abs() < 1e-9);
assert!((pieces[1].1 - 0.6).abs() < 1e-9);
let (text, advance) = font.decode(b"AB");
assert_eq!(text, "AB");
assert!(
(advance - 1.1).abs() < 1e-9,
"the total is the entries' sum"
);
}
fn document(objects: &[(u32, &str)]) -> crate::Document {
let mut out = b"%PDF-2.0\n".to_vec();
let mut offsets = Vec::new();
for (number, body) in objects {
offsets.push((*number, out.len()));
out.extend_from_slice(format!("{number} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref = out.len();
out.extend_from_slice(b"xref\n");
for (number, offset) in &offsets {
out.extend_from_slice(format!("{number} 1\n{offset:010} 00000 n \n").as_bytes());
}
let size = objects.iter().map(|(number, _)| *number).max().unwrap_or(0) + 1;
out.extend_from_slice(format!("trailer\n<< /Size {size} /Root 1 0 R >>\n").as_bytes());
out.extend_from_slice(format!("startxref\n{xref}\n%%EOF\n").as_bytes());
crate::Document::open(out).expect("the test document opens")
}
#[test]
fn a_run_keeps_one_advance_per_character_when_asked() {
let content = "BT /F1 10 Tf 10 10 Td (AB) Tj ET";
let document = document(&[
(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 200 200] /Contents 4 0 R \
/Resources << /Font << /F1 5 0 R >> >> >>",
),
(
4,
&format!(
"<< /Length {} >>\nstream\n{content}\nendstream",
content.len()
),
),
(
5,
"<< /Type /Font /Subtype /Type1 /BaseFont /X /Encoding /WinAnsiEncoding \
/FirstChar 65 /Widths [500 1000] >>",
),
]);
let page = document.page(0).expect("page");
let lines = super::TextInterpreter::new(&document, page.resources.clone())
.with_positions()
.run("BT /F1 10 Tf 10 10 Td (AB) Tj ET".as_bytes())
.expect("the content runs");
let line = lines.first().expect("one line");
assert_eq!(line.text, "AB");
assert_eq!(line.advances.len(), 2, "one advance per character");
assert!((line.advances[0] - 5.0).abs() < 1e-9, "0.5 em of 10 pt");
assert!((line.advances[1] - 10.0).abs() < 1e-9, "1 em of 10 pt");
assert!((line.advance - 15.0).abs() < 1e-9, "and the line's total");
}
#[test]
fn offsets_survive_a_character_whose_lowercase_is_longer() {
let (folded, origin) = super::fold_with_origin("İstanbul");
assert!(folded.starts_with("i\u{307}stanbul"), "folded: {folded}");
let at = folded.find("stan").expect("the needle folds in");
let first = origin[at];
let last = origin[at + 3];
assert_eq!(
(first, last),
(1, 4),
"the characters 'stan' in the original"
);
let taken: String = "İstanbul"
.chars()
.skip(first)
.take(last + 1 - first)
.collect();
assert_eq!(
taken, "stan",
"and the offsets name exactly those characters"
);
}
#[test]
fn a_simple_font_without_widths_still_reads_its_text_and_no_advance() {
let font = Font::Simple {
encoding: Encoding::win_ansi(),
widths: None,
};
let (text, advance) = font.decode(b"Hi");
assert_eq!(text, "Hi");
assert_eq!(advance, 0.0, "the caller's estimate applies");
}
}