PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
refactor(edit): split text.rs into text/
aiongg157cbf3a9dba
diff --git a/crates/edit/src/text.rs b/crates/edit/src/text.rsindex 55f2e7ad1..eb4520935 100644--- a/crates/edit/src/text.rs+++ b/crates/edit/src/text.rs@@ -27,6 +27,40 @@ mod session;use regions::{group_blocks, is_centred, rewrite_styled_block};pub use session::TextSession;+mod blocks;+mod editor;+mod fallback;+mod interp;+mod lines;+mod rewrite;++use blocks::paragraph_separator;+#[cfg(test)]+use blocks::wrap;+pub use blocks::{+ BlockKey, BlockStyle, RangeStyle, ReadingBlocks, TextBlock, block_overlapping, clear_block, reading_blocks, reading_blocks_checked,+ replace_block, text_blocks,+};+use editor::layout_draft;+pub use editor::{TextEditLayout, TextEditorFont, register_text_font, text_edit_layout, text_editor_fonts};+#[cfg(test)]+pub(crate) use fallback::SOURCE_SPACE_CALLS;+use fallback::{+ MAX_TYPE3_GLYPHS, Type3Glyph, fallback_face, needs_type3, no_fallback_font, no_glyph_for, same_base_font, same_font, source_encodes,+ source_family, source_program, source_show, source_space, source_width, strip_subset_tag, type3_faces, type3_glyph, write_type3_glyphs,+};+#[cfg(test)]+use fallback::{add_type3_font, is_type3_fallback};+use interp::{Origin, Paint, union};+use lines::page_dict;+pub(crate) use lines::{FormBudget, content_streams, content_streams_within, form_call, rewritten_contents, splice};+pub use lines::{MAX_FORM_DEPTH, MAX_FORM_VISITS, glyph_text_lines, text_lines};+pub use rewrite::{LineEdit, replace_line, rewrite_block};+use rewrite::{coincident_ops, rewrite_block_from};+#[cfg(test)]+pub(crate) use rewrite::{replace_line_with_limit, rewrite_block_with_limit};+pub(crate) use rewrite::{reveal_ops, selectable_blocks, translate_blocks};+/// One line of existing text.#[derive(Clone, Debug, PartialEq)]pub struct TextLine {@@ -103,3426 +137,6 @@ impl TextLine {}}-/// An embedded sfnt source face, read only for the inline editor. Bytes stay in memory and-/// are never installed, copied into assets, or used as a font for another document.-#[derive(Clone, Debug)]-pub struct TextEditorFont {- pub resource: String,- pub face: String,- pub bytes: Vec<u8>,-}--pub fn text_editor_fonts(doc: &Document, page: usize) -> Result<Vec<TextEditorFont>, EditError> {- let p = page_dict(doc, page)?;- let resources = p.dict.get(b"Resources").and_then(|o| doc.dict(o)).unwrap_or_default();- let fonts = resources.get(b"Font").and_then(|o| doc.dict(o)).unwrap_or_default();- let mut budget = 32_usize << 20;- // Every program decoded counts, usable or not, so aliases of one program can't repeat the work.- let mut decode = DecodeBudget::new(2 * budget, 0);- let mut result = Vec::new();- for (name, font) in fonts.iter().take(128) {- let Some(font) = doc.dict(font) else { continue };- let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt_within(doc, &font, &mut decode) else { continue };- if bytes.len() > budget {- continue;- }- budget -= bytes.len();- result.push(TextEditorFont {- resource: String::from_utf8_lossy(name).into_owned(),- face: Metrics::from_dict(doc, &font).base_font.rsplit('+').next().unwrap_or_default().to_owned(),- bytes,- });- }- // The approved full face follows all source subsets in the editor's font stack. It can- // display newly inserted glyphs before Apply without changing the source text's face.- let source_faces: Vec<_> = result.iter().map(|p| p.face.clone()).collect();- for face in source_faces {- for full in pdfcraft_fonts::embedding::matching_faces(&face) {- if full.bytes.len() > budget || result.iter().any(|p| p.resource == format!("PCApproved{}", full.name())) {- continue;- }- budget -= full.bytes.len();- result.push(TextEditorFont { resource: format!("PCApproved{}", full.name()), face: face.clone(), bytes: full.bytes.to_vec() });- }- }- Ok(result)-}--/// Load an explicit full face into this page's resources. Nothing on the page is replaced;-/// the new resource can complete matching source subsets or be chosen in a text style.-pub fn register_text_font(doc: &mut Document, page: usize, bytes: &[u8]) -> Result<String, EditError> {- pdfcraft_fonts::embedding::validate_document_input(bytes).map_err(EditError::Invalid)?;- let (_, postscript) = pdfcraft_fonts::embedding::names(bytes).map_err(EditError::Invalid)?;- let p = page_dict(doc, page)?;- let mut resources = p.dict.get(b"Resources").and_then(|o| doc.dict(o)).unwrap_or_default();- let mut fonts = resources.get(b"Font").and_then(|o| doc.dict(o)).unwrap_or_default();- let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, bytes, &postscript).map_err(EditError::Invalid)?;- resources.set(b"Font".to_vec(), Object::Dict(fonts));- doc.update_dict(p.obj, |d| d.set(b"Resources".to_vec(), Object::Dict(resources)))?;- Ok(name)-}--/// Read-only draft bounds, measured with the same PDF rewrite used by Apply/Save.-#[derive(Clone, Debug, PartialEq)]-pub struct TextEditLayout {- pub source_rect: [f64; 4],- pub draft_rect: Option<[f64; 4]>,- pub overflow: bool,-}--pub fn text_edit_layout(doc: &Document, page: usize, block: usize, text: &str, style: &BlockStyle) -> Result<TextEditLayout, EditError> {- TextSession::open(doc, page, block)?.layout(text, style)-}--/// A draft of paragraph `source` (number `block` among the page's `lines`) laid out by the rewrite-/// Apply runs, on a copy of `doc`.-fn layout_draft(- doc: &Document,- page: usize,- lines: &[TextLine],- source: &TextBlock,- block: usize,- text: &str,- style: &BlockStyle,-) -> Result<TextEditLayout, EditError> {- if text == source.editor_text && *style == BlockStyle::default() {- return Ok(TextEditLayout { source_rect: source.rect, draft_rect: Some(source.rect), overflow: false });- }- // Subtract the untouched runs by value, rather than by operator offsets: a rewrite may- // split BT/ET or add font resources. A multiset also handles coincident repeated text.- let key =- |line: &TextLine| (line.text.clone(), line.font.clone(), line.rect.map(f64::to_bits), line.size.to_bits(), line.color.map(f64::to_bits));- let mut untouched = std::collections::BTreeMap::new();- for (index, line) in lines.iter().enumerate() {- if !source.lines.contains(&index) {- *untouched.entry(key(line)).or_insert(0_usize) += 1;- }- }- let mut draft = doc.clone();- rewrite_block_from(&mut draft, page, lines.to_vec(), block, Some(text), style, MAX_TYPE3_GLYPHS)?;- let mut rect: Option<[f64; 4]> = None;- for line in text_lines(&draft, page)? {- if let Some(count) = untouched.get_mut(&key(&line))- && *count > 0- {- *count -= 1;- continue;- }- // Spaces typed after a row's last word are drawn but show nothing, so an upright row is- // measured to the end of its last word: they don't make a draft overflow (#4199).- let mut r = line.rect;- if line.upright() && !line.ink.is_empty() {- if crate::bidi::rtl_base(&line.text) {- r[0] = r[0].max(line.ink.iter().map(|i| i[0]).fold(f64::INFINITY, f64::min));- } else {- r[2] = r[2].min(line.ink.iter().map(|i| i[2]).fold(f64::NEG_INFINITY, f64::max));- }- }- rect = Some(rect.map_or(r, |a| [a[0].min(r[0]), a[1].min(r[1]), a[2].max(r[2]), a[3].max(r[3])]));- }- let overflow = rect- .is_some_and(|r| r[0] < source.rect[0] - 0.5 || r[1] < source.rect[1] - 0.5 || r[2] > source.rect[2] + 0.5 || r[3] > source.rect[3] + 0.5);- Ok(TextEditLayout { source_rect: source.rect, draft_rect: rect, overflow })-}--/// Text and graphics state captured for rewriting.-#[derive(Clone, Debug, PartialEq)]-struct TextState {- font: Option<(String, f64)>,- char_spacing: f64,- word_spacing: f64,- scale: f64,- leading: f64,- rise: f64,- fill: Vec<Op>,- /// The text rendering mode (`Tr`); 3 is invisible text, as in an OCR layer over a scan.- render_mode: i64,- /// The stroke colour operators, the line width and the ExtGStates selected (see [`Ts`]):- /// graphics state the text was painted with that [`TextState::ops`] doesn't restate.- stroke: Vec<Op>,- line_width: Option<f64>,- ext_gstate: Vec<Vec<u8>>,- /// The dash pattern and line cap in force (see [`Ts`]): compared, not restated.- dash: Dash,- line_cap: i64,-}--impl TextState {- fn of(ts: &Ts) -> Self {- TextState {- font: ts.font.as_ref().map(|(n, _)| (String::from_utf8_lossy(n).into_owned(), ts.size)),- char_spacing: ts.char_spacing,- word_spacing: ts.word_spacing,- scale: ts.scale,- leading: ts.leading,- rise: ts.rise,- fill: ts.fill.clone(),- render_mode: ts.render_mode,- stroke: ts.stroke.clone(),- line_width: ts.line_width,- ext_gstate: ts.ext_gstate.clone(),- dash: ts.dash.clone(),- line_cap: ts.line_cap,- }- }-- /// Operators that change how text is painted from `current` (the state where they run) to- /// this one: the ExtGStates, stroke colour, line width and a visible rendering mode. A- /// rewritten paragraph is drawn before its text object, so whatever that object set before- /// its first show (`/GS1 gs`, `1 Tr 1 0 0 RG 2 w` inside `BT`, #3508/#3509) must be stated- /// again. Empty when nothing differs.- ///- /// Only fill, stroke and fill-then-stroke (`Tr` 0–2) are restated: invisible text is revealed- /// by [`reveal_ops`] and clipping text is refused, so neither is ever drawn this way.- ///- /// A `gs` has no inverse, so a selection `current` has and this state doesn't stays in force:- /// run these inside a `q`/`Q` that starts from `current`, one per state drawn.- fn paint_ops(&self, current: &TextState) -> Vec<Op> {- let n = pdfcraft_content::num;- let mut v = Vec::new();- // The selections both share stay in force; the ones after them are selected again in order.- let shared = self.ext_gstate.iter().zip(¤t.ext_gstate).take_while(|(a, b)| a == b).count();- for name in self.ext_gstate.iter().skip(shared) {- v.push(Op::new("gs", vec![Object::Name(name.clone())]));- }- // A reselected ExtGState may set `/LW`, so the width (already the effective one) follows it.- let reselected = !v.is_empty();- if self.stroke != current.stroke {- if self.stroke.is_empty() {- // The initial stroke colour: black in DeviceGray.- v.push(Op::new("G", vec![n(0.0)]));- } else {- v.extend(self.stroke.iter().cloned());- }- }- let width = self.line_width.unwrap_or(1.0);- if reselected || width != current.line_width.unwrap_or(1.0) {- v.push(Op::new("w", vec![n(width)]));- }- if (0..=2).contains(&self.render_mode) && self.render_mode != current.render_mode {- v.push(Op::new("Tr", vec![Object::Int(self.render_mode)]));- }- v- }-- /// Operators that set this state (inside a text object).- fn ops(&self) -> Vec<Op> {- let n = pdfcraft_content::num;- let mut v = Vec::new();- if let Some((f, size)) = &self.font {- v.push(Op::new("Tf", vec![Object::name(f), n(*size)]));- }- v.push(Op::new("Tc", vec![n(self.char_spacing)]));- v.push(Op::new("Tw", vec![n(self.word_spacing)]));- v.push(Op::new("Tz", vec![n(self.scale * 100.0)]));- v.push(Op::new("TL", vec![n(self.leading)]));- v.push(Op::new("Ts", vec![n(self.rise)]));- v.extend(self.fill.iter().cloned());- v- }-}--/// What a run is drawn in beyond its text state: the optional content groups of the `/OC`-/// marked-content sequences around it, and the effective graphics state parameters (`gs`) in-/// force. A rewrite writes a paragraph in its first run's place, so runs that differ here are-/// never joined: one in a hidden layer or at another opacity would lose it.-#[derive(Clone, Debug, Default, PartialEq)]-struct Paint {- layers: Vec<Vec<u8>>,- gs: Gs,-}--/// The transparency parameters of the graphics state: what the `gs` operators have set, resolved,-/// so a repeated `gs` or two names with the same settings leave it as it was.-#[derive(Clone, Debug, PartialEq)]-struct Gs {- /// `ca`, the fill opacity.- fill_alpha: f64,- /// `CA`, the stroke opacity.- stroke_alpha: f64,- /// `BM`, the blend mode (`Compatible` is `Normal`).- blend: Vec<u8>,- /// `SMask`, when it is not `None`: the reference of an indirect soft mask, else the dictionary.- soft_mask: Option<Object>,-}--impl Default for Gs {- fn default() -> Self {- Gs { fill_alpha: 1.0, stroke_alpha: 1.0, blend: b"Normal".to_vec(), soft_mask: None }- }-}--impl Gs {- /// Applies the parameters a graphics state parameter dictionary sets; the others stay.- fn apply(&mut self, doc: &Document, params: &Dict) {- let num = |key: &[u8]| params.get(key).and_then(|o| doc.resolve(o).as_f64()).filter(|v| v.is_finite());- if let Some(v) = num(b"ca") {- self.fill_alpha = v;- }- if let Some(v) = num(b"CA") {- self.stroke_alpha = v;- }- if let Some(bm) = params.get(b"BM").map(|o| doc.resolve(o)) {- let first = bm- .as_name()- .map(<[u8]>::to_vec)- .or_else(|| bm.as_array().and_then(|a| a.iter().find_map(|o| doc.resolve(o).as_name().map(<[u8]>::to_vec))));- if let Some(name) = first {- self.blend = if name == b"Compatible" { b"Normal".to_vec() } else { name };- }- }- if let Some(mask) = params.get(b"SMask") {- self.soft_mask = match (mask.as_ref(), &*doc.resolve(mask)) {- (_, Object::Name(_)) => None,- (Some(r), _) => Some(Object::Ref(r)),- (None, Object::Dict(d)) => Some(Object::Dict(d.clone())),- (None, _) => None,- };- }- }-}--#[derive(Clone, Debug, PartialEq)]-struct Origin {- tm: [f64; 6],- /// The text line matrix there (where the next line's Td/T* starts from).- tlm: [f64; 6],- /// Text-space units → user space (the scale of the text rendering matrix's y axis).- k: f64,- /// The CTM there (current space → page space), for moving the paragraph in page space.- ctm: [f64; 6],- baseline: f64,- x: f64,- state: TextState,- bt_op: usize,- bt_state: TextState,-}--/// An editable text region: adjacent runs on visual rows, followed by aligned rows.-/// A region may contain several source fonts, sizes, colours and weights.-#[derive(Clone, Debug, PartialEq)]-pub struct TextBlock {- /// The lines' text joined with spaces (lines that ended in a hyphen are joined directly).- pub text: String,- pub rect: [f64; 4],- pub base_font: String,- pub size: f64,- pub bold: bool,- pub italic: bool,- /// The text fill colour as RGB, used by the visual editor and preserved when no colour- /// override is requested.- pub color: [f64; 3],- /// Counterclockwise baseline angle in page user space, in degrees.- pub rotation: f64,- /// Indexes into [`text_lines`].- pub lines: Vec<usize>,- /// Visual rows; each contains indexes into [`text_lines`], including mixed-style runs.- pub rows: Vec<Vec<usize>>,- /// Text for the inline editor, with a newline only between visual rows.- pub editor_text: String,- /// Byte ranges in `editor_text` and their source line indexes.- pub spans: Vec<(std::ops::Range<usize>, usize)>,- /// Every line is invisible text (rendering mode 3): an OCR layer over a scanned image, whose- /// pixels show the words. A rewrite draws the new text visibly (see [`BlockStyle::cover`]).- pub invisible: bool,-}--impl TextBlock {- /// Preserve styles outside the changed ranges; inserted characters inherit the surrounding- /// source run. The texts are aligned word by word, so words left untouched between two edits- /// keep their own runs (#2198); past [`MAX_CHANGED_WORDS`] the draft counts as one change.- /// Byte ranges are always UTF-8 boundaries. Linear time, including large edits.- pub fn edited_spans(&self, draft: &str) -> Vec<(std::ops::Range<usize>, usize)> {- if self.editor_text.len() > 4_000_000 || draft.len() > 4_000_000 {- return vec![(0..draft.len(), self.lines.first().copied().unwrap_or(0))];- }- let old: Vec<_> = self.editor_text.chars().collect();- let new: Vec<_> = draft.char_indices().collect();- let chars: Vec<_> = new.iter().map(|(_, c)| *c).collect();- let mut original = Vec::with_capacity(old.len());- let mut span = 0;- for (byte, _) in self.editor_text.char_indices() {- while self.spans.get(span).is_some_and(|(r, _)| byte >= r.end) {- span += 1;- }- original.push(self.spans.get(span).or_else(|| self.spans.last()).map_or(0, |(_, i)| *i));- }- let mut sources = Vec::with_capacity(new.len());- let slices = |text: &[char]| words(text).into_iter().map(|w| text.get(w).unwrap_or_default().to_vec()).collect::<Vec<_>>();- let (old_words, new_words) = (slices(&old), slices(&chars));- match edit_script(&old_words, &new_words, MAX_CHANGED_WORDS) {- Some(script) => {- // `(o, n)`: where the current change starts in the old and new text; `(x, y)`: where it ends.- let ((mut o, mut n), (mut x, mut y)) = ((0, 0), (0, 0));- let (mut a, mut b) = (old_words.iter(), new_words.iter());- for step in script {- match step {- Step::Keep => {- replaced(&original, o, old.get(o..x).unwrap_or_default(), chars.get(n..y).unwrap_or_default(), &mut sources);- let len = a.next().map_or(0, Vec::len);- b.next();- sources.extend(original.get(x..x.saturating_add(len)).unwrap_or_default());- (x, y) = (x.saturating_add(len), y.saturating_add(len));- (o, n) = (x, y);- }- Step::Delete => x = x.saturating_add(a.next().map_or(0, Vec::len)),- Step::Insert => y = y.saturating_add(b.next().map_or(0, Vec::len)),- }- }- replaced(&original, o, old.get(o..x).unwrap_or_default(), chars.get(n..y).unwrap_or_default(), &mut sources);- }- None => replaced(&original, 0, &old, &chars, &mut sources),- }- let fallback = original.first().copied().unwrap_or(0);- let mut result: Vec<(std::ops::Range<usize>, usize)> = Vec::new();- for (i, (byte, ch)) in new.iter().enumerate() {- let source = sources.get(i).copied().unwrap_or(fallback);- let end = byte.saturating_add(ch.len_utf8());- if let Some((range, _)) = result.last_mut().filter(|(_, prev)| *prev == source) {- range.end = end;- } else {- result.push((*byte..end, source));- }- }- result- }-}--/// Changed words [`TextBlock::edited_spans`] aligns before it treats the draft as one change.-/// Myers' diff costs O((N + M) · D), so bounding D keeps it linear.-const MAX_CHANGED_WORDS: usize = 64;--/// `text` split into words, each with the whitespace after it, as char ranges.-fn words(text: &[char]) -> Vec<std::ops::Range<usize>> {- let mut out = Vec::new();- let mut start = 0;- for (i, pair) in text.windows(2).enumerate() {- if let [a, b] = pair- && a.is_whitespace()- && !b.is_whitespace()- {- out.push(start..i + 1);- start = i + 1;- }- }- if start < text.len() {- out.push(start..text.len());- }- out-}--#[derive(Clone, Copy, Debug, PartialEq)]-enum Step {- Keep,- Delete,- Insert,-}--/// Myers' shortest edit script from `a` to `b`, or `None` when it takes more than `max` steps.-fn edit_script<T: PartialEq>(a: &[T], b: &[T], max: usize) -> Option<Vec<Step>> {- let (n, m) = (a.len() as isize, b.len() as isize);- let max = max.min(a.len().saturating_add(b.len())) as isize;- // Furthest x reached on each diagonal k = x - y, stored at k + max + 1.- let at = |v: &[isize], k: isize| usize::try_from(k + max + 1).ok().and_then(|i| v.get(i).copied()).unwrap_or(0);- let mut v = vec![0isize; (2 * max + 3) as usize];- let mut trace = Vec::new();- for d in 0..=max {- trace.push(v.clone());- for k in (-d..=d).step_by(2) {- let down = k == -d || (k != d && at(&v, k - 1) < at(&v, k + 1));- let mut x = if down { at(&v, k + 1) } else { at(&v, k - 1) + 1 };- let mut y = x - k;- while x < n && y < m && a.get(x as usize) == b.get(y as usize) {- x += 1;- y += 1;- }- if let Some(slot) = usize::try_from(k + max + 1).ok().and_then(|i| v.get_mut(i)) {- *slot = x;- }- if x >= n && y >= m {- return Some(backtrack(&trace, n, m, max));- }- }- }- None-}--/// Walk Myers' saved frontiers back from the end to the edit script.-fn backtrack(trace: &[Vec<isize>], n: isize, m: isize, max: isize) -> Vec<Step> {- let at = |v: &[isize], k: isize| usize::try_from(k + max + 1).ok().and_then(|i| v.get(i).copied()).unwrap_or(0);- let mut steps = Vec::new();- let (mut x, mut y) = (n, m);- for (d, v) in trace.iter().enumerate().rev() {- let (d, k) = (d as isize, x - y);- let prev_k = if k == -d || (k != d && at(v, k - 1) < at(v, k + 1)) { k + 1 } else { k - 1 };- let prev_x = at(v, prev_k);- let prev_y = prev_x - prev_k;- while x > prev_x && y > prev_y {- steps.push(Step::Keep);- x -= 1;- y -= 1;- }- if d > 0 {- steps.push(if x == prev_x { Step::Insert } else { Step::Delete });- }- (x, y) = (prev_x, prev_y);- }- steps.reverse();- steps-}--/// `old`, at char `at` of the source, became `new`: characters kept at either end keep their-/// runs, and the rest inherit the run just before the change (or the first one it replaces).-fn replaced(original: &[usize], at: usize, old: &[char], new: &[char], out: &mut Vec<usize>) {- let prefix = old.iter().zip(new).take_while(|(a, b)| a == b).count();- let suffix = old.iter().rev().zip(new.iter().rev()).take(old.len().min(new.len()).saturating_sub(prefix)).take_while(|(a, b)| a == b).count();- let start = at.saturating_add(prefix);- let inherited = start.checked_sub(1).and_then(|i| original.get(i)).or_else(|| original.get(start)).copied().unwrap_or(0);- for i in 0..new.len() {- let source = if i < prefix {- original.get(at.saturating_add(i)).copied()- } else if i >= new.len().saturating_sub(suffix) {- original.get(at.saturating_add(old.len()).saturating_sub(new.len() - i)).copied()- } else {- Some(inherited)- };- out.push(source.unwrap_or(inherited));- }-}--impl TextLine {- /// The baseline's height in user space.- pub fn origin_baseline(&self) -> f64 {- self.origin.baseline- }-- /// Paint position of the line's first operator: `(content-stream index, operator index in- /// the page's joined stream)`. A line joins runs painted at different times, so anything- /// painted after this position may lie on top of part of it.- /// (Lines from `text_lines` never come from form XObjects, so `stream` is always a- /// page content-stream index and `ops` are indices into the joined operator list.)- pub fn first_paint_pos(&self) -> (usize, usize) {- (self.stream, self.ops.iter().min().copied().unwrap_or(0))- }-- /// The runs of text the line joins, in content order: each run's text as its glyphs show it,- /// the boxes of its words (a part of `ink`), and whether joining put a space between it and- /// the run before (`text` has one there; runs closer together join with none, so one word- /// can span runs). None when the line's text was reordered for reading (right-to-left or- /// visual-order Indic text): then only the line's text as a whole says what it reads.- pub fn runs(&self) -> impl Iterator<Item = (&str, &[[f64; 4]], bool)> {- let mut start = 0;- self.runs.iter().map(move |(text, end, spaced)| {- let ink = self.ink.get(start..*end).unwrap_or_default();- start = *end;- (text.as_str(), ink, *spaced)- })- }-- fn rotation(&self) -> f64 {- let m = Matrix(self.origin.tm).then(&Matrix(self.origin.ctm)).0;- m[1].atan2(m[0]).to_degrees()- }-- /// The unit direction its baseline runs in, in user space.- fn direction(&self) -> (f64, f64) {- direction(&Matrix(self.origin.tm).then(&Matrix(self.origin.ctm)))- }-- /// Whether it reads left to right along the page's x axis (most text; a page drawn- /// turned a quarter, as landscape pages often are, isn't).- pub(crate) fn upright(&self) -> bool {- let (x, y) = self.direction();- (x - 1.0).abs() < 1e-3 && y.abs() < 1e-3- }-- /// Where it starts as `(along, across)` its baseline: user space turned to the text's direction.- fn frame_origin(&self) -> (f64, f64) {- to_frame(self.direction(), (self.origin.x, self.origin.baseline))- }-- /// Its box in the same frame, `[along0, across0, along1, across1]` (for upright text, `rect`).- fn frame_rect(&self) -> [f64; 4] {- self.frame- }-}--/// The unit x axis of a text rendering matrix in user space (`(1, 0)` when it is degenerate).-fn direction(m: &Matrix) -> (f64, f64) {- let (x, y) = (m.0[0], m.0[1]);- let length = x.hypot(y);- if length.is_finite() && length > 1e-9 { (x / length, y / length) } else { (1.0, 0.0) }-}--/// User-space point `p` as `(along, across)` a baseline running in unit direction `dir`. Upright-/// text (`dir` = `(1, 0)`) keeps its coordinates, so lines and rows of turned text are found the-/// same way (#1443).-fn to_frame(dir: (f64, f64), p: (f64, f64)) -> (f64, f64) {- (p.0 * dir.0 + p.1 * dir.1, p.1 * dir.0 - p.0 * dir.1)-}--/// The box covering both `[x0, y0, x1, y1]` boxes.-fn union(a: [f64; 4], b: [f64; 4]) -> [f64; 4] {- [a[0].min(b[0]), a[1].min(b[1]), a[2].max(b[2]), a[3].max(b[3])]-}--/// What replacing a line did.-#[derive(Clone, Debug, PartialEq)]-pub struct LineEdit {- /// `Some(font)` when the line's font couldn't show the new text and Helvetica was used.- pub substituted: Option<String>,-}--#[derive(Clone)]-struct Ts {- ctm: Matrix,- /// The operators that set the current fill colour (`g`, `rg`, `k`, or `cs` + `sc`/`scn`).- fill: Vec<Op>,- font: Option<(Vec<u8>, Rc<Metrics>)>,- /// The Japanese or Hebrew fallback face the font subsets, when the font is one (see [`is_type3_fallback`]).- face: Option<String>,- size: f64,- char_spacing: f64,- word_spacing: f64,- scale: f64,- leading: f64,- rise: f64,- render_mode: i64,- /// The transparency parameters the `gs` operators have set so far (see [`Paint`]).- gs: Gs,- /// The font's vertical advance per unit of font size (`/DW2`'s w1, normally −1) when its- /// CMap writes vertically (`WMode 1`, §9.7.4.3): each glyph then moves the pen down, not right.- vertical: Option<f64>,- /// Why the font's writing mode couldn't be read (a broken or cyclic CMap). Its text is then- /// listed as horizontal, but the lines in it are refused for editing.- unreadable: Option<Rc<str>>,- /// The operators that set the current stroke colour (`G`, `RG`, `K`, or `CS` + `SC`/`SCN`).- stroke: Vec<Op>,- /// The line width a `w` or an ExtGState's `/LW` set (`None`: the initial 1.0).- line_width: Option<f64>,- /// The ExtGState resources selected with `gs`, oldest first (see [`select_gs`]).- ext_gstate: Vec<Vec<u8>>,- /// The dash pattern a `d` or an ExtGState's `/D` set (initially solid: `[] 0`).- dash: Dash,- /// The line cap a `J` or an ExtGState's `/LC` set (initially 0, butt).- line_cap: i64,-}--/// A dash pattern (ISO 32000-2 §8.4.3.6): the dash array and the phase.-type Dash = (Vec<f64>, f64);--/// The most dash array entries a pattern keeps; a longer one is ignored, as is a malformed one.-const MAX_DASH: usize = 32;--/// The dash pattern `array phase`, as `d` takes it and an ExtGState's `/D` holds it.-fn dash_pattern(doc: &Document, array: Option<&Object>, phase: Option<&Object>) -> Option<Dash> {- let array = doc.resolve(array?);- let items = array.as_array().filter(|a| a.len() <= MAX_DASH)?;- let finite = |o: &Object| doc.resolve(o).as_f64().filter(|v| v.is_finite());- Some((items.iter().map(finite).collect::<Option<Vec<_>>>()?, finite(phase?)?))-}--/// A line cap style, as `J` takes it and an ExtGState's `/LC` holds it: 0, 1 or 2.-fn line_cap(doc: &Document, cap: Option<&Object>) -> Option<i64> {- doc.resolve(cap?).as_int().filter(|c| (0..=2).contains(c))-}--/// The most `gs` selections a state remembers. Repeating a selection moves it to the end, so-/// this bounds the distinct ExtGStates in force, not the operators a hostile stream repeats.-const MAX_GS: usize = 32;--/// Record `gs /name` in `list`. A `gs` sets every parameter its dictionary names to an absolute-/// value, so a later selection of the same dictionary overrides the earlier one completely: the-/// earlier entry goes, which keeps replaying the list equivalent to replaying the stream.-fn select_gs(list: &mut Vec<Vec<u8>>, name: &[u8]) {- list.retain(|n| n != name);- if list.len() >= MAX_GS {- list.remove(0);- }- list.push(name.to_vec());-}--/// The page's content streams as listed, each with its decoded data (empty when it doesn't-/// decode), within one page's [`DecodeBudget`]. An error when the content runs past it: reading-/// or rewriting a page from part of its content would lose the rest.-pub(crate) fn content_streams(doc: &Document, page: &Dict) -> Result<Vec<(Object, Vec<u8>)>, EditError> {- content_streams_within(doc, page, &mut DecodeBudget::page())-}--/// [`content_streams`], decoded against `budget`, which a walk of the page's forms then goes on-/// spending.-pub(crate) fn content_streams_within(doc: &Document, page: &Dict, budget: &mut DecodeBudget) -> Result<Vec<(Object, Vec<u8>)>, EditError> {- let list: Vec<Object> = match page.get(b"Contents") {- None => Vec::new(),- Some(c) => match &*doc.resolve(c) {- Object::Array(a) => a.clone(),- _ => vec![c.clone()],- },- };- let mut out = Vec::with_capacity(list.len());- for o in list {- let data = match &*doc.resolve(&o) {- Object::Stream(s) => match budget.decode(s) {- Ok(data) => data,- Err(e) if budget.remaining() == 0 => return Err(EditError::Invalid(format!("the page content is too large to read: {e}"))),- Err(_) => Vec::new(),- },- _ => Vec::new(),- };- out.push((o, data));- }- Ok(out)-}--/// Rewrite a page's content (its streams joined, see [`Pieces`]): `edit(i)` gives the operators-/// to insert before operator `i` of `ops` (parsed from the joined pieces) and whether to keep it.-/// Everything else is copied byte for byte. A page's streams are one stream in pieces, split-/// between any two tokens (ISO 32000-2 §7.8.2), so an operator's operands can end one piece and-/// its keyword start the next; removing or replacing it rewrites every piece it spans. Returns-/// each piece's new bytes.-pub(crate) fn splice(pieces: &Pieces, ops: &[Op], mut edit: impl FnMut(usize) -> (Vec<Op>, bool)) -> Vec<Vec<u8>> {- let data = pieces.data();- let mut edits = Vec::new();- for (i, op) in ops.iter().enumerate() {- let (insert, keep) = edit(i);- if insert.is_empty() && keep {- continue;- }- let mut bytes = Vec::new();- if !insert.is_empty() {- if op.span.start.checked_sub(1).and_then(|p| data.get(p)).is_some_and(|b| !b.is_ascii_whitespace()) {- bytes.push(b'\n');- }- bytes.extend_from_slice(&serialize_ops(&insert));- }- let end = if keep { op.span.start } else { op.span.end };- edits.push((op.span.start..end, bytes));- }- pieces.splice(edits)-}--/// The page's `/Contents` after a [`splice`]: pieces whose bytes changed become new streams-/// (keeping their dictionaries), the others stay as they were.-pub(crate) fn rewritten_contents(doc: &mut Document, streams: &[(Object, Vec<u8>)], new: Vec<Vec<u8>>) -> Object {- let mut contents: Vec<Object> = Vec::with_capacity(streams.len());- for ((obj, old), data) in streams.iter().zip(new) {- if *old == data {- contents.push(obj.clone());- continue;- }- let mut dict = match &*doc.resolve(obj) {- Object::Stream(s) => s.dict.clone(),- _ => Dict::new(),- };- dict.remove(b"Length");- contents.push(Object::Ref(doc.add(Object::Stream(Stream::flate(dict, &data)))));- }- match <[Object; 1]>::try_from(contents) {- Ok([one]) => one,- Err(many) => Object::Array(many),- }-}--fn page_dict(doc: &Document, page: usize) -> Result<pdfcraft_model::Page, EditError> {- pdfcraft_model::pages(doc).into_iter().nth(page).ok_or(EditError::NoSuchPage(page))-}--fn fill_color(fill: &[Op]) -> [f64; 3] {- let Some(op) = fill.iter().rev().find(|op| matches!(op.op.as_slice(), b"g" | b"rg" | b"k" | b"sc" | b"scn")) else {- return [0.0, 0.0, 0.0];- };- let space = match op.op.as_slice() {- b"sc" | b"scn" => match op.operands.len() {- 1 => b"g".as_slice(),- 3 => b"rg".as_slice(),- 4 => b"k".as_slice(),- _ => return [0.0; 3],- },- other => other,- };- match space {- b"g" => {- let v = op.operands.first().and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0);- [v, v, v]- }- b"rg" => [- op.operands.first().and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),- op.operands.get(1).and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),- op.operands.get(2).and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),- ],- b"k" => {- let c = op.operands.first().and_then(Object::as_f64).unwrap_or(0.0);- let m = op.operands.get(1).and_then(Object::as_f64).unwrap_or(0.0);- let y = op.operands.get(2).and_then(Object::as_f64).unwrap_or(0.0);- let k = op.operands.get(3).and_then(Object::as_f64).unwrap_or(0.0);- [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)]- }- _ => [0.0, 0.0, 0.0],- }-}--/// The text-showing operators of one stream with their text, font, box and baseline.-struct Shown {- op: usize,- extra_ops: Vec<usize>,- /// Encoded glyphs, not bytes or Unicode characters (a ligature can represent several).- glyph_count: usize,- /// Advance in text space, including spacing and TJ adjustments.- advance: f64,- tracking: f64,- /// The text matrix where it starts (text space), and the state there and at its `BT`.- tm: Matrix,- tlm: Matrix,- state: Ts,- bt_op: usize,- bt_state: Ts,- text: String,- rect: [f64; 4],- /// Its box along and across its baseline (see [`TextLine::frame`]).- frame: [f64; 4],- /// The boxes of its words (see [`TextLine::ink`]).- ink: Vec<[f64; 4]>,- baseline: f64,- start_x: f64,- end_x: f64,- end_y: f64,- bt: usize,- font: Vec<u8>,- base_font: String,- face: Option<String>,- size: f64,- bold: bool,- italic: bool,- visual_order: bool,- decodable: bool,- scope: Option<usize>,- paint: Paint,- logical_order: bool,- actual_text: bool,-}--impl Shown {- /// The unit direction of its baseline, where it starts and ends along it, and the baseline's- /// offset across it (for upright text: the user-space x, x and y). A vertical run goes along- /// its column instead, the way the pen moves: for upright text down, with the column's x- /// across.- fn span(&self) -> ((f64, f64), f64, f64, f64) {- let m = self.tm.then(&self.state.ctm);- let dir = match self.state.vertical {- Some(w1) => direction(&Matrix([m.0[2] * w1.signum(), m.0[3] * w1.signum(), 0.0, 0.0, 0.0, 0.0])),- None => direction(&m),- };- let (start, across) = to_frame(dir, (self.start_x, self.baseline));- (dir, start, to_frame(dir, (self.end_x, self.end_y)).0, across)- }-}--/// Where the previous run of a line ended: its text object, baseline direction, offset across-/// the baseline, end along it and size.-#[derive(Clone, Copy)]-struct Pen {- bt: usize,- dir: (f64, f64),- across: f64,- end: f64,- size: f64,- vertical: bool,-}--impl Pen {- fn after(s: &Shown) -> Self {- let (dir, _, end, across) = s.span();- Pen { bt: s.bt, dir, across, end, size: s.size.max(1.0), vertical: s.state.vertical.is_some() }- }-- /// Whether `s` could continue the same line on geometry alone: on the same baseline, starting- /// at most a word gap (`reach` sizes) after it. Also the gap along the baseline.- fn continues(&self, s: &Shown, reach: f64) -> (bool, f64) {- let (dir, start, _, across) = s.span();- let gap = start - self.end;- let same_dir = (dir.0 - self.dir.0).abs() < 1e-3 && (dir.1 - self.dir.1).abs() < 1e-3;- // A column continues a column (along which the pen moves), a baseline a baseline.- let same_dir = same_dir && self.vertical == s.state.vertical.is_some();- (same_dir && (across - self.across).abs() < self.size * 0.3 && gap > -self.size && gap < self.size * reach, gap)- }-}--/// Use the lower third of letter gaps, not word gaps. A pair of isolated labels is not-/// evidence of tracking; unadjusted neighbours inside a string contribute zero too.-/// The tracking a run of glyphs was set with: the lower third of its gaps, when that is at-/// most half an em (`limit`). A wider "tracking" is word or cell spacing between one-glyph-/// words (`a b c`, a column of digits or Y/N ticks), which must keep its spaces.-fn typical_tracking(gaps: &mut [f64], limit: f64) -> f64 {- if gaps.len() < 3 {- return 0.0;- }- let at = gaps.len() / 3;- gaps.select_nth_unstable_by(at, f64::total_cmp);- gaps.get(at).copied().filter(|n| n.is_finite() && *n <= limit).unwrap_or(0.0).max(0.0)-}--fn tj_tracking(pieces: &[Object], metrics: &Metrics, size: f64, scale: f64) -> f64 {- let mut gaps = Vec::new();- let mut previous = false;- let mut gap = 0.0;- for piece in pieces {- if let Object::String(s) = piece {- for (code, len) in metrics.codes(&s.bytes) {- let blank = metrics.is_space(code, len) || metrics.text_of(code).is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));- if previous && !blank {- gaps.push(gap);- }- previous = !blank;- gap = 0.0;- }- } else if let Some(n) = piece.as_f64() {- gap += -n / 1000.0 * size * scale;- }- }- typical_tracking(&mut gaps, size * scale.abs() * 0.5)-}--fn positioned_tracking(shown: &mut [Shown]) {- let mut start = 0;- while start < shown.len() {- let mut end = start.saturating_add(1);- while let (Some(prev), Some(next)) = (shown.get(end.saturating_sub(1)), shown.get(end)) {- if prev.glyph_count != 1- || next.glyph_count != 1- || prev.font != next.font- || prev.scope != next.scope- || (prev.size - next.size).abs() > 0.01- || prev.state.char_spacing != next.state.char_spacing- || prev.state.scale != next.state.scale- || !Pen::after(prev).continues(next, 1.5).0- {- break;- }- end = end.saturating_add(1);- }- if let Some(run) = shown.get_mut(start..end) {- let mut gaps: Vec<f64> = run- .windows(2)- .filter_map(|pair| {- let [prev, next] = pair else { return None };- (!prev.text.trim().is_empty() && !next.text.trim().is_empty()).then(|| Pen::after(prev).continues(next, 0.0).1)- })- .collect();- let limit = run.first().map_or(0.0, |s| s.size * s.state.scale.abs() * 0.5);- let tracking = typical_tracking(&mut gaps, limit);- for s in run.iter_mut().skip(1) {- s.tracking = tracking;- }- }- start = end;- }-}--/// The graphics state carried from one of a page's content streams to the next: the streams-/// are one stream in pieces (§7.8.2), so a `cm` (AutoCAD scales the whole page in the first-/// stream), an unbalanced `q`, the font and the colour still apply in the streams after it.-struct Carry {- ts: Ts,- stack: Vec<Ts>,- marked: Vec<Option<usize>>,- /// For each open marked-content sequence, its optional content group when it is `/OC`.- layers: Vec<Option<Vec<u8>>>,- /// Bytes of glyph text the rest of the page may still produce (see [`MAX_PAGE_TEXT`]).- text_left: usize,-}--/// The most glyph text one page's extraction produces, in bytes. A ToUnicode destination is-/// copied for every glyph showing its code, so a small page can otherwise expand into gigabytes;-/// real pages hold far less (a whole novel is about 1 MB).-const MAX_PAGE_TEXT: usize = 16 << 20;--impl Carry {- fn new() -> Self {- let ts = Ts {- ctm: Matrix::IDENTITY,- fill: Vec::new(),- font: None,- face: None,- size: 0.0,- char_spacing: 0.0,- word_spacing: 0.0,- scale: 1.0,- leading: 0.0,- rise: 0.0,- render_mode: 0,- gs: Gs::default(),- vertical: None,- unreadable: None,- stroke: Vec::new(),- line_width: None,- ext_gstate: Vec::new(),- dash: (Vec::new(), 0.0),- line_cap: 0,- };- Carry { ts, stack: Vec::new(), marked: Vec::new(), layers: Vec::new(), text_left: MAX_PAGE_TEXT }- }-}--/// A font resource's metrics, fallback face and vertical advance (see [`Ts`]), read once per page.-/// The advance is an error message when the font's writing mode can't be read.-type CachedFont = (Rc<Metrics>, Option<String>, Result<Option<f64>, String>);--/// A `Do` met while interpreting: its operator index, XObject name and the state there.-type Invocation = (usize, Vec<u8>, Ts);--fn interpret(- doc: &Document,- ops: &[Op],- resources: &Dict,- cache: &mut HashMap<Vec<u8>, CachedFont>,- carry: &mut Carry,- mut invoked: Option<&mut Vec<Invocation>>,- // `Some(properties)`: read `/ActualText`, looking named property lists up in `properties`.- logical_text: Option<&Dict>,-) -> Result<Vec<Shown>, EditError> {- let fonts_res = resources.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();- let states = resources.get(b"ExtGState").map(|g| doc.resolve(g)).and_then(|g| g.as_dict().cloned()).unwrap_or_default();- let mut out: Vec<Shown> = Vec::new();- let mut ts = carry.ts.clone();- let mut at_bt = (0usize, ts.clone());- let mut stack: Vec<Ts> = std::mem::take(&mut carry.stack);- let (mut tm, mut tlm) = (Matrix::IDENTITY, Matrix::IDENTITY);- let mut bt = 0usize;- let mut marked = std::mem::take(&mut carry.marked);- let mut layers = std::mem::take(&mut carry.layers);- let mut actual: Vec<Option<(usize, usize, String)>> = Vec::new();- for (i, op) in ops.iter().enumerate() {- match op.op.as_slice() {- // No depth cap: every `EMC` pops, so a capped push would pair it with the enclosing- // sequence (#3573). Both stacks stay bounded by the number of operators.- b"BMC" | b"BDC" => {- // Marked text paragraphs/headings are authoritative boundaries. Ignore- // artifacts and inner spans, which inherit their enclosing region.- let region = matches!(op.name(0), Some(b"P" | b"H" | b"H1" | b"H2" | b"H3" | b"H4" | b"H5" | b"H6" | b"LI" | b"TD" | b"TH"));- marked.push(if region { Some(i) } else { marked.last().copied().flatten() });- // A layer named in the resources is told apart by its name, an inline one by where it opens.- let layer = op.is("BDC") && op.name(0) == Some(b"OC".as_slice());- layers.push(layer.then(|| op.operands.get(1).and_then(Object::as_name).map_or_else(|| format!("@{i}").into_bytes(), <[u8]>::to_vec)));- // The property list is inline or named in the resources' /Properties (§14.6.2).- let list = logical_text.and_then(|properties| match op.operands.get(1) {- Some(Object::Name(n)) => properties.get(n).and_then(|o| doc.dict(o)),- other => other.and_then(Object::as_dict).cloned(),- });- let logical = list.as_ref().and_then(|d| d.get(b"ActualText")).and_then(|s| match s {- Object::String(s) if s.bytes.len() <= 4_000_000 => Some(s.to_text()),- _ => None,- });- actual.push(logical.map(|s| (out.len(), i, s)));- }- b"EMC" => {- marked.pop();- layers.pop();- if let Some(Some((start, open, logical))) = actual.pop() {- let tail = out.split_off(start.min(out.len()));- let mut items = tail.into_iter();- if let Some(mut first) = items.next() {- for shown in items {- first.glyph_count = first.glyph_count.saturating_add(shown.glyph_count);- first.extra_ops.push(shown.op);- first.extra_ops.extend(shown.extra_ops);- first.rect = [- first.rect[0].min(shown.rect[0]),- first.rect[1].min(shown.rect[1]),- first.rect[2].max(shown.rect[2]),- first.rect[3].max(shown.rect[3]),- ];- first.frame = union(first.frame, shown.frame);- first.ink.extend(shown.ink);- }- first.extra_ops.extend([open, i]);- // Only right-to-left ActualText is already in typing order and must stay- // out of the line's bidi recovery. Word and Chrome wrap Latin ligatures- // (`fi`, `fl`) in ActualText spans mid-word; those keep joining their line.- first.logical_order = logical.chars().any(crate::bidi::is_rtl);- first.actual_text = true;- first.text = logical;- first.start_x = first.rect[0];- first.end_x = first.rect[2];- first.end_y = first.baseline;- first.advance = (first.end_x - first.start_x) / first.tm.then(&first.state.ctm).0[0].abs().max(1e-6);- out.push(first);- }- }- }- b"q" => stack.push(ts.clone()),- b"Q" => {- if let Some(s) = stack.pop() {- ts = s;- }- }- b"cm" => {- if let Some(m) = op.nums::<6>() {- ts.ctm = Matrix(m).then(&ts.ctm);- }- }- b"BT" => {- tm = Matrix::IDENTITY;- tlm = Matrix::IDENTITY;- bt += 1;- at_bt = (i, ts.clone());- }- b"g" | b"rg" | b"k" | b"cs" => ts.fill = vec![op.clone()],- b"sc" | b"scn" => {- ts.fill.retain(|o| o.is("cs"));- ts.fill.push(op.clone());- }- b"G" | b"RG" | b"K" | b"CS" => ts.stroke = vec![op.clone()],- b"SC" | b"SCN" => {- ts.stroke.retain(|o| o.is("CS"));- ts.stroke.push(op.clone());- }- b"w" => ts.line_width = op.num(0).filter(|w| w.is_finite()).or(ts.line_width),- b"d" => ts.dash = dash_pattern(doc, op.operands.first(), op.operands.get(1)).unwrap_or_else(|| ts.dash.clone()),- b"J" => ts.line_cap = line_cap(doc, op.operands.first()).unwrap_or(ts.line_cap),- b"Tf" => {- ts.size = op.num(1).unwrap_or(ts.size);- if let Some(name) = op.name(0) {- let (m, face, vertical) = cache.entry(name.to_vec()).or_insert_with(|| {- let dict = fonts_res.get(name).and_then(|f| doc.resolve(f).as_dict().cloned());- let metrics = dict.as_ref().map_or_else(Metrics::fallback, |d| Metrics::from_dict(doc, d));- let vertical = dict.as_ref().map_or(Ok(None), |d| vertical_advance(doc, d).map_err(|e| e.to_string()));- let face = dict.filter(is_type3_fallback).map(|_| metrics.base_font.clone());- (Rc::new(metrics), face, vertical)- });- ts.font = Some((name.to_vec(), m.clone()));- ts.face = face.clone();- // Which way the glyphs advance is unknown (§9.7.4.3): list the font's text as- // horizontal and record why, so editing its lines is refused (not the page).- match vertical {- Ok(v) => (ts.vertical, ts.unreadable) = (*v, None),- Err(e) => (ts.vertical, ts.unreadable) = (None, Some(Rc::from(e.as_str()))),- }- }- }- b"Tc" => ts.char_spacing = op.num(0).unwrap_or(0.0),- b"Tw" => ts.word_spacing = op.num(0).unwrap_or(0.0),- b"Tz" => ts.scale = op.num(0).unwrap_or(100.0) / 100.0,- b"TL" => ts.leading = op.num(0).unwrap_or(0.0),- b"Ts" => ts.rise = op.num(0).unwrap_or(0.0),- b"Tr" => ts.render_mode = op.operands.first().and_then(Object::as_int).unwrap_or(-1),- b"gs" => {- if let Some(name) = op.name(0) {- select_gs(&mut ts.ext_gstate, name);- }- let params = op.name(0).and_then(|name| states.get(name)).map(|p| doc.resolve(p));- if let Some(params) = params.as_deref().and_then(Object::as_dict) {- ts.gs.apply(doc, params);- // `/LW` sets the line width as `w` does (ISO 32000-2 §8.4.5).- let lw = params.get(b"LW").and_then(|w| doc.resolve(w).as_f64()).filter(|w| w.is_finite());- ts.line_width = lw.or(ts.line_width);- let dash = params.get(b"D").map(|d| doc.resolve(d));- let dash = dash.as_deref().and_then(Object::as_array);- if let Some(d) = dash.and_then(|d| dash_pattern(doc, d.first(), d.get(1))) {- ts.dash = d;- }- ts.line_cap = line_cap(doc, params.get(b"LC")).unwrap_or(ts.line_cap);- }- }- b"Do" => {- if let (Some(list), Some(name)) = (invoked.as_deref_mut(), op.name(0)) {- list.push((i, name.to_vec(), ts.clone()));- }- }- b"Td" | b"TD" => {- if let Some([x, y]) = op.nums::<2>() {- if op.is("TD") {- ts.leading = -y;- }- tlm = Matrix([1.0, 0.0, 0.0, 1.0, x, y]).then(&tlm);- tm = tlm;- }- }- b"Tm" => {- if let Some(m) = op.nums::<6>() {- tlm = Matrix(m);- tm = tlm;- }- }- b"T*" => {- tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(&tlm);- tm = tlm;- }- b"Tj" | b"TJ" | b"'" | b"\"" => {- if matches!(op.op.as_slice(), b"'" | b"\"") {- if op.is("\"") {- ts.word_spacing = op.num(0).unwrap_or(ts.word_spacing);- ts.char_spacing = op.num(1).unwrap_or(ts.char_spacing);- }- tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(&tlm);- tm = tlm;- }- let Some((name, m)) = ts.font.clone() else { continue };- // Pieces: strings, and TJ number adjustments.- let pieces: Vec<Object> = match op.op.as_slice() {- // A surplus array (`[(A)] [(B)] TJ`) is malformed, but the operator still- // takes the one immediately before it, as the renderer and every other- // reader here do (#3569) -- not the first, which a reader counting operands- // from the front of a surplus list would otherwise take.- b"TJ" => op.operands.last().and_then(Object::as_array).cloned().unwrap_or_default(),- _ => op.operands.last().cloned().into_iter().collect(),- };- // Tc is already included in the pen advance; TJ may encode tracking instead.- let tracking = if op.is("TJ") { tj_tracking(&pieces, &m, ts.size, ts.scale) } else { 0.0 };- let trm0 = tm.then(&ts.ctm);- let start = trm0.apply(0.0, ts.rise);- let mut text = String::new();- let mut decodable = true;- let mut x_text = 0.0;- // Vertical text (§9.4.4): the pen moves along y instead, and each glyph is centred- // on it horizontally; `half` is half the widest glyph.- let vertical = ts.vertical;- let (mut y_text, mut half) = (0.0, 0.0_f64);- // Where each word's glyphs start and end along the run (text space), and whether- // the next glyph continues the last word.- let mut words: Vec<(f64, f64)> = Vec::new();- let mut in_word = false;- let mut glyph_count = 0_usize;- for p in &pieces {- match p {- Object::String(s) => {- for (code, len) in m.codes(&s.bytes) {- glyph_count = glyph_count.saturating_add(1);- let shown = m.text_of(code);- let blank =- m.is_space(code, len) || shown.as_deref().is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));- match shown {- Some(t) => {- carry.text_left = carry- .text_left- .checked_sub(t.len())- .ok_or_else(|| EditError::Invalid("the page's text is too large to read".into()))?;- text.push_str(&t);- }- None => decodable = false,- }- let spacing = ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };- if let Some(w1) = vertical {- half = half.max((m.width(code) * ts.size * ts.scale).abs() / 2.0);- if !blank {- let ink_end = y_text + w1 * ts.size;- let (lo, hi) = (y_text.min(ink_end), y_text.max(ink_end));- match words.last_mut() {- Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),- _ => words.push((lo, hi)),- }- }- in_word = !blank;- y_text += w1 * ts.size + spacing;- continue;- }- if !blank {- let ink_end = x_text + m.width(code) * ts.size * ts.scale;- // A negative font size or `Tz` runs the glyphs backwards:- // the word is the union of its glyphs, whichever way they go.- let (lo, hi) = (x_text.min(ink_end), x_text.max(ink_end));- match words.last_mut() {- Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),- _ => words.push((lo, hi)),- }- }- in_word = !blank;- let w = m.width(code) * ts.size + ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };- x_text += w * ts.scale;- }- }- other => {- if let Some(n) = other.as_f64() {- if vertical.is_some() {- // Down by n/1000 em, not scaled by `Tz`.- let dy = -n / 1000.0 * ts.size;- if -dy > ts.size * 0.2 && !text.ends_with(' ') {- text.push(' ');- }- if dy.abs() > ts.size.abs() * 0.2 {- in_word = false;- }- y_text += dy;- continue;- }- let dx = -n / 1000.0 * ts.size * ts.scale;- // A large gap inside TJ reads as a space.- if dx - tracking > (ts.size * ts.scale).abs() * 0.2 && !text.ends_with(' ') {- text.push(' ');- }- // Tracking and kerning keep a word together; a larger jump- // ends it (whatever the sign of the size or `Tz`).- if dx - tracking > (ts.size * ts.scale).abs() * 0.2 || dx < -(ts.size * ts.scale).abs() * 0.2 {- in_word = false;- }- x_text += dx;- }- }- }- }- tm = Matrix([1.0, 0.0, 0.0, 1.0, x_text, y_text]).then(&tm);- let end = tm.then(&ts.ctm).apply(0.0, ts.rise);- // The box from `a` to `b` along the run: from descent to ascent across it, or for- // vertical text, the widest glyph's width centred on the pen.- let span = |a: f64, b: f64| match vertical {- Some(_) => {- [trm0.apply(-half, ts.rise + a), trm0.apply(half, ts.rise + a), trm0.apply(-half, ts.rise + b), trm0.apply(half, ts.rise + b)]- }- None => [- trm0.apply(a, ts.rise + m.descent * ts.size),- trm0.apply(b, ts.rise + m.descent * ts.size),- trm0.apply(a, ts.rise + m.ascent * ts.size),- trm0.apply(b, ts.rise + m.ascent * ts.size),- ],- };- let corners = span(0.0, if vertical.is_some() { y_text } else { x_text });- let rect = corners- .iter()- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);- // The same corners along and across the baseline: the run's own box, not its- // upright bounding box turned (which is wider by the box's height on a slant).- let dir = direction(&trm0);- let frame = corners- .iter()- .map(|&p| to_frame(dir, p))- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);- let ink = words- .iter()- .map(|&(a, b)| {- span(a, b)- .iter()- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |r, p| [r[0].min(p.0), r[1].min(p.1), r[2].max(p.0), r[3].max(p.1)])- })- .collect();- let size_user = (trm0.0[2].powi(2) + trm0.0[3].powi(2)).sqrt() * ts.size;- // A numeric-only TJ adjusts the current text matrix but paints no glyphs.- // It must not create a phantom editable line or enlarge its neighbours' boxes.- if !pieces.iter().any(|p| matches!(p, Object::String(s) if !s.bytes.is_empty())) {- continue;- }- out.push(Shown {- op: i,- extra_ops: Vec::new(),- glyph_count,- // Vertical text: the TJ adjustment that undoes the run is n = -1000 y / size; the- // preview divides by size × `Tz`, so `Tz` is put back here.- advance: if vertical.is_some() { y_text * ts.scale } else { x_text },- tracking: 0.0,- tm: Matrix([- tm.0[0],- tm.0[1],- tm.0[2],- tm.0[3],- tm.0[4] - x_text * tm.0[0] - y_text * tm.0[2],- tm.0[5] - x_text * tm.0[1] - y_text * tm.0[3],- ]),- state: ts.clone(),- tlm,- bt_op: at_bt.0,- bt_state: at_bt.1.clone(),- text,- rect,- frame,- ink,- baseline: start.1,- start_x: start.0,- end_x: end.0,- end_y: end.1,- bt,- font: name,- base_font: m.base_font.clone(),- face: ts.face.clone(),- size: if size_user > 0.0 { size_user } else { ts.size },- bold: m.bold,- italic: m.italic,- visual_order: m.visual_order,- decodable,- scope: marked.last().copied().flatten(),- paint: Paint { layers: layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },- logical_order: false,- actual_text: false,- });- }- _ => {}- }- }- carry.ts = ts;- carry.stack = stack;- carry.marked = marked;- carry.layers = layers;- positioned_tracking(&mut out);- Ok(out)-}--/// The lines of text on a page (0-based), in content order.-pub fn text_lines(doc: &Document, page: usize) -> Result<Vec<TextLine>, EditError> {- text_lines_in(doc, &page_dict(doc, page)?, true)-}--/// The lines `page`'s glyphs show, in content order, without `/ActualText` replacements: what the-/// page draws, not what its marked-content metadata says the glyphs mean. For checks that must-/// not trust that metadata (the redaction audit). Takes the page itself, so a caller going-/// through every page doesn't walk the page tree again for each.-pub fn glyph_text_lines(doc: &Document, page: &pdfcraft_model::Page) -> Result<Vec<TextLine>, EditError> {- text_lines_in(doc, page, false)-}--/// [`text_lines`] of `p`; with `actual_text`, `/ActualText` replaces the glyphs it spans.-fn text_lines_in(doc: &Document, p: &pdfcraft_model::Page, actual_text: bool) -> Result<Vec<TextLine>, EditError> {- let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let mut cache = HashMap::new();- let mut lines: Vec<TextLine> = Vec::new();- let mut carry = Carry::new();- // The streams are one stream in pieces (§7.8.2), split between any two tokens: parse them- // joined, so an operator whose operands end one piece still has them.- let pieces = Pieces::join(&content_streams(doc, &p.dict)?.into_iter().map(|(_, d)| d).collect::<Vec<_>>());- let ops = pieces.parse().ops;- let properties = res.get(b"Properties").and_then(|o| doc.dict(o)).unwrap_or_default();- let shown = interpret(doc, &ops, &res, &mut cache, &mut carry, None, actual_text.then_some(&properties))?;- let mut last: Option<(usize, Pen)> = None; // the stream piece and where its last run ended- for mut s in shown {- // A single RTL glyph's ActualText (e.g. lam-alef) is an inline ligature, not a- // separate logical line. Put its letters into visual order before joining the- // surrounding glyphs; the completed line is recovered to typing order below.- // Multi-glyph and mixed-direction replacements keep their authoritative order.- if s.logical_order && s.glyph_count == 1 && s.text.chars().all(crate::bidi::is_rtl) {- s.text = crate::bidi::to_visual(&s.text);- s.logical_order = false;- }- // A line belongs to one stream piece. Within it, PDF producers often put every word- // in its own BT/ET: geometry and text state, not object boundaries, define a line.- let si = ops.get(s.op).map_or(0, |op| pieces.pieces_of(op).0);- let joins = last.is_some_and(|(piece, pen)| {- let bt = pen.bt;- let (near, gap) = pen.continues(&s, if bt == s.bt { 3.0 } else { 1.5 });- piece == si- && lines.last().is_some_and(|l| l.scope == s.scope && l.paint == s.paint && l.logical_order == s.logical_order)- && (bt == s.bt || lines.last().is_some_and(|l| compatible_word(l, &s)))- && (s.text.trim().is_empty() || lines.last().is_some_and(|l| same_font(l, &s.font, &s.base_font, s.face.as_deref())))- && (s.text.trim().is_empty()- || lines.last().is_some_and(|l| {- (s.size - l.size).abs() < 0.01- && s.bold == l.bold- && s.italic == l.italic- && fill_color(&s.state.fill) == l.color- && same_paint(l, &s.state)- }))- && near- // An OCR layer is one text object over the whole scan: its words continue a line- // only across a word space, not across a table cell or a tab stop.- && (s.state.render_mode != 3 || gap < pen.size * 0.6)- });- if joins && let Some(l) = lines.last_mut() {- let gap = last.map_or(0.0, |(_, pen)| pen.continues(&s, 0.0).1);- let spaced = gap - s.tracking > l.size * s.state.scale.abs() * 0.2 && !l.text.ends_with(' ') && !s.text.starts_with(' ');- if spaced {- l.text.push(' ');- }- l.text.push_str(&s.text);- l.rect = [l.rect[0].min(s.rect[0]), l.rect[1].min(s.rect[1]), l.rect[2].max(s.rect[2]), l.rect[3].max(s.rect[3])];- l.frame = union(l.frame, s.frame);- l.ink.extend(s.ink.iter().copied());- l.runs.push((s.text.clone(), l.ink.len(), spaced));- l.ops.push(s.op);- l.ops.extend(s.extra_ops.iter().copied());- l.decodable &= s.decodable;- l.visual_order |= s.visual_order;- l.actual_text |= s.actual_text;- l.clips |= s.state.render_mode >= 4;- if l.unreadable_mode.is_none() {- l.unreadable_mode = s.state.unreadable.as_deref().map(str::to_owned);- }- // Spaces may use a separate subset font; they do not change the visible style.- } else {- lines.push(TextLine {- text: s.text.clone(),- rect: s.rect,- frame: s.frame,- ink: s.ink.clone(),- font: String::from_utf8_lossy(&s.font).into_owned(),- base_font: s.base_font.clone(),- size: s.size,- bold: s.bold,- italic: s.italic,- color: fill_color(&s.state.fill),- decodable: s.decodable,- visual_order: s.visual_order,- face: s.face.clone(),- stream: si,- scope: s.scope,- paint: s.paint.clone(),- logical_order: s.logical_order,- actual_text: s.actual_text,- clips: s.state.render_mode >= 4,- unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),- runs: vec![(s.text.clone(), s.ink.len(), false)],- ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),- origin: Origin {- tm: s.tm.0,- tlm: s.tlm.0,- k: (s.tm.then(&s.state.ctm).0[2].powi(2) + s.tm.then(&s.state.ctm).0[3].powi(2)).sqrt(),- ctm: s.state.ctm.0,- baseline: s.baseline,- x: s.start_x,- state: TextState::of(&s.state),- bt_op: s.bt_op,- bt_state: TextState::of(&s.bt_state),- },- });- }- last = Some((si, Pen::after(&s)));- }- // Content streams draw right-to-left lines in visual order; the editor works in typing order.- for l in lines.iter_mut().filter(|l| !l.logical_order) {- // A visual-order Indic font draws pre-base vowel signs before their consonant.- let shown = l.text.clone();- if l.visual_order && !l.actual_text {- l.text = crate::indic::to_logical(&l.text);- }- l.text = crate::bidi::to_logical(&l.text);- // The runs hold the text in drawing order, which no longer reads as the line does.- if l.text != shown {- l.runs.clear();- }- }- // Lines of only spaces aren't editable text.- lines.retain(|l| !l.text.trim().is_empty());- Ok(lines)-}--/// Joining independent text objects is safe only when they use the same text and graphics-/// transforms and spacing. In particular, a nearby rotated label isn't part of this line.-fn compatible_word(line: &TextLine, shown: &Shown) -> bool {- let within = |a: &[f64], b: &[f64], tolerance: f64| a.iter().zip(b).all(|(a, b)| (a - b).abs() < tolerance);- let same = |a: &[f64], b: &[f64]| within(a, b, 1e-6);- let (a, b) = (&line.origin.state, TextState::of(&shown.state));- // Spacing that differs by less than a thousandth of an em, the unit glyph widths are given in,- // can't be seen. Some producers still write it (`0.0001 Tc` on one word of a line).- let em = shown.state.size.abs() / 1000.0;- line.scope == shown.scope- && line.paint == shown.paint- && same(&line.origin.tm[..4], &shown.tm.0[..4])- && same(&line.origin.ctm, &shown.state.ctm.0)- && within(&[a.char_spacing, a.word_spacing], &[b.char_spacing, b.word_spacing], em.max(1e-6))- && same(&[a.scale, a.rise], &[b.scale, b.rise])- && a.fill.len() == b.fill.len()- && a.fill.iter().zip(&b.fill).all(|(a, b)| a.op == b.op && a.operands == b.operands)-}--/// The line `s` continues, or a new one: `last` is the previous run of the same stream-/// (`bt`, baseline, end x, size).-fn add_shown(lines: &mut Vec<TextLine>, last: &mut Option<Pen>, s: Shown, stream: usize) {- let joins = last.is_some_and(|pen| {- let bt = pen.bt;- lines.last().is_some_and(|l| l.scope == s.scope && l.paint == s.paint && l.logical_order == s.logical_order)- && (bt == s.bt || lines.last().is_some_and(|l| compatible_word(l, &s)))- && (s.text.trim().is_empty() || lines.last().is_some_and(|l| same_font(l, &s.font, &s.base_font, s.face.as_deref())))- && (s.text.trim().is_empty()- || lines.last().is_some_and(|l| {- (s.size - l.size).abs() < 0.01- && s.bold == l.bold- && s.italic == l.italic- && fill_color(&s.state.fill) == l.color- && same_paint(l, &s.state)- }))- && pen.continues(&s, if bt == s.bt { 3.0 } else { 1.5 }).0- });- if joins && let Some(l) = lines.last_mut() {- let gap = last.map_or(0.0, |pen| pen.continues(&s, 0.0).1);- let spaced = gap - s.tracking > l.size * s.state.scale.abs() * 0.2 && !l.text.ends_with(' ') && !s.text.starts_with(' ');- if spaced {- l.text.push(' ');- }- l.text.push_str(&s.text);- l.rect = [l.rect[0].min(s.rect[0]), l.rect[1].min(s.rect[1]), l.rect[2].max(s.rect[2]), l.rect[3].max(s.rect[3])];- l.frame = union(l.frame, s.frame);- l.ink.extend(s.ink.iter().copied());- l.runs.push((s.text.clone(), l.ink.len(), spaced));- l.ops.push(s.op);- l.ops.extend(s.extra_ops.iter().copied());- l.decodable &= s.decodable;- l.visual_order |= s.visual_order;- l.actual_text |= s.actual_text;- l.clips |= s.state.render_mode >= 4;- if l.unreadable_mode.is_none() {- l.unreadable_mode = s.state.unreadable.as_deref().map(str::to_owned);- }- } else {- lines.push(TextLine {- text: s.text.clone(),- rect: s.rect,- frame: s.frame,- ink: s.ink.clone(),- font: String::from_utf8_lossy(&s.font).into_owned(),- base_font: s.base_font.clone(),- size: s.size,- bold: s.bold,- italic: s.italic,- color: fill_color(&s.state.fill),- decodable: s.decodable,- visual_order: s.visual_order,- face: s.face.clone(),- stream,- scope: s.scope,- paint: s.paint.clone(),- logical_order: s.logical_order,- actual_text: s.actual_text,- clips: s.state.render_mode >= 4,- unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),- runs: vec![(s.text.clone(), s.ink.len(), false)],- ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),- origin: Origin {- tm: s.tm.0,- tlm: s.tlm.0,- k: (s.tm.then(&s.state.ctm).0[2].powi(2) + s.tm.then(&s.state.ctm).0[3].powi(2)).sqrt(),- ctm: s.state.ctm.0,- baseline: s.baseline,- x: s.start_x,- state: TextState::of(&s.state),- bt_op: s.bt_op,- bt_state: TextState::of(&s.bt_state),- },- });- }- *last = Some(Pen::after(&s));-}--/// How deep form XObjects nest before reading stops (they may also refer to themselves). The-/// renderer stops at the same depth, so export reads the text the page shows (#3120).-pub const MAX_FORM_DEPTH: usize = 50;--/// The most form XObjects one page's walk enters, at any depth. The depth cap alone still lets-/// a form that draws another form many times fan out exponentially (100 `Do`s on each of 50-/// levels), which would hang export on a hostile PDF. The renderer paints as many forms nested-/// in forms; this budget also counts the forms the page draws itself, so a page that draws one-/// a million times stays bounded too. A label or table cell drawn as a form a few thousand-/// times is read in full (#3120).-pub const MAX_FORM_VISITS: usize = 50_000;--/// One page's walk through the form XObjects it draws: how many it entered (the page's-/// [`MAX_FORM_VISITS`]), the bytes the page's content and forms may still decode to, and whether-/// a limit left a form unread.-pub(crate) struct FormBudget {- visits: usize,- decode: DecodeBudget,- /// A form was left unread because it nests deeper than [`MAX_FORM_DEPTH`], comes past- /// [`MAX_FORM_VISITS`] or past the decode budget: what it draws is missing from the walk.- pub(crate) truncated: bool,-}--impl FormBudget {- /// The walk of a page's forms, spending what `decode` has left after the page's content.- pub(crate) fn new(decode: DecodeBudget) -> Self {- Self { visits: 0, decode, truncated: false }- }-}--/// A form XObject a page draws: its object, content, resources and its matrix composed with the-/// CTM at the `Do`.-pub(crate) struct FormCall {- pub(crate) obj: Option<pdfcraft_cos::ObjRef>,- pub(crate) data: Vec<u8>,- pub(crate) resources: Dict,- pub(crate) ctm: Matrix,-}--/// The form XObject `name` in `resources`, drawn with `ctm`. `None` for images, missing names-/// and forms already being read (`path`), and for forms nested too deep or past the page's-/// budget, which `budget` records as truncated; each form entered counts one visit.-pub(crate) fn form_call(- doc: &Document,- resources: &Dict,- name: &[u8],- ctm: Matrix,- path: &[pdfcraft_cos::ObjRef],- budget: &mut FormBudget,-) -> Option<FormCall> {- let limited = path.len() >= MAX_FORM_DEPTH || budget.visits >= MAX_FORM_VISITS || budget.decode.remaining() == 0;- // Once a limit has cut the page short, refusing the rest costs nothing more.- if limited && budget.truncated {- return None;- }- let xobjects = resources.get(b"XObject").map(|x| doc.resolve(x)).and_then(|x| x.as_dict().cloned())?;- let o = xobjects.get(name)?;- let obj = o.as_ref();- if obj.is_some_and(|r| path.contains(&r)) {- return None;- }- let Object::Stream(s) = &*doc.resolve(o) else { return None };- if s.dict.name(b"Subtype") != Some(b"Form") {- return None;- }- // Only a form left unread loses content; an image at the limit is still read by its caller.- if limited {- budget.truncated = true;- return None;- }- let m = s.dict.get(b"Matrix").map(|m| doc.resolve(m)).and_then(|m| {- let a = m.as_array()?;- let v: Vec<f64> = a.iter().filter_map(|x| doc.resolve(x).as_f64()).collect();- <[f64; 6]>::try_from(v).ok().filter(|v| v.iter().all(|x| x.is_finite()))- });- // A form without its own resources uses the ones it was drawn with (PDF 1.1 files).- let own = s.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned());- let data = match budget.decode.decode(s) {- Ok(data) => data,- Err(_) if budget.decode.remaining() == 0 => {- budget.truncated = true;- return None;- }- Err(_) => Vec::new(),- };- budget.visits = budget.visits.saturating_add(1);- Some(FormCall { obj, data, resources: own.unwrap_or_else(|| resources.clone()), ctm: m.map_or(ctm, |m| Matrix(m).then(&ctm)) })-}--/// The lines a page shows as it reads, including text drawn by form XObjects (which-/// [`text_lines`] leaves out because it can only rewrite the page's own streams). Lines from a-/// form carry a stream number past the page's streams, one per form drawn. The flag is `true`-/// when forms past [`MAX_FORM_DEPTH`] or [`MAX_FORM_VISITS`] were left unread.-fn reading_lines(doc: &Document, page: usize) -> Result<(Vec<TextLine>, bool), EditError> {- struct Walk<'a> {- doc: &'a Document,- lines: Vec<TextLine>,- next_stream: usize,- path: Vec<pdfcraft_cos::ObjRef>,- budget: FormBudget,- }- /// `stream` gives the stream number of the operator at an index of `ops`.- fn walk(w: &mut Walk, ops: &[Op], resources: &Dict, carry: &mut Carry, stream: &dyn Fn(usize) -> usize) -> Result<(), EditError> {- let mut cache = HashMap::new();- let mut invoked = Vec::new();- let properties = resources.get(b"Properties").and_then(|o| w.doc.dict(o)).unwrap_or_default();- let shown = interpret(w.doc, ops, resources, &mut cache, carry, Some(&mut invoked), Some(&properties))?;- let mut last = None;- let mut last_stream = None;- let mut forms = invoked.into_iter().peekable();- for s in shown {- while let Some((_, name, ts)) = forms.next_if(|f| f.0 < s.op) {- enter(w, resources, &name, ts, &mut carry.text_left)?;- // Text after a form starts a new line.- last = None;- }- let si = stream(s.op);- // Text from another stream starts a new line, as when each stream was read alone.- if last_stream.replace(si).is_some_and(|prev| prev != si) {- last = None;- }- add_shown(&mut w.lines, &mut last, s, si);- }- for (_, name, ts) in forms {- enter(w, resources, &name, ts, &mut carry.text_left)?;- }- Ok(())- }- /// `text_left`: the page's text budget, shared with the forms the page draws.- fn enter(w: &mut Walk, resources: &Dict, name: &[u8], ts: Ts, text_left: &mut usize) -> Result<(), EditError> {- let Some(form) = form_call(w.doc, resources, name, ts.ctm, &w.path, &mut w.budget) else { return Ok(()) };- let ops = parse(&form.data).ops;- // The form starts with the graphics state at its `Do`, its own matrix applied.- let mut carry = Carry { ts: Ts { ctm: form.ctm, ..ts }, stack: Vec::new(), marked: Vec::new(), layers: Vec::new(), text_left: *text_left };- let stream = w.next_stream;- w.next_stream = w.next_stream.saturating_add(1);- if let Some(r) = form.obj {- w.path.push(r);- }- walk(w, &ops, &form.resources, &mut carry, &|_| stream)?;- *text_left = carry.text_left;- if form.obj.is_some() {- w.path.pop();- }- Ok(())- }- let p = page_dict(doc, page)?;- let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let mut decode = DecodeBudget::page();- let streams = content_streams_within(doc, &p.dict, &mut decode)?;- let mut w = Walk { doc, lines: Vec::new(), next_stream: streams.len(), path: Vec::new(), budget: FormBudget::new(decode) };- let mut carry = Carry::new();- // Read the page's streams as the one stream they are, in one pass, as rendering and editing- // do: a comment, an operator's operands or a marked-content sequence (its /ActualText too)- // can run on from one stream into the next. Text still counts as the stream its operator- // starts in, which keeps lines from different streams apart.- let pieces = Pieces::join(&streams.into_iter().map(|(_, data)| data).collect::<Vec<_>>());- let ops = pieces.parse().ops;- let stream_of = |i: usize| ops.get(i).map_or(0, |op| pieces.pieces_of(op).0);- walk(&mut w, &ops, &res, &mut carry, &stream_of)?;- let mut lines = w.lines;- // A visual-order Indic font draws pre-base vowel signs before their consonant.- for l in lines.iter_mut().filter(|l| l.visual_order && !l.actual_text) {- let shown = l.text.clone();- l.text = crate::indic::to_logical(&l.text);- if l.text != shown {- l.runs.clear();- }- }- lines.retain(|l| !l.text.trim().is_empty());- Ok((lines, w.budget.truncated))-}--/// Text → the runs that show it: each run's font resource name and the bytes shown in that font.-type Encoder = Box<dyn Fn(&str) -> Option<Vec<(String, Vec<u8>)>>>;--fn is_win_ansi_char(c: char) -> bool {- c == '\t' || pdfcraft_fonts::win_ansi_byte(c).is_some()-}--fn needs_type3(text: &str) -> bool {- text.chars().any(|c| !is_win_ansi_char(c))-}--/// The `/Name` of the Type 3 fonts generated for Japanese text.-const JAPANESE_FONT_NAME: &str = "PCJapanese";-/// The `/Name` of the Type 3 fonts generated for Hebrew text.-const HEBREW_FONT_NAME: &str = "PCHebrew";-/// The `/Name` of the Type 3 fonts generated from the bundled Latin (Inter) face.-const LATIN_FONT_NAME: &str = "PCLatin";--/// Whether `font` is one of those generated fonts (Latin, Japanese or Hebrew): a replacement longer-/// than one of them is split across several, which read back as one line (see [`same_font`]).-fn is_type3_fallback(font: &Dict) -> bool {- font.name(b"Subtype") == Some(b"Type3")- && font- .name(b"Name")- .is_some_and(|n| n == JAPANESE_FONT_NAME.as_bytes() || n == HEBREW_FONT_NAME.as_bytes() || n == LATIN_FONT_NAME.as_bytes())-}--/// The generated font's `/Name` and its resource prefix: the bundled Latin face, Hebrew, or the-/// Japanese ones.-fn fallback_names(face: &CraftFont, hebrew: bool) -> (&'static str, &'static str) {- if hebrew {- (HEBREW_FONT_NAME, "PCHe")- } else if face.family == "Inter" {- (LATIN_FONT_NAME, "PCLat")- } else {- (JAPANESE_FONT_NAME, "PCJp")- }-}--/// Drops the generated fallback fonts ([`is_type3_fallback`]) that nothing on `page` shows any more.-/// Each rewrite generates its own, with the outlines of every character it draws, so without this-/// an earlier rewrite's fonts stay in the page's resources and the file. Only a font dictionary the-/// page owns is changed (a rewrite gives the page its own), and nothing is dropped unless every-/// content stream that may name the page's fonts can be read: the page's own, and those of form-/// XObjects and Type 3 glyphs that have no resources of their own and so use the page's.-fn drop_unused_fallback_fonts(doc: &mut Document, page: usize) {- let Ok(p) = page_dict(doc, page) else { return };- let Some(Object::Dict(mut resources)) = p.dict.get(b"Resources").cloned() else { return };- let Some(mut fonts) = resources.get(b"Font").and_then(|f| doc.dict(f)) else { return };- let generated: Vec<Vec<u8>> =- fonts.iter().filter(|(_, f)| doc.dict(f).is_some_and(|d| is_type3_fallback(&d))).map(|(name, _)| name.clone()).collect();- if generated.is_empty() {- return;- }- let Some(shown) = fonts_shown(doc, &p.dict, &resources) else { return };- let unused: Vec<&Vec<u8>> = generated.iter().filter(|name| !shown.contains(*name)).collect();- if unused.is_empty() {- return;- }- for name in unused {- fonts.remove(name);- }- resources.set(b"Font".to_vec(), Object::Dict(fonts));- // Nothing is lost if this fails: the fonts just stay.- let _ = doc.update_dict(p.obj, |d| d.set(b"Resources".to_vec(), Object::Dict(resources)));-}--/// The font resource names `Tf` selects in the page's content and in the content that uses the-/// page's resources (see [`drop_unused_fallback_fonts`]), or `None` if any of it can't be read.-fn fonts_shown(doc: &Document, page: &Dict, resources: &Dict) -> Option<std::collections::HashSet<Vec<u8>>> {- let mut streams: Vec<Object> = match page.get(b"Contents") {- None => Vec::new(),- Some(c) => match &*doc.resolve(c) {- Object::Array(a) => a.clone(),- _ => vec![c.clone()],- },- };- // Form XObjects without their own resources use the page's, however deeply they are nested- // (ISO 32000-1 §7.8.3), so every form the page can reach is visited.- let mut pending: Vec<Dict> = vec![resources.clone()];- let mut seen = std::collections::HashSet::new();- while let Some(res) = pending.pop() {- for (_, x) in res.get(b"XObject").and_then(|x| doc.dict(x)).unwrap_or_default().iter() {- let Some(r) = x.as_ref() else { continue };- if !seen.insert(r) {- continue;- }- if seen.len() > 4096 {- return None;- }- let Object::Stream(s) = &*doc.get(r) else { continue };- if s.dict.name(b"Subtype") != Some(b"Form") {- continue;- }- match s.dict.get(b"Resources").and_then(|r| doc.dict(r)) {- Some(own) => pending.push(own),- None => streams.push(x.clone()),- }- }- }- // And so do Type 3 glyph procedures without their own (the generated fonts' are outlines only).- for (_, f) in resources.get(b"Font").and_then(|f| doc.dict(f)).unwrap_or_default().iter() {- if let Some(font) = doc.dict(f).filter(|d| d.name(b"Subtype") == Some(b"Type3") && !d.contains(b"Resources") && !is_type3_fallback(d)) {- streams.extend(font.get(b"CharProcs").and_then(|c| doc.dict(c)).unwrap_or_default().iter().map(|(_, proc)| proc.clone()));- }- }- let mut shown = std::collections::HashSet::new();- for stream in streams {- let Object::Stream(s) = &*doc.resolve(&stream) else { return None };- // Strict: a stream only partly read might name a font in the part that wasn't.- let data = s.decoded_strict().ok()?;- for op in parse(&data).ops {- if op.is("Tf")- && let Some(name) = op.operands.first().and_then(|n| n.as_name())- {- shown.insert(name.to_vec());- }- }- }- Some(shown)-}--/// Whether a run shown in `font` (a resource name), with `/BaseFont` `base_font` and the Japanese-/// or Hebrew fallback face it subsets, if any, continues `line`: the same font resource, another-/// resource for the same font (a writer may split one font into several subsets, #3661), or-/// another subset of the same face.-fn same_font(line: &TextLine, font: &[u8], base_font: &str, face: Option<&str>) -> bool {- line.font.as_bytes() == font || same_base_font(&line.base_font, base_font) || (line.face.is_some() && line.face.as_deref() == face)-}--/// Whether a run painted with `ts` continues `line` as it is painted: a line is rewritten in the-/// state of its first run, so a `Tr`, stroke colour or line width that changes partway starts-/// another run (see [`TextState::paint_ops`]; the `gs` parameters are compared as [`Paint`]).-/// The stroke colour, width, dash and cap only count for text that is stroked, so a rule drawn-/// between two words doesn't split their line. They are compared as values, wherever they were-/// set: two ExtGStates with the same settings under other names still continue a line.-///-/// Only the visible modes (`Tr` 0–2) that `paint_ops` restates are compared: a line that goes on-/// as invisible or clipping text stays one line, which the clipping refusal reads whole (#3447).-fn same_paint(line: &TextLine, ts: &Ts) -> bool {- let a = &line.origin.state;- let visible = |m: i64| (0..=2).contains(&m);- let same_mode = a.render_mode == ts.render_mode || !visible(a.render_mode) || !visible(ts.render_mode);- let stroked = matches!((a.render_mode, ts.render_mode), (1 | 2, 1 | 2));- let outline = a.stroke == ts.stroke && a.line_width == ts.line_width && a.dash == ts.dash && a.line_cap == ts.line_cap;- same_mode && (!stroked || outline)-}--/// Whether two `/BaseFont` names name the same font: a subset's six-letter tag and `+` prefix do-/// not change the font (ISO 32000-2 §9.6.4), so `ABCDEF+Arial` and `GHIJKL+Arial` are one font.-/// A name that is missing, or only a tag (`ABCDEF+`), names no font and matches nothing.-fn same_base_font(a: &str, b: &str) -> bool {- let (a, b) = (strip_subset_tag(a), strip_subset_tag(b));- !a.is_empty() && a == b-}--/// `ABCDEF+Arial` → `Arial`. A name without a subset tag is returned unchanged.-fn strip_subset_tag(name: &str) -> &str {- let bytes = name.as_bytes();- let is_tag = bytes.get(6) == Some(&b'+') && bytes.get(..6).is_some_and(|tag| tag.iter().all(u8::is_ascii_uppercase));- if is_tag { name.get(7..).unwrap_or(name) } else { name }-}--fn source_family(base_font: &str) -> crate::added::Family {- let name = base_font.to_ascii_lowercase();- if ["courier", "mono", "consolas", "menlo", "monaco", "lucida console"].iter().any(|s| name.contains(s)) {- crate::added::Family::Courier- } else if !name.contains("sans")- && ["times", "serif", "roman", "mincho", "cambria", "georgia", "palatino", "garamond"].iter().any(|s| name.contains(s))- {- crate::added::Family::Times- } else {- crate::added::Family::Helvetica- }-}--const MAX_TYPE3_GLYPHS: usize = 240;--/// The generated fonts for one replacement: one per run of at most `max_glyphs` unique characters,-/// in order of first appearance.-#[derive(Clone)]-struct Type3Fallback {- /// The family its glyphs come from ("Shippori Mincho").- family: &'static str,- /// The fonts' resource names in order; the first is `PCJp` (`PCLat` for the bundled Latin- /// face, `PCHe` for Hebrew text).- names: Vec<String>,- /// Every unique character with its advance (em), in order of first appearance.- widths: Vec<(char, f64)>,- /// Where each character is shown: the index of its font in `names`, and its code there.- codes: HashMap<char, (usize, u8)>,-}--/// One glyph of a generated font: its code there, its character, its glyph procedure and advance.-struct Type3Glyph {- code: u8,- ch: char,- path: Vec<u8>,- width: f64,-}--fn pdf_num(v: f64) -> String {- if v.fract() == 0.0 { format!("{v:.0}") } else { format!("{v:.4}").trim_end_matches('0').trim_end_matches('.').to_string() }-}--fn type3_path(face: &CraftFont, ch: char) -> Result<(Vec<u8>, f64), EditError> {- let glyph = japanese_glyph_from(face, ch).map_err(|e| match e {- GlyphError::NoFont => no_japanese_font(),- GlyphError::Missing => EditError::Invalid(format!("the {} fallback font has no glyph for U+{:04X}", face.family, ch as u32)),- GlyphError::TooComplex => EditError::Invalid(format!("the {} fallback glyph U+{:04X} is too complex", face.family, ch as u32)),- })?;- let (dx, width) = proportional(ch, &glyph);- let scale = 1000.0;- // d1 is `wx wy llx lly urx ury` (ISO 32000-2 §9.6.4) with a box enclosing the glyph;- // Acrobat draws a bullet in place of a glyph whose d1 is malformed.- let b = if glyph.contours.is_empty() { [0.0; 4] } else { glyph.bbox };- let mut out = format!(- "{} 0 {} {} {} {} d1\n",- pdf_num(width * scale),- pdf_num(((b[0] + dx) * scale).floor()),- pdf_num((b[1] * scale).floor()),- pdf_num(((b[2] + dx) * scale).ceil()),- pdf_num((b[3] * scale).ceil())- )- .into_bytes();- for contour in glyph.contours {- let Some(first) = contour.first() else { continue };- out.extend_from_slice(format!("{} {} m\n", pdf_num((first[0] + dx) * scale), pdf_num(first[1] * scale)).as_bytes());- for p in contour.iter().skip(1) {- out.extend_from_slice(format!("{} {} l\n", pdf_num((p[0] + dx) * scale), pdf_num(p[1] * scale)).as_bytes());- }- out.extend_from_slice(b"h\n");- }- out.extend_from_slice(b"f\n");- Ok((out, width))-}--/// Side bearing (em) given to a respaced glyph on each side.-const SIDE_BEARING: f64 = 0.05;--/// Shift and advance for a fallback glyph. Japanese faces draw Cyrillic and Greek full-width-/// (one em each, as in JIS X 0208) and have no proportional (`palt`) metrics for them, so a-/// word set that way reads as letter-spaced. Those letters get their ink width plus a side-/// bearing instead; everything else keeps the face's own advance.-fn proportional(ch: char, glyph: &pdfcraft_fonts::GlyphOutline) -> (f64, f64) {- let respace = matches!(ch, '\u{0370}'..='\u{03FF}' | '\u{0400}'..='\u{052F}' | '\u{1F00}'..='\u{1FFF}');- let ink = glyph.bbox[2] - glyph.bbox[0];- if !respace || glyph.contours.is_empty() || !(ink > 0.0 && ink < glyph.width) {- return (0.0, glyph.width);- }- (SIDE_BEARING - glyph.bbox[0], ink + 2.0 * SIDE_BEARING)-}--fn unicode_hex(ch: char) -> String {- let mut units = [0u16; 2];- let encoded = ch.encode_utf16(&mut units);- encoded.iter().map(|u| format!("{u:04X}")).collect()-}--/// The same outline for a face that may simply lack the glyph: `None` then, so the caller can try-/// the next face (and report the character once none of them has it).-fn type3_glyph(face: &CraftFont, ch: char) -> Result<Option<(Vec<u8>, f64)>, EditError> {- match japanese_glyph_from(face, ch) {- Err(GlyphError::Missing) => Ok(None),- _ => type3_path(face, ch).map(Some),- }-}--/// No face this build has can draw `text`. Only Japanese text is about the Japanese face: other-/// characters are missing from the paragraph's font, and choosing a font that has them works too.-fn no_fallback_font(text: &str) -> EditError {- if text.chars().any(needs_japanese) {- return no_japanese_font();- }- let Some(ch) = text.chars().find(|c| !c.is_whitespace() && !is_win_ansi_char(*c)) else { return no_japanese_font() };- EditError::Invalid(format!(- "the paragraph's font has no glyph for {ch} (U+{:04X}) and this build has no fallback font for it; \- choose a font that has it (Load font… or Installed fonts…), or use an official release, which includes \- PdfCraft's fallback fonts (to build them in, set CRAFT_FONTS_DIR to a craft-fonts checkout)",- u32::from(ch)- ))-}--/// The character the craft-fonts Japanese faces are for: kana, CJK ideographs and their compatibility-/// and full-width forms.-fn needs_japanese(ch: char) -> bool {- matches!(u32::from(ch), 0x3000..=0x30FF | 0x3400..=0x4DBF | 0x4E00..=0x9FFF | 0xF900..=0xFAFF | 0xFF00..=0xFFEF)-}--/// The chosen face has no outline for `ch`, and neither has any other: say which character it is and-/// what the writer can do about it. A CJK character without a Japanese face in the build is about-/// that build input, which is the one answer that changes it.-fn no_glyph_for(face: &CraftFont, ch: char) -> EditError {- if needs_japanese(ch) && pdfcraft_fonts::document_japanese_font().is_none() {- return no_japanese_font();- }- EditError::Invalid(format!(- "the {} fallback font has no glyph for {ch} (U+{:04X}), and no fallback face covers the text; \- choose a font that has it (Load font… or Installed fonts…), or use an official release, which includes \- PdfCraft's fallback fonts (to build them in, set CRAFT_FONTS_DIR to a craft-fonts checkout)",- face.family,- u32::from(ch)- ))-}--/// This build has no Japanese face to draw replacement text with.-fn no_japanese_font() -> EditError {- EditError::Invalid(- "this text needs PdfCraft's Japanese fallback font, which this build doesn't include \- (official releases do; to build it in, set CRAFT_FONTS_DIR to a craft-fonts checkout)"- .into(),- )-}--/// The first of `faces` (best match first) that has a glyph for every one of `chars`, else the first.-fn fallback_face<'a>(faces: &[&'a CraftFont], chars: &[char], has_glyph: impl Fn(&CraftFont, char) -> bool) -> Option<&'a CraftFont> {- faces.iter().copied().find(|face| chars.iter().all(|ch| has_glyph(face, *ch))).or_else(|| faces.first().copied())-}--/// This build has no Hebrew face to draw replacement text with.-fn no_hebrew_font() -> EditError {- EditError::Invalid(- "this text needs PdfCraft's Hebrew fallback font (Noto Sans Hebrew), which this build doesn't include \- (to build it in, set CRAFT_FONTS_DIR to a craft-fonts checkout that has it)"- .into(),- )-}--/// The faces a Type 3 replacement may draw `text` with, best first. Text with Hebrew takes the-/// Hebrew face first (its Latin and digits too, so a line keeps one look), then the Japanese faces-/// and the bundled Latin one for anything it lacks; other text takes the Japanese faces, and the-/// bundled Latin face behind them, which covers the Latin, Greek and Cyrillic letters they lack-/// (#2593: the Japanese faces have no қ, ғ, ҳ, ә, ө, ү, ұ or һ).-fn type3_faces(text: &str, family: crate::added::Family, bold: bool) -> Result<(Vec<&'static CraftFont>, bool), EditError> {- let japanese = pdfcraft_fonts::document_japanese_fonts_for_style(family == crate::added::Family::Times, bold);- let latin = pdfcraft_fonts::document_latin_fonts(bold);- if !text.chars().any(crate::bidi::is_hebrew) {- return Ok((japanese.into_iter().chain(latin).collect(), false));- }- // Points are drawn on their letter with the font's positioning, which a one-glyph-per-- // character Type 3 font can't do; refuse rather than print them beside the letter.- if text.chars().any(crate::bidi::is_hebrew_mark) {- return Err(EditError::Invalid("Hebrew points (niqqud) can't be written into a PDF yet; type the text without them".into()));- }- let hebrew = pdfcraft_fonts::document_hebrew_font(bold).ok_or_else(no_hebrew_font)?;- Ok((std::iter::once(hebrew).chain(japanese).chain(latin).collect(), true))-}--fn type3_font(- doc: &mut Document,- fonts_res: &mut Dict,- text: &str,- family: crate::added::Family,- bold: bool,- max_glyphs: usize,-) -> Result<Type3Fallback, EditError> {- let (faces, hebrew) = type3_faces(text, family, bold)?;- // Each unique character once, in order of first appearance.- let mut chars = Vec::new();- let mut seen = std::collections::HashSet::new();- for ch in text.chars() {- if seen.insert(ch) {- chars.push(ch);- }- }- if chars.is_empty() {- return Err(EditError::Invalid("replacement text is empty".into()));- }- // The faces differ in coverage (e.g. of Cyrillic), so use the best face that has every- // character. When none has them all, the best face reports the character it lacks. Hebrew- // text keeps the Hebrew face and takes each character it lacks from the next face that has it.- let face = if hebrew { faces.first().copied() } else { fallback_face(&faces, &chars, |face, ch| japanese_glyph_from(face, ch).is_ok()) }- .ok_or_else(|| no_fallback_font(text))?;- let others: &[&CraftFont] = if hebrew { faces.get(1..).unwrap_or_default() } else { &[] };- // Every outline is read before the document is touched, so a character that fails leaves it- // as it was. Each font takes the next `per_font` characters; codes restart at 1 in each.- let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);- let mut glyphs = Vec::with_capacity(chars.len());- for (i, ch) in chars.into_iter().enumerate() {- // The chosen face first, then the faces after it (Hebrew text takes a character the Hebrew- // face lacks from the next face that has it); a character no face draws is reported once.- let mut drawn = type3_glyph(face, ch)?;- for f in others.iter().copied() {- if drawn.is_some() {- break;- }- drawn = type3_glyph(f, ch)?;- }- let Some((path, width)) = drawn else { return Err(no_glyph_for(face, ch)) };- let code = u8::try_from((i % per_font).saturating_add(1))- .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;- glyphs.push(Type3Glyph { code, ch, path, width });- }- Ok(write_type3_glyphs(doc, fonts_res, face, hebrew, glyphs, per_font))-}--/// Write already validated outlines; callers can prepare every face before adding any objects.-fn write_type3_glyphs(- doc: &mut Document,- fonts_res: &mut Dict,- face: &CraftFont,- hebrew: bool,- glyphs: Vec<Type3Glyph>,- per_font: usize,-) -> Type3Fallback {- let per_font = per_font.clamp(1, MAX_TYPE3_GLYPHS);- let mut codes = HashMap::with_capacity(glyphs.len());- let mut widths = Vec::with_capacity(glyphs.len());- let mut names = Vec::new();- let mut glyphs = glyphs.into_iter();- loop {- let group: Vec<Type3Glyph> = glyphs.by_ref().take(per_font).collect();- if group.is_empty() {- break;- }- for glyph in &group {- codes.insert(glyph.ch, (names.len(), glyph.code));- widths.push((glyph.ch, glyph.width));- }- names.push(add_type3_font(doc, fonts_res, face, hebrew, group));- }- Type3Fallback { family: face.family, names, widths, codes }-}--/// Adds one generated font whose codes 1 to `glyphs.len()` show `glyphs`, and returns its resource-/// name (`PCLat`, `PCJp`, then `PCJp1`, ...; `PCHe`, ... for Hebrew text). Nothing here can fail: the-/// outlines were read already.-fn add_type3_font(doc: &mut Document, fonts_res: &mut Dict, face: &CraftFont, hebrew: bool, glyphs: Vec<Type3Glyph>) -> String {- let last_char = glyphs.len();- let mut charprocs = Dict::new();- let mut widths = Vec::with_capacity(last_char);- let mut differences = vec![Object::Int(1)];- let mut cmap = String::from(- "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CMapType 2 def\n1 begincodespacerange\n<01> <FF>\nendcodespacerange\n",- );- cmap.push_str(&format!("{last_char} beginbfchar\n"));- for glyph in glyphs {- let glyph_name = format!("g{:02X}", glyph.code);- let mut pd = Dict::new();- pd.set(b"Length".to_vec(), glyph.path.len() as i64);- let proc_ref = doc.add(Object::Stream(Stream::from_raw(pd, glyph.path)));- charprocs.set(glyph_name.as_bytes().to_vec(), Object::Ref(proc_ref));- differences.push(Object::name(&glyph_name));- widths.push(Object::Real((glyph.width * 1000.0).round()));- cmap.push_str(&format!("<{:02X}> <{}>\n", glyph.code, unicode_hex(glyph.ch)));- }- cmap.push_str("endbfchar\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");- let mut cmap_dict = Dict::new();- cmap_dict.set(b"Length".to_vec(), cmap.len() as i64);- let cmap_ref = doc.add(Object::Stream(Stream::from_raw(cmap_dict, cmap.into_bytes())));- let mut encoding = Dict::new();- encoding.set(b"Type".to_vec(), Object::name("Encoding"));- encoding.set(b"Differences".to_vec(), Object::Array(differences));- let mut font = Dict::new();- font.set(b"Type".to_vec(), Object::name("Font"));- font.set(b"Subtype".to_vec(), Object::name("Type3"));- let (font_name, prefix) = fallback_names(face, hebrew);- font.set(b"Name".to_vec(), Object::name(font_name));- let mut descriptor = Dict::new();- descriptor.set(b"Type".to_vec(), Object::name("FontDescriptor"));- descriptor.set(b"FontName".to_vec(), Object::name(&format!("{}-{}", face.family, face.style).replace(' ', "")));- descriptor.set(b"FontFamily".to_vec(), Object::String(PdfString::literal(face.family.as_bytes().to_vec())));- descriptor.set(b"Flags".to_vec(), Object::Int(if face.family.contains("Mincho") { 6 } else { 4 }));- descriptor.set(b"ItalicAngle".to_vec(), Object::Int(0));- // PDF 1.7 tables 5.9 and 5.19: a Type 3 descriptor is indirect; Ascent/Descent may be omitted.- font.set(b"FontDescriptor".to_vec(), Object::Ref(doc.add(Object::Dict(descriptor))));- font.set(b"FontBBox".to_vec(), Object::Array(vec![Object::Int(0), Object::Int(-300), Object::Int(1000), Object::Int(1000)]));- font.set(- b"FontMatrix".to_vec(),- Object::Array(vec![Object::Real(0.001), Object::Int(0), Object::Int(0), Object::Real(0.001), Object::Int(0), Object::Int(0)]),- );- font.set(b"FirstChar".to_vec(), Object::Int(1));- font.set(b"LastChar".to_vec(), Object::Int(last_char as i64));- font.set(b"Widths".to_vec(), Object::Array(widths));- font.set(b"Encoding".to_vec(), Object::Dict(encoding));- font.set(b"CharProcs".to_vec(), Object::Dict(charprocs));- font.set(b"ToUnicode".to_vec(), Object::Ref(cmap_ref));- let mut name = String::from(prefix);- let mut suffix = 0usize;- while fonts_res.contains(name.as_bytes()) {- suffix = suffix.saturating_add(1);- name = format!("{prefix}{suffix}");- }- fonts_res.set(name.as_bytes().to_vec(), Object::Dict(font));- name-}--/// The runs that show `text` in the fallback: consecutive characters in one font form one run, so-/// a font is switched only where the text moves to another font. `None` if a character has no code.-fn type3_encode(fallback: &Type3Fallback, text: &str) -> Option<Vec<(String, Vec<u8>)>> {- let mut runs: Vec<(usize, Vec<u8>)> = Vec::new();- for ch in text.chars() {- let (font, code) = *fallback.codes.get(&ch)?;- match runs.last_mut() {- Some((last, bytes)) if *last == font => bytes.push(code),- _ => runs.push((font, vec![code])),- }- }- runs.into_iter().map(|(font, bytes)| Some((fallback.names.get(font)?.clone(), bytes))).collect()-}--/// The source font's own TrueType/OpenType program, when the document embeds a complete one whose-/// licence allows editable embedding. A subset (an `ABCDEF+` name) is left out: a character can keep-/// its mapping there after the subsetter dropped its outline.-fn source_program(doc: &Document, fonts: &Dict, name: &str) -> Option<Vec<u8>> {- let font = fonts.get(name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned())?;- let base = Metrics::from_dict(doc, &font).base_font;- if base.split_once('+').is_some_and(|(tag, _)| tag.len() == 6 && tag.bytes().all(|b| b.is_ascii_uppercase())) {- return None;- }- let bytes = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)?;- pdfcraft_fonts::embedding::validate(&bytes).is_ok().then_some(bytes)-}--/// Whether `text` has characters `line`'s font can't encode that its own program can draw.-fn source_program_completes(doc: &Document, fonts: &Dict, line: &TextLine, text: &str) -> bool {- let Some(metrics) = fonts.get(line.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|f| Metrics::from_dict(doc, &f)) else {- return false;- };- let missing: String = text.chars().filter(|c| !c.is_whitespace() && !source_encodes(&metrics, &c.to_string())).collect();- !missing.is_empty() && source_program(doc, fonts, &line.font).is_some_and(|bytes| pdfcraft_fonts::embedding::covers(&bytes, &missing))-}--/// A subset may contain all the letters but no space glyph: producers use another subset-/// or a positioning operator for spaces. Do the same instead of substituting the whole font.-fn source_encodes(metrics: &Metrics, text: &str) -> bool {- text.split(' ').all(|word| metrics.encode(word).is_some())-}--#[cfg(test)]-thread_local! {- /// How often [`source_space`] ran on this thread, for the test that pins it out of per-character loops.- pub(crate) static SOURCE_SPACE_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };-}--fn source_space(doc: &Document, fonts: &Dict, metrics: &Metrics) -> f64 {- #[cfg(test)]- SOURCE_SPACE_CALLS.with(|c| c.set(c.get().saturating_add(1)));- let width = |m: &Metrics| m.encode(" ").map(|b| m.codes(&b).iter().map(|(c, _)| m.width(*c)).sum::<f64>());- if let Some(w) = width(metrics) {- return w;- }- let family = metrics.base_font.rsplit('+').next().unwrap_or(&metrics.base_font);- for (_, font) in fonts.iter() {- if let Some(dict) = doc.resolve(font).as_dict() {- let m = Metrics::from_dict(doc, dict);- if m.base_font.rsplit('+').next() == Some(family)- && let Some(w) = width(&m)- {- return w;- }- }- }- 0.33-}--fn source_width(metrics: &Metrics, text: &str, size: f64, space: f64, char_spacing: f64, word_spacing: f64) -> f64 {- if let Some(bytes) = metrics.encode(text) {- // PDF word spacing applies only to single-byte code 32, even for a Unicode space.- return metrics- .codes(&bytes)- .iter()- .map(|(c, len)| metrics.width(*c) * size + char_spacing + if metrics.is_space(*c, *len) { word_spacing } else { 0.0 })- .sum();- }- let words: f64 = text- .split(' ')- .filter_map(|w| metrics.encode(w))- .map(|b| metrics.codes(&b).iter().map(|(c, _)| metrics.width(*c) * size + char_spacing).sum::<f64>())- .sum();- words + text.matches(' ').count() as f64 * (space * size + char_spacing + word_spacing)-}--fn source_show(metrics: &Metrics, text: &str, size: f64, space: f64, char_spacing: f64, word_spacing: f64) -> Result<Vec<Op>, EditError> {- if let Some(bytes) = metrics.encode(text) {- return Ok(vec![Op::new("Tj", vec![Object::String(PdfString::literal(bytes))])]);- }- let adjustment = -1000.0 * (space + (char_spacing + word_spacing) / size);- if !adjustment.is_finite() {- return Err(EditError::Invalid("the source font's space advance is invalid".into()));- }- let mut out = Vec::new();- for (i, word) in text.split(' ').enumerate() {- if i > 0 {- out.push(Op::new("TJ", vec![Object::Array(vec![pdfcraft_content::num(adjustment)])]));- }- if !word.is_empty() {- let bytes = metrics.encode(word).ok_or_else(|| EditError::Invalid("the source font cannot show the replacement text".into()))?;- out.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));- }- }- Ok(out)-}--/// Replace the text of line `line` (an index into [`text_lines`]) on `page` with `text`.-pub fn replace_line(doc: &mut Document, page: usize, line: usize, text: &str) -> Result<LineEdit, EditError> {- let edit = replace_line_with_limit(doc, page, line, text, MAX_TYPE3_GLYPHS)?;- drop_unused_fallback_fonts(doc, page);- Ok(edit)-}--/// Refuses a rewrite that would remove text drawn as a clipping path (`4 Tr` to `7 Tr`). Such-/// glyphs are not ink but a mask, and whatever is painted through them takes their shape.-/// Removing the glyphs removes the mask, and the fill or image behind floods its own rectangle-/// instead -- the artwork is destroyed, in a file that still opens without a warning (#3429).-/// `clear_block` already refuses these for the same reason.-///-/// Every line the rewrite drops is checked, not only the one being replaced: a line's runs need-/// not share a rendering mode (see [`TextLine::clips`]), and [`coincident_ops`] drops a whole-/// overlapping line without regard to its mode -- so a mask could go with text that is ink.-fn refuse_clipping_text(lines: &[TextLine], dropped: &std::collections::HashSet<usize>) -> Result<(), EditError> {- if lines.iter().any(|l| l.clips && l.ops.iter().any(|op| dropped.contains(op))) {- return Err(EditError::Invalid("text used as a clipping path cannot be edited: its glyphs mask the artwork behind them".into()));- }- Ok(())-}--/// [`replace_line`] with the most unique characters one generated font may hold (tests lower it).-pub(crate) fn replace_line_with_limit(doc: &mut Document, page: usize, line: usize, text: &str, max_glyphs: usize) -> Result<LineEdit, EditError> {- let text = text.replace(['\n', '\r'], " ");- let lines = text_lines(doc, page)?;- let target = lines.get(line).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no line {}", page + 1, line + 1)))?;- target.ensure_editable()?;- // Copies of the line drawn on the same baseline go with it, so the replacement is all that- // shows. Which operators go is settled here, before any font is generated, so that a refusal- // leaves the document untouched.- let mut drops = coincident_ops(&lines, &[&target]);- drops.extend(target.ops.iter().copied());- refuse_clipping_text(&lines, &drops)?;- let p = page_dict(doc, page)?;- let mut res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let mut fonts_res = res.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();- let streams = content_streams(doc, &p.dict)?;- let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());- let ops = pieces.parse().ops;- let first = target.ops.first().copied().filter(|i| *i < ops.len()).ok_or_else(|| EditError::Invalid("the page's content changed".into()))?;- // The line's own font, when it can show every character.- let font = fonts_res.get(target.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));- let visual_indic = font.as_ref().is_some_and(|m| m.visual_order) || target.visual_order;- let indic_text = if visual_indic { crate::indic::to_visual(&text) } else { text.clone() };- // Typed in logical order; drawn left to right (right-to-left runs reversed).- let shown = crate::bidi::to_visual(&indic_text);- let reused = font.as_ref().filter(|m| source_encodes(m, &shown));- let mut substituted = None;- let mut replacement: Vec<Op> = Vec::new();- // ' and " also move to the next line; keep that.- match ops[first].op.as_slice() {- b"'" => replacement.push(Op::new("T*", vec![])),- b"\"" => {- replacement.push(Op::new("Tw", vec![ops[first].operands.first().cloned().unwrap_or(Object::Int(0))]));- replacement.push(Op::new("Tc", vec![ops[first].operands.get(1).cloned().unwrap_or(Object::Int(0))]));- replacement.push(Op::new("T*", vec![]));- }- _ => {}- }- match reused {- Some(metrics) => replacement.extend(source_show(- metrics,- &shown,- target.origin.state.font.as_ref().map_or(target.size, |(_, size)| *size),- source_space(doc, &fonts_res, metrics),- target.origin.state.char_spacing,- target.origin.state.word_spacing,- )?),- None => {- let fallback_shown = crate::bidi::to_visual(&text);- if needs_type3(&text) {- let fallback = type3_font(doc, &mut fonts_res, &text, source_family(&target.base_font), target.bold, max_glyphs)?;- let runs = type3_encode(&fallback, &fallback_shown)- .ok_or_else(|| EditError::Invalid(format!("\"{text}\" can't be shown by the {} fallback", fallback.family)))?;- let size = font_size_before(&ops, first).unwrap_or(target.size);- for (name, bytes) in runs {- replacement.push(Op::new("Tf", vec![Object::name(&name), pdfcraft_content::num(size)]));- replacement.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));- }- replacement.push(Op::new("Tf", vec![Object::name(&target.font), pdfcraft_content::num(size)]));- substituted = Some(format!("{} Type3", fallback.family));- } else {- let win = pdfcraft_fonts::win_ansi(&fallback_shown);- // WinAnsi turns what it can't show into '?'; refuse rather than print the wrong thing.- let back: String = win.iter().map(|b| char::from_u32(u32::from(*b)).unwrap_or('?')).collect();- if fallback_shown.chars().zip(back.chars()).any(|(a, b)| b == '?' && a != '?') {- return Err(EditError::Invalid(format!("\"{text}\" has characters neither {} nor Helvetica can show", target.base_font)));- }- // The size in text space: the current Tf's size.- let size = font_size_before(&ops, first).unwrap_or(target.size);- let family = source_family(&target.base_font);- let base = family.base_font(target.bold, target.italic);- let substitute_name = format!("PCEd{}", base.replace('-', ""));- replacement.push(Op::new("Tf", vec![Object::name(&substitute_name), pdfcraft_content::num(size)]));- replacement.push(Op::new("Tj", vec![Object::String(PdfString::literal(win))]));- replacement.push(Op::new("Tf", vec![Object::name(&target.font), pdfcraft_content::num(size)]));- substituted = Some(base.to_string());- let mut f = Dict::new();- f.set(b"Type".to_vec(), Object::name("Font"));- f.set(b"Subtype".to_vec(), Object::name("Type1"));- f.set(b"BaseFont".to_vec(), Object::name(base));- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));- fonts_res.set(substitute_name.into_bytes(), Object::Dict(f));- }- }- }- // Rebuild: the line's first operator becomes the replacement, its others go.- let new_data = splice(&pieces, &ops, |i| if i == first { (std::mem::take(&mut replacement), false) } else { (Vec::new(), !drops.contains(&i)) });- let contents = rewritten_contents(doc, &streams, new_data);- let page_ref = p.obj;- if substituted.is_some() {- res.set(b"Font".to_vec(), Object::Dict(fonts_res));- }- doc.update_dict(page_ref, |d| {- d.set(b"Contents".to_vec(), contents);- if substituted.is_some() {- d.set(b"Resources".to_vec(), Object::Dict(res));- }- })?;- Ok(LineEdit { substituted })-}--/// The size of the last `Tf` before operator `at`.-fn font_size_before(ops: &[Op], at: usize) -> Option<f64> {- ops[..at].iter().rev().find(|o| o.is("Tf")).and_then(|o| o.num(1))-}--/// Operators of every line that is another drawing of one of `targets` (fake bold, an invisible-/// text layer). A surviving copy would show the old text under the replacement.-///-/// A copy overlaps a target by more than half the smaller box and sits on the same baseline-/// (within the tolerance that joins showing operators onto one line). A neighbouring line can-/// share box area when the leading is tighter than the font's ascent plus descent; its baseline-/// is farther away, so it stays.-fn coincident_ops(lines: &[TextLine], targets: &[&TextLine]) -> std::collections::HashSet<usize> {- let area = |r: [f64; 4]| ((r[2] - r[0]) * (r[3] - r[1])).max(0.0);- let mut drop = std::collections::HashSet::new();- for line in lines {- let copy = targets.iter().any(|target| {- let same_text = line.text.trim() == target.text.trim() || (line.origin.state.render_mode == 3) != (target.origin.state.render_mode == 3);- same_text && overlaps_half(line.rect, target.rect, area) && on_same_baseline(line, target)- });- if copy {- drop.extend(line.ops.iter().copied());- }- }- drop-}--fn overlaps_half(a: [f64; 4], b: [f64; 4], area: impl Fn([f64; 4]) -> f64) -> bool {- let ix = (b[2].min(a[2]) - b[0].max(a[0])).max(0.0);- let iy = (b[3].min(a[3]) - b[1].max(a[1])).max(0.0);- let small = area(b).min(area(a));- small > 0.0 && ix * iy / small > 0.5-}--/// Perpendicular distance between baselines, in user space. Horizontal text compares height;-/// turned text compares the distance across the writing direction.-fn on_same_baseline(line: &TextLine, target: &TextLine) -> bool {- let (dir, target_dir) = (line.direction(), target.direction());- let same_dir = (dir.0 - target_dir.0).abs() < 1e-3 && (dir.1 - target_dir.1).abs() < 1e-3;- let same_size = line.size.min(target.size) >= line.size.max(target.size) * 0.8;- let angle = target.rotation().to_radians();- let (sin, cos) = if angle.is_finite() { angle.sin_cos() } else { (0.0, 1.0) };- let dx = line.origin.x - target.origin.x;- let dy = line.origin.baseline - target.origin.baseline;- let offset = dx.mul_add(-sin, dy * cos).abs();- let size = line.size.min(target.size).max(1.0);- same_dir && same_size && offset.is_finite() && offset < size * 0.3-}--/// How a listing of [`text_blocks`] records a paragraph so that it can be found again.-///-/// The index of a paragraph is its position in a list regrouped from geometry on every read, so-/// an edit that merges or splits paragraphs makes the same index name another one (#2516). A key-/// names the paragraph by what it says and where it is; a paragraph that no longer exists as-/// such has no match, instead of a neighbour taking its place.-#[derive(Clone, Debug, PartialEq)]-pub struct BlockKey {- text: String,- rect: [f64; 4],-}--impl BlockKey {- /// Two boxes are the same box within this many points.- const TOLERANCE: f64 = 0.01;-- pub fn of(block: &TextBlock) -> Self {- Self { text: block.text.clone(), rect: block.rect }- }-- /// The paragraph's box when it was recorded (user space).- pub fn rect(&self) -> [f64; 4] {- self.rect- }-- /// The paragraph in `blocks` with this text and box. `hint` is tried first, so two- /// paragraphs drawn on top of one another are told apart by their order.- pub fn find(&self, blocks: &[TextBlock], hint: usize) -> Option<usize> {- let matches = |b: &TextBlock| b.text == self.text && b.rect.iter().zip(&self.rect).all(|(a, b)| (a - b).abs() <= Self::TOLERANCE);- match blocks.get(hint) {- Some(b) if matches(b) => Some(hint),- _ => blocks.iter().position(matches),- }- }-}--/// The paragraph in `blocks` whose box overlaps `rect` the most, if any overlaps it at all. An-/// edit rewrites a paragraph in place, so this is the paragraph it became.-pub fn block_overlapping(blocks: &[TextBlock], rect: [f64; 4]) -> Option<usize> {- // `f64::min` and `max` skip a NaN, which would make a box that isn't a number overlap anything.- let area = |b: &TextBlock| {- if !rect.iter().chain(&b.rect).all(|v| v.is_finite()) {- return 0.0;- }- let w = b.rect[2].min(rect[2]) - b.rect[0].max(rect[0]);- let h = b.rect[3].min(rect[3]) - b.rect[1].max(rect[1]);- if w > 0.0 && h > 0.0 { w * h } else { 0.0 }- };- blocks.iter().enumerate().map(|(i, b)| (i, area(b))).filter(|(_, a)| *a > 0.0).max_by(|(_, a), (_, b)| a.total_cmp(b)).map(|(i, _)| i)-}--/// The paragraphs on a page (0-based).-pub fn text_blocks(doc: &Document, page: usize) -> Result<Vec<TextBlock>, EditError> {- let lines = text_lines(doc, page)?;- Ok(group_blocks(&lines))-}--/// Remove a paragraph's glyphs for a temporary editor background. Numeric TJ adjustments-/// preserve the text matrix, so unselected text positioned relative to it stays in place.-/// Call this on a clone: it is a preview operation, not a document edit.-pub fn clear_block(doc: &mut Document, page: usize, block: usize) -> Result<(), EditError> {- let lines = text_lines(doc, page)?;- let blocks = group_blocks(&lines);- let target = blocks.get(block).ok_or_else(|| EditError::Invalid("the paragraph no longer exists".into()))?;- let targets: Vec<&TextLine> = target.lines.iter().filter_map(|i| lines.get(*i)).collect();- targets.iter().try_for_each(|line| line.ensure_editable())?;- let mut drops = coincident_ops(&lines, &targets);- drops.extend(target.lines.iter().filter_map(|i| lines.get(*i)).flat_map(|l| l.ops.iter().copied()));- let p = page_dict(doc, page)?;- let res = p.dict.get(b"Resources").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();- let streams = content_streams(doc, &p.dict)?;- let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());- let ops = pieces.parse().ops;- let shown = interpret(doc, &ops, &res, &mut HashMap::new(), &mut Carry::new(), None, None)?;- let mut patches = HashMap::new();- for s in shown.into_iter().filter(|s| drops.contains(&s.op)) {- if s.state.render_mode >= 4 {- return Err(EditError::Invalid("text used as a clipping path cannot be previewed for editing".into()));- }- let denominator = s.state.size * s.state.scale;- let adjustment = if denominator != 0.0 { -1000.0 * s.advance / denominator } else { 0.0 };- if !adjustment.is_finite() || (denominator == 0.0 && s.advance != 0.0) {- return Err(EditError::Invalid("the paragraph's text advance cannot be previewed".into()));- }- let mut replacement = Vec::new();- if let Some(op) = ops.get(s.op) {- if op.is("\"") {- replacement.push(Op::new("Tw", vec![op.operands.first().cloned().unwrap_or(Object::Int(0))]));- replacement.push(Op::new("Tc", vec![op.operands.get(1).cloned().unwrap_or(Object::Int(0))]));- }- if op.is("'") || op.is("\"") {- replacement.push(Op::new("T*", vec![]));- }- }- replacement.push(Op::new("TJ", vec![Object::Array(vec![pdfcraft_content::num(adjustment)])]));- patches.insert(s.op, replacement);- }- let data = splice(&pieces, &ops, |i| patches.remove(&i).map_or((Vec::new(), true), |v| (v, false)));- let contents = rewritten_contents(doc, &streams, data);- doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;- Ok(())-}--/// The paragraphs on a page as a reader sees them, including text drawn by form XObjects-/// (Export to Word, HTML and RTF). Read-only: indexes into this list are not-/// [`text_blocks`] indexes, so they can't be passed to [`replace_block`] or [`rewrite_block`].-/// [`reading_blocks_checked`] also says whether text was left out.-pub fn reading_blocks(doc: &Document, page: usize) -> Result<Vec<TextBlock>, EditError> {- reading_blocks_checked(doc, page).map(|r| r.blocks)-}--/// A page's paragraphs as a reader sees them ([`reading_blocks_checked`]).-#[derive(Clone, Debug, Default, PartialEq)]-pub struct ReadingBlocks {- /// The paragraphs, as [`reading_blocks`] returns them.- pub blocks: Vec<TextBlock>,- /// The page draws forms nested deeper than [`MAX_FORM_DEPTH`], more of them than- /// [`MAX_FORM_VISITS`], or forms that run past what the page's content left of its decode- /// budget. Reading leaves those forms out to stay bounded on hostile files, so their text- /// is missing from `blocks`; [`crate::reading_images`] walks the same forms and misses- /// their images too.- pub truncated: bool,-}--/// [`reading_blocks`], saying whether the limits that bound reading left text out. A page-/// whose `/Contents` alone runs past its decode budget is an [`EditError::Invalid`], not a-/// truncated result.-pub fn reading_blocks_checked(doc: &Document, page: usize) -> Result<ReadingBlocks, EditError> {- let (lines, truncated) = reading_lines(doc, page)?;- Ok(ReadingBlocks { blocks: regions::group_reading_blocks(&lines), truncated })-}--// An ideographic space carries intentional Japanese spacing, including paragraph indentation.-// Keep other whitespace normalization unchanged.-fn paragraph_separator(c: char) -> bool {- c.is_whitespace() && c != '\u{3000}'-}--/// Greedy word wrapping to `width` with `advance` giving a string's width. Each `\n` starts a-/// new line. A row may also end inside a word of Chinese or Japanese text ([`crate::linebreak`]);-/// those pieces join without a space. Every white-space character is written as one space, so-/// a run of spaces typed between, before or after words stays (#4199); only the spaces where a-/// row wraps are dropped.-fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<String> {- let mut out = Vec::new();- for row in text.split('\n') {- let mut line = String::new();- let start = out.len();- // The separators read since the last word: each one boundary between `split` pieces.- let mut gap = 0usize;- for (k, word) in row.split(paragraph_separator).enumerate() {- if k > 0 {- gap = gap.saturating_add(1);- }- if word.is_empty() {- continue;- }- let spaces = " ".repeat(std::mem::take(&mut gap));- for (i, piece) in crate::linebreak::pieces(word).into_iter().enumerate() {- let candidate = if i == 0 { format!("{line}{spaces}{piece}") } else { format!("{line}{piece}") };- // A row holding only the spaces that indent it doesn't wrap before its first word.- if line.chars().any(|c| c != ' ') && advance(&candidate) > width {- out.push(std::mem::take(&mut line));- line = piece.to_string();- } else {- line = candidate;- }- }- }- line.push_str(&" ".repeat(gap));- if !line.is_empty() || out.len() == start {- out.push(line);- }- }- out-}--/// Replace paragraph `block` (an index into [`text_blocks`]) with `text`, rewrapped to the-/// paragraph's width with its line spacing. The paragraph keeps its first line's position, font-/// (or Helvetica when the font can't show the text), size and colour.-pub fn replace_block(doc: &mut Document, page: usize, block: usize, text: &str) -> Result<LineEdit, EditError> {- rewrite_block(doc, page, block, Some(text), &BlockStyle::default())-}--/// Formatting for a rewritten paragraph (`None` keeps the paragraph's own).-#[derive(Clone, Debug, Default, PartialEq)]-pub struct BlockStyle {- /// Disjoint UTF-8 ranges in the replacement, each preserving unspecified source style.- pub ranges: Vec<RangeStyle>,- /// Explicit page font resource (from register_text_font or the page font inventory).- pub resource: Option<String>,- /// A standard font family, bold, italic.- pub family: Option<(crate::added::Family, bool, bool)>,- /// Override weight without choosing a different family (`None` keeps the source weight).- pub bold: Option<bool>,- /// Font size in points (user space).- pub size: Option<f64>,- /// Fill colour (RGB 0–1).- pub color: Option<[f64; 3]>,- pub align: Option<crate::added::Align>,- /// Draw a line under each line of text.- pub underline: Option<bool>,- /// Line spacing as a multiple of the font size (1.2 is ordinary).- pub line_spacing: Option<f64>,- /// Character spacing (points) and horizontal scaling (percent).- pub char_spacing: Option<f64>,- pub scale: Option<f64>,- /// Move the paragraph by `[dx, dy]` in user space (dragging its box).- pub offset: Option<[f64; 2]>,- /// Rewrap to this width in user space (dragging the box's edge).- pub width: Option<f64>,- /// For an invisible paragraph ([`TextBlock::invisible`]): fill its old area with this colour- /// (RGB 0–1) before the new text, hiding the scanned word beneath it.- pub cover: Option<[f64; 3]>,-}--#[derive(Clone, Debug, PartialEq)]-pub struct RangeStyle {- pub range: std::ops::Range<usize>,- pub family: Option<(crate::added::Family, bool, bool)>,- pub resource: Option<String>,- pub size: Option<f64>,- pub color: Option<[f64; 3]>,- pub underline: Option<bool>,- pub char_spacing: Option<f64>,- pub scale: Option<f64>,-}--/// Rewrite paragraph `block` with new text (or its own) and formatting, rewrapped to its width.-pub fn rewrite_block(doc: &mut Document, page: usize, block: usize, text: Option<&str>, style: &BlockStyle) -> Result<LineEdit, EditError> {- let edit = rewrite_block_with_limit(doc, page, block, text, style, MAX_TYPE3_GLYPHS)?;- drop_unused_fallback_fonts(doc, page);- Ok(edit)-}--/// [`rewrite_block`] with the most unique characters one generated font may hold (tests lower it).-pub(crate) fn rewrite_block_with_limit(- doc: &mut Document,- page: usize,- block: usize,- text: Option<&str>,- style: &BlockStyle,- max_glyphs: usize,-) -> Result<LineEdit, EditError> {- TextSession::open(doc, page, block)?.commit_with_limit(doc, text, style, max_glyphs)-}--/// [`rewrite_block_with_limit`] with the page's [`text_lines`], read from `doc` as it is now.-fn rewrite_block_from(- doc: &mut Document,- page: usize,- lines: Vec<TextLine>,- block: usize,- text: Option<&str>,- style: &BlockStyle,- max_glyphs: usize,-) -> Result<LineEdit, EditError> {- let blocks = group_blocks(&lines);- let b = blocks.get(block).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no paragraph {}", page + 1, block + 1)))?;- let members: Vec<&TextLine> = b.lines.iter().map(|i| &lines[*i]).collect();- // One clipping run is enough: rewriting the paragraph would drop its mask with the rest.- let mut dropped = coincident_ops(&lines, &members);- dropped.extend(members.iter().flat_map(|l| l.ops.iter().copied()));- refuse_clipping_text(&lines, &dropped)?;- let first = members.first().copied().ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;- members.iter().try_for_each(|line| line.ensure_editable())?;- let p = page_dict(doc, page)?;- let mut res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let mut fonts_res = res.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();- let registered_face = fonts_res.iter().any(|(name, _)| name.starts_with(b"PCFull"));- // Hebrew is written back in drawing order (and with the Hebrew fallback face) by the- // single-style path below; the styled region path does not reorder right-to-left runs.- let hebrew = text.unwrap_or(&b.text).chars().any(crate::bidi::is_hebrew);- if hebrew && (!style.ranges.is_empty() || style.resource.is_some()) {- return Err(EditError::Invalid(- "formatting part of right-to-left (Hebrew) text, or choosing a document font for it, isn't supported yet".into(),- ));- }- // Text turned on the page (a landscape page drawn a quarter turn round) is rewritten in its- // own text space below; the styled region path lays rows out along the page's x axis.- let upright = members.iter().all(|line| line.upright());- if !upright && (!style.ranges.is_empty() || style.resource.is_some()) {- return Err(EditError::Invalid("formatting part of turned text, or choosing a document font for it, isn't supported yet".into()));- }- let visual_indic = members.iter().any(|line| line.visual_order);- if upright- && !hebrew- && !visual_indic- && (!style.ranges.is_empty()- || style.resource.is_some()- || (text.is_some_and(|draft| {- // A row break, `\n` or a carriage return, takes the path that keeps untouched rows.- draft.contains(['\n', '\r'])- || pdfcraft_fonts::source_shaping::required(draft)- || !pdfcraft_fonts::embedding::matching_faces(&b.base_font).is_empty()- }) || registered_face- || text.is_some_and(|draft| source_program_completes(doc, &fonts_res, first, draft))- || b.rows.iter().any(|row| row.len() > 1)- || members.iter().any(|line| line.font != first.font || line.size != first.size || line.color != first.color))- && style.family.is_none()- && style.bold.is_none())- {- return rewrite_styled_block(doc, page, &b, &lines, text, style, max_glyphs);- }- let streams = content_streams(doc, &p.dict)?;- let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());- let ops = pieces.parse().ops;- // Explicit line breaks stay (#1443), and so does each typed U+0020 space: a run of them is- // not folded into one (#4199, #3797). `\r\n` and a lone `\r` are breaks too; other white- // space is written as one space.- let text: String = text- .unwrap_or(&b.text)- .replace("\r\n", "\n")- .chars()- .map(|c| match c {- '\r' => '\n',- c if c != '\n' && paragraph_separator(c) => ' ',- c => c,- })- .collect();- // The characters to show, for choosing fonts: the breaks are moves, not glyphs.- let flat = text.replace('\n', " ");- let o = &first.origin;- let last = members.last().copied().unwrap_or(first);- let emit = &last.origin;- let (font_name, old_size) = o.state.font.clone().ok_or_else(|| EditError::Invalid("the paragraph has no font".into()))?;- let k = o.k.max(1e-6);- // The size in text space: points ÷ the text-to-user scale.- let size = style.size.map_or(old_size, |pt| (pt / k).max(0.1));- // Spacing and scaling (text state), with the chosen values.- let mut ts_state = o.state.clone();- if let Some(c) = style.char_spacing {- ts_state.char_spacing = c / k;- }- if let Some(sc) = style.scale {- ts_state.scale = (sc / 100.0).clamp(0.1, 10.0);- }- let o_state = ts_state.clone();- let metrics = fonts_res.get(font_name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));- let visual_indic = metrics.as_ref().is_some_and(|m| m.visual_order) || first.visual_order;- let indic_text = if visual_indic { crate::indic::to_visual(&flat) } else { flat.clone() };- let reuse = style.family.is_none() && style.bold.is_none() && metrics.as_ref().is_some_and(|m| source_encodes(m, &indic_text));- let space = metrics.as_ref().map_or(0.33, |m| source_space(doc, &fonts_res, m));- // The chosen style also determines the real Japanese fallback outlines and advances.- let (family, bold, italic) = style.family.unwrap_or((source_family(&b.base_font), b.bold, b.italic));- let bold = style.bold.unwrap_or(bold);- // The face is chosen after `bold` settles, so a bold request measures with the bold metrics.- let face = family.std14(bold, italic);- let std_width = move |s: &str, size: f64| -> f64 { face.text_width(s, size) };- let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);- if !(dx.is_finite() && dy.is_finite()) {- return Err(EditError::Invalid("the paragraph can't be moved that far".into()));- }- // Right-to-left text (more Hebrew or Arabic letters than Latin) is right-aligned unless an- // alignment is asked for, and a single right-to-left line keeps its right edge as it grows.- let rtl = crate::bidi::rtl_base(&flat);- let anchored_right = rtl && upright && style.width.is_none() && members.len() == 1;- // The paragraph's width along its lines: in user space unless it is turned.- let frame = if upright {- b.rect- } else {- members.iter().map(|l| l.frame_rect()).reduce(|a, f| [a[0].min(f[0]), a[1].min(f[1]), a[2].max(f[2]), a[3].max(f[3])]).unwrap_or(b.rect)- };- // A centred title is laid out in the box it already sits in, so it keeps its centre as it- // grows or wraps, rather than being grown to the right up to the page's margin (#2581).- // Turned text is left alone: its centre lives along its own baseline, not in page space.- let crop = p.crop(doc);- let centred = upright && !rtl && style.width.is_none() && style.align.is_none() && is_centred(&b, &lines, (crop[0] + crop[2]) / 2.0, first.size);- // A paragraph keeps its width (or takes the one asked for); a single line grows to the right- // (to the left when right-to-left), up to the page's margin.- let width = match style.width {- // Capped at the largest page PDF allows (14 400 pt), even for text set larger than that- // (`clamp` panics when its minimum is the larger, or NaN).- Some(w) if w.is_finite() => w.clamp((size * k).min(14_400.0), 14_400.0),- Some(_) => return Err(EditError::Invalid("the paragraph's width must be a number".into())),- // Turned text: the page's margins are along another axis. A single line grows (below).- None if !upright => (frame[2] - frame[0]).max(size * k),- None if anchored_right => (b.rect[2] - b.rect[0]).max(size * k).max(b.rect[2] + dx - (crop[0] + 36.0)),- // A centred line is not stretched to the margin: its own box is the frame it is centred in.- None if members.len() == 1 && !centred => (b.rect[2] - b.rect[0]).max(size * k).max(crop[2] - 36.0 - (b.rect[0] + dx)),- None => (b.rect[2] - b.rect[0]).max(size * k),- };- if !width.is_finite() {- return Err(EditError::Invalid("the paragraph's width must be a number".into()));- }- let align = if centred { Some(crate::added::Align::Center) } else { style.align.or(rtl.then_some(crate::added::Align::Right)) };- // Where a right-aligned line ends, from the paragraph's left edge (user space).- let right_edge = if anchored_right { (b.rect[2] - b.rect[0]).max(0.0) } else { width };- // The move and the width are checked here, before the fallback fonts are written: a refused- // paragraph leaves the document as it was. The move is in page space, so it is taken back through- // the CTM's linear part into the space the paragraph is drawn in.- let movement = if dx != 0.0 || dy != 0.0 {- let c = emit.ctm;- let back = Matrix([c[0], c[1], c[2], c[3], 0.0, 0.0])- .invert()- .ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be moved in".into()))?;- Some(back.apply(dx, dy))- } else {- None- };- let tm = if o.ctm == emit.ctm {- o.tm- } else {- let emit_inv = Matrix(emit.ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph has a singular transform".into()))?;- Matrix(o.tm).then(&Matrix(o.ctm)).then(&emit_inv).0- };- let type3 = if !reuse && needs_type3(&flat) { Some(type3_font(doc, &mut fonts_res, &flat, family, bold, max_glyphs)?) } else { None };- let advance = |s: &str| -> f64 {- let t = match (&metrics, reuse) {- (Some(m), true) => {- let visual_s = if m.visual_order { crate::indic::to_visual(s) } else { s.to_owned() };- source_width(m, &visual_s, size, space, o_state.char_spacing, o_state.word_spacing)- }- _ if let Some(fallback) = &type3 => {- // Each character's count in `s`, from one pass over `s`.- let mut counts: HashMap<char, usize> = HashMap::new();- for c in s.chars() {- let count = counts.entry(c).or_insert(0);- *count = count.saturating_add(1);- }- fallback.widths.iter().map(|(ch, width)| counts.get(ch).copied().unwrap_or(0) as f64 * width * size).sum::<f64>()- + s.chars().count() as f64 * o_state.char_spacing- }- _ => std_width(s, size) + s.chars().count() as f64 * o_state.char_spacing,- };- t * o_state.scale * k- };- // A turned single line grows to fit, up to where its baseline reaches the page's margin.- let width = if !upright && style.width.is_none() && members.len() == 1 {- let crop = p.crop(doc);- let (x0, y0) = (first.origin.x + dx, first.origin.baseline + dy);- let (ux, uy) = first.direction();- let tx = if ux > 1e-6 {- (crop[2] - 36.0 - x0) / ux- } else if ux < -1e-6 {- (crop[0] + 36.0 - x0) / ux- } else {- f64::INFINITY- };- let ty = if uy > 1e-6 {- (crop[3] - 36.0 - y0) / uy- } else if uy < -1e-6 {- (crop[1] + 36.0 - y0) / uy- } else {- f64::INFINITY- };- let cap = width.max(tx.min(ty)).min(14_400.0);- text.split('\n').map(&advance).fold(width, f64::max).min(cap)- } else {- width- };- let right_edge = if anchored_right { right_edge } else { width };- let wrapped = wrap(&text, width + 0.5, advance);- let mut substituted = None;- let new_font = !reuse;- let (show_font, encode): (String, Encoder) = if let Some(m) = metrics.clone().filter(|_| reuse) {- let name = font_name.clone();- (font_name.clone(), Box::new(move |s: &str| m.encode(s).map(|bytes| vec![(name.clone(), bytes)])))- } else if let Some(fallback) = type3.clone() {- substituted = Some(format!("{} Type3", fallback.family));- let first = fallback.names.first().cloned().ok_or_else(no_japanese_font)?;- (first, Box::new(move |s: &str| type3_encode(&fallback, s)))- } else {- let win = pdfcraft_fonts::win_ansi(&flat);- let back: String = win.iter().map(|c| char::from_u32(u32::from(*c)).unwrap_or('?')).collect();- let base = family.base_font(bold, italic);- if flat.chars().zip(back.chars()).any(|(a, c)| c == '?' && a != '?') {- return Err(EditError::Invalid(format!("\"{flat}\" has characters neither {} nor {base} can show", b.base_font)));- }- let mut f = Dict::new();- f.set(b"Type".to_vec(), Object::name("Font"));- f.set(b"Subtype".to_vec(), Object::name("Type1"));- f.set(b"BaseFont".to_vec(), Object::name(base));- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));- // Named after its face, as the line and region rewrites name theirs: one name for every- // stand-in would repoint the paragraphs set in an earlier one at this face (#4280).- let name = format!("PCEd{}", base.replace('-', ""));- fonts_res.set(name.clone().into_bytes(), Object::Dict(f));- if style.family.is_none() {- substituted = Some(base.to_string());- }- let shown = name.clone();- (name, Box::new(move |s: &str| Some(vec![(shown.clone(), pdfcraft_fonts::win_ansi(s))])))- };- // Line spacing in text space: the paragraph's own (scaled with the size), or 1.2 × the size.- let lead = match style.line_spacing {- Some(m) => size * m.clamp(0.5, 5.0),- // From the first two rows (a row may hold several runs).- None if let Some((upper, lower)) = b- .rows- .first()- .zip(b.rows.get(1))- .and_then(|(upper, lower)| upper.first().zip(lower.first()))- .and_then(|(upper, lower)| lines.get(*upper).zip(lines.get(*lower))) =>- {- (upper.frame_origin().1 - lower.frame_origin().1) / k * size / old_size- }- None if o_state.leading > 0.0 => o_state.leading,- None => size * 1.2,- };- let n = pdfcraft_content::num;- // The paragraph's operators go, and so does another drawing on the same baseline (a fake-bold- // second copy, an invisible text layer): the new text is all that may show.- let drop = dropped;- // Text shown earlier in the same text object stays first: the paragraph then goes where its- // last row was, after any backgrounds between the rows, or between two halves of the text object.- let start = last.ops.first().copied().unwrap_or(emit.bt_op);- let split = ops- .get(emit.bt_op..start)- .unwrap_or_default()- .iter()- .enumerate()- .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(emit.bt_op + i)));- // What the text after the paragraph expects, and what is in force where the paragraph is- // drawn: the state at its BT (or where it was split).- let after = if split { &emit.state } else { &emit.bt_state };- // In its own graphics state, so a new colour (or anything else) stops at the paragraph.- let mut block_ops = vec![Op::new("q", vec![])];- block_ops.extend(reveal_ops(&b, &lines, style, emit.ctm)?);- // Moved: a translation inside that state.- if let Some((ax, ay)) = movement {- block_ops.push(Op::new("cm", vec![n(1.0), n(0.0), n(0.0), n(1.0), n(ax), n(ay)]));- }- // Painted as the paragraph was, including what its text object set before the first show.- block_ops.extend(o_state.paint_ops(after));- block_ops.push(Op::new("BT", vec![]));- let mut state = o_state.clone();- state.word_spacing = 0.0;- // The font the next run is shown in: the one the BT sets, until a run of another fallback subset.- let mut shown_font = show_font.clone();- state.font = Some((show_font, size));- if let Some([r, g, bl]) = style.color {- state.fill = vec![Op::new("rg", vec![n(r), n(g), n(bl)])];- }- block_ops.extend(state.ops());- block_ops.push(Op::new("Tm", tm.iter().map(|v| n(*v)).collect()));- // Alignment: each line's offset from the left edge, in text space.- // `visible` is the width the line is aligned on (see the loop below).- let offset = |visible: f64| -> f64 {- let free = (width - visible).max(0.0) / k;- match align {- Some(crate::added::Align::Center) => free / 2.0,- // A right-to-left line anchored at its right edge may start left of the old box.- Some(crate::added::Align::Right) if anchored_right => (right_edge - visible) / k,- Some(crate::added::Align::Right) => free,- // A justified right-to-left paragraph ends its last line at the right edge.- Some(crate::added::Align::Justify) if rtl => free,- _ => 0.0,- }- };- // Justify: each line but the last fills the width. Word spacing reaches only single-byte code 32- // (ISO 32000-1 §9.3.3), so where a space is shown with another code (a composite font, a- // generated Type 3 font, a subset without a space) the extra space follows each space as a- // TJ adjustment instead, and code 32, which may then be a letter, gets none.- let justify = align == Some(crate::added::Align::Justify);- let word_spacing_reaches_spaces = match metrics.as_ref().filter(|_| reuse) {- Some(m) => m.encode(" ").is_some_and(|b| m.codes(&b).iter().all(|(c, len)| m.is_space(*c, *len))),- None => type3.is_none(),- };- let mut x = 0.0;- let mut tw_set = 0.0;- let mut underlines: Vec<(f64, f64, f64)> = Vec::new(); // (x0, x1, y) in text space- for (i, line) in wrapped.iter().enumerate() {- // A stretched (justified) line shows only its words, as before #4199: word spacing would- // reach the spaces before its first word and after its last, so they are left out, and- // the line fills the width from the left edge. Nothing to stretch over, or a paragraph- // drawn at `0 Tz`, isn't justified.- let body = line.trim_matches(' ');- let interior = body.matches(' ').count();- let tw = if justify && i + 1 < wrapped.len() && interior > 0 && o_state.scale.abs() > 1e-6 {- Some((width - advance(body)).max(0.0) / k / o_state.scale / interior as f64).filter(|tw| tw.is_finite())- } else {- None- }- .unwrap_or(0.0);- // Other lines show every space typed. A left-to-right one is aligned on its width up to- // its last word; a right-to-left one on its whole width, since the spaces typed after its- // last word are drawn on its left and the ones before its first on its right.- let (shown, visible) = if tw > 0.0 {- (body, advance(body))- } else if crate::bidi::rtl_base(line) {- (line.as_str(), advance(line))- } else {- (line.as_str(), advance(line.trim_end_matches(' ')))- };- let dx = if tw > 0.0 { 0.0 } else { offset(visible) };- if i > 0 || dx != 0.0 {- block_ops.push(Op::new("Td", vec![n(dx - x), n(if i > 0 { -lead } else { 0.0 })]));- }- x = dx;- let stretch = if word_spacing_reaches_spaces { 0.0 } else { tw };- let tw = tw - stretch;- if tw != tw_set {- block_ops.push(Op::new("Tw", vec![n(tw)]));- tw_set = tw;- }- // Each wrapped line in typing order; drawn left to right (right-to-left runs reversed).- let visual = crate::bidi::to_visual(shown);- // Stretched without word spacing: shown up to and including each space, then moved on.- let pieces = if stretch > 0.0 { visual.split_inclusive(' ').collect() } else { vec![visual.as_str()] };- for piece in pieces {- if let Some(metrics) = metrics.as_ref().filter(|_| reuse) {- let indic_piece = if metrics.visual_order { crate::indic::to_visual(piece) } else { piece.to_owned() };- block_ops.extend(source_show(metrics, &indic_piece, size, space, o_state.char_spacing, tw)?);- } else {- for (font, bytes) in encode(piece).ok_or_else(|| EditError::Invalid(format!("\"{line}\" can't be shown")))? {- if font != shown_font {- block_ops.push(Op::new("Tf", vec![Object::name(&font), n(size)]));- shown_font = font;- }- block_ops.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));- }- }- if stretch > 0.0 && piece.ends_with(' ') {- block_ops.push(Op::new("TJ", vec![Object::Array(vec![n(-1000.0 * stretch / size)])]));- }- }- let tw = tw + stretch;- // Underlined to the line's last word, over its stretched gaps.- let w = (visible + tw * interior as f64 * o_state.scale * k) / k;- underlines.push((dx, dx + w, -(i as f64) * lead - size * 0.12));- }- block_ops.push(Op::new("ET", vec![]));- if style.underline == Some(true) {- // In text space (the paragraph's text matrix), in its fill colour.- let colour: Vec<Op> = state- .fill- .iter()- .map(|f| match f.op.as_slice() {- b"g" => Op::new("G", f.operands.clone()),- b"rg" => Op::new("RG", f.operands.clone()),- b"k" => Op::new("K", f.operands.clone()),- b"cs" => Op::new("CS", f.operands.clone()),- b"sc" => Op::new("SC", f.operands.clone()),- _ => Op::new("SCN", f.operands.clone()),- })- .collect();- block_ops.push(Op::new("q", vec![]));- block_ops.push(Op::new("cm", tm.iter().map(|v| n(*v)).collect()));- block_ops.extend(colour);- block_ops.push(Op::new("w", vec![n(size * 0.06)]));- for (x0, x1, y) in underlines {- block_ops.push(Op::new("m", vec![n(x0), n(y)]));- block_ops.push(Op::new("l", vec![n(x1), n(y)]));- }- block_ops.push(Op::new("S", vec![]));- block_ops.push(Op::new("Q", vec![]));- }- block_ops.push(Op::new("Q", vec![]));- block_ops.extend(after.ops().into_iter().filter(|op| !op.is("Tf") || after.font.is_some()));- if split {- block_ops.insert(0, Op::new("ET", vec![]));- block_ops.push(Op::new("BT", vec![]));- block_ops.push(Op::new("Tm", emit.tlm.iter().map(|v| n(*v)).collect()));- }- let at = if split { start } else { emit.bt_op };- let new_data = splice(&pieces, &ops, |i| {- let insert = if i == at { std::mem::take(&mut block_ops) } else { Vec::new() };- (insert, !drop.contains(&i))- });- let contents = rewritten_contents(doc, &streams, new_data);- if new_font {- res.set(b"Font".to_vec(), Object::Dict(fonts_res));- }- let page_ref = p.obj;- doc.update_dict(page_ref, |d| {- d.set(b"Contents".to_vec(), contents);- if new_font {- d.set(b"Resources".to_vec(), Object::Dict(res));- }- })?;- Ok(LineEdit { substituted })-}--/// The cover (when [`BlockStyle::cover`] asks for one) and visible rendering that start a-/// rewritten invisible paragraph, drawn in the space whose CTM is `ctm`. Nothing for visible text.-/// The paragraph's `q`/`Q` restores the rendering mode for the invisible text after it.-pub(crate) fn reveal_ops(block: &TextBlock, lines: &[TextLine], style: &BlockStyle, ctm: [f64; 6]) -> Result<Vec<Op>, EditError> {- if !block.invisible {- return Ok(Vec::new());- }- let n = pdfcraft_content::num;- let mut ops = Vec::new();- if let Some(colour) = style.cover {- if colour.iter().any(|c| !c.is_finite() || !(0.0..=1.0).contains(c)) {- return Err(EditError::Invalid("the cover colour must be RGB values from 0 to 1".into()));- }- let back = Matrix(ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be covered in".into()))?;- ops.push(Op::new("q", vec![]));- ops.push(Op::new("rg", colour.map(n).to_vec()));- for rect in block.lines.iter().filter_map(|i| lines.get(*i)).map(|l| l.rect) {- // Scanned ink reaches a little past the recognised box.- let pad = ((rect[3] - rect[1]).abs() * 0.1).clamp(0.5, 2.0);- let corners =- [[rect[0] - pad, rect[1] - pad], [rect[2] + pad, rect[1] - pad], [rect[2] + pad, rect[3] + pad], [rect[0] - pad, rect[3] + pad]];- for (i, [x, y]) in corners.into_iter().enumerate() {- let (x, y) = back.apply(x, y);- if !(x.is_finite() && y.is_finite()) {- return Err(EditError::Invalid("the paragraph's area can't be covered".into()));- }- ops.push(Op::new(if i == 0 { "m" } else { "l" }, vec![n(x), n(y)]));- }- ops.push(Op::new("h", vec![]));- }- ops.push(Op::new("f", vec![]));- ops.push(Op::new("Q", vec![]));- }- ops.push(Op::new("Tr", vec![Object::Int(0)]));- Ok(ops)-}--/// Existing paragraph indexes, excluding streams owned by an added-content item.-pub(crate) fn selectable_blocks(- doc: &Document,- page: usize,- excluded: &std::collections::BTreeSet<pdfcraft_cos::ObjRef>,-) -> Result<Vec<(usize, TextBlock)>, EditError> {- let p = page_dict(doc, page)?;- let streams = content_streams(doc, &p.dict)?;- let lines = text_lines(doc, page)?;- Ok(group_blocks(&lines)- .into_iter()- .enumerate()- .filter(|(_, b)| {- !b.lines- .iter()- .filter_map(|i| lines.get(*i))- .any(|l| streams.get(l.stream).and_then(|(o, _)| o.as_ref()).is_some_and(|r| excluded.contains(&r)))- })- .collect())-}--/// The vertical advance per unit of font size of a font that writes vertically: `/DW2`'s w1-/// (default −1000, §9.7.4.3), or `None` for horizontal text. Per-glyph `/W2` entries are not-/// read. An encoding whose writing mode can't be read is an error, as in [`vertical_encoding`];-/// listing text treats it as horizontal and records the error (see [`Ts::unreadable`]).-fn vertical_advance(doc: &Document, font: &Dict) -> Result<Option<f64>, EditError> {- if !vertical_encoding(doc, font)? {- return Ok(None);- }- let descendant = font.get(b"DescendantFonts").and_then(|d| doc.resolve(d).as_array().and_then(|a| a.first().cloned()));- let w1 = descendant- .and_then(|d| doc.resolve(&d).as_dict().and_then(|d| d.get(b"DW2").cloned()))- .and_then(|a| doc.resolve(&a).as_array().and_then(|a| a.get(1).cloned()))- .and_then(|w| doc.resolve(&w).as_f64())- .filter(|w| w.is_finite())- .unwrap_or(-1000.0);- Ok(Some(w1 / 1000.0))-}--/// Detect vertical CMaps before moving horizontal text. A broken/cyclic embedded CMap is-/// refused rather than guessing which direction TJ advances its text matrix.-fn vertical_encoding(doc: &Document, font: &Dict) -> Result<bool, EditError> {- if font.name(b"Subtype") != Some(b"Type0") {- return Ok(false);- }- let mut next = font.get(b"Encoding").cloned();- let mut seen = std::collections::BTreeSet::new();- for _ in 0..8 {- let Some(o) = next.take() else { return Ok(false) };- if let Some(r) = o.as_ref()- && !seen.insert(r)- {- return Err(EditError::Invalid("the text encoding is cyclic".into()));- }- match &*doc.resolve(&o) {- Object::Name(n) => return Ok(n.ends_with(b"-V")),- Object::Stream(stream) => {- if let Some(mode) = stream.dict.get(b"WMode") {- match mode.as_int() {- Some(1) => return Ok(true),- Some(0) => {}- _ => return Err(EditError::Invalid("the text writing mode is invalid".into())),- }- }- let bytes = stream- .decoded_within(8 * 1024 * 1024)- .map_err(|_| EditError::Invalid("the text encoding cannot be decoded within its size limit".into()))?;- let ops = parse(&bytes).ops;- if let Some(mode) = ops.iter().rev().find(|op| op.is("def") && op.name(0) == Some(b"WMode")) {- return match mode.num(1) {- Some(0.0) => Ok(false),- Some(1.0) => Ok(true),- _ => Err(EditError::Invalid("the text writing mode is invalid".into())),- };- }- next = stream- .dict- .get(b"UseCMap")- .cloned()- .or_else(|| ops.iter().rev().find(|op| op.is("usecmap")).and_then(|op| op.operands.first().cloned()));- }- _ => return Err(EditError::Invalid("the text encoding is invalid".into())),- }- }- Err(EditError::Invalid("the text encoding is nested too deeply".into()))-}--/// Translate paragraphs together without re-encoding glyphs, changing fonts or reflowing.-/// Numeric TJ offsets and text rise temporarily move each selected show operation, then-/// restore both advances and rise. The PDF reader advances the original glyph bytes itself:-/// no approximate font metrics are used to position following, unselected text (§9.4.4).-pub(crate) fn translate_blocks(doc: &mut Document, page: usize, indexes: &[usize], offset: [f64; 2]) -> Result<(), EditError> {- if indexes.is_empty() {- return Ok(());- }- let p = page_dict(doc, page)?;- let streams = content_streams(doc, &p.dict)?;- let lines = text_lines(doc, page)?;- let blocks = group_blocks(&lines);- let mut selected = std::collections::BTreeSet::new();- for index in indexes {- let b = blocks.get(*index).ok_or_else(|| EditError::Invalid("a selected paragraph no longer exists".into()))?;- for line in &b.lines {- let l = lines.get(*line).ok_or_else(|| EditError::Invalid("a selected text line no longer exists".into()))?;- l.ensure_editable()?;- selected.extend(l.ops.iter().copied());- }- }- let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let fonts = res.get(b"Font").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();- let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());- let ops = pieces.parse().ops;- let shown = interpret(doc, &ops, &res, &mut HashMap::new(), &mut Carry::new(), None, None)?;- let mut patches = HashMap::new();- // Keep full precision: a tiny rounded text-space change can be magnified by a CTM,- // and restoring rise/spacing must not alter following unselected text.- let n = Object::Real;- for s in shown.into_iter().filter(|s| selected.contains(&s.op)) {- if !(0..=3).contains(&s.state.render_mode) {- return Err(EditError::Invalid("text used as a clipping path cannot be moved in a group".into()));- }- let font = fonts- .get(&s.font)- .map(|f| doc.resolve(f))- .and_then(|f| f.as_dict().cloned())- .ok_or_else(|| EditError::Invalid("a selected paragraph has no font".into()))?;- if vertical_encoding(doc, &font)? {- return Err(EditError::Invalid("vertical text cannot be moved in a group".into()));- }- let inverse = s.tm.then(&s.state.ctm).invert().ok_or_else(|| EditError::Invalid("a selected paragraph has no area".into()))?;- let [a, b, c, d, _, _] = inverse.0;- let (dx, dy) = (a * offset[0] + c * offset[1], b * offset[0] + d * offset[1]);- let denominator = s.state.size * s.state.scale;- let shift = if dx == 0.0 {- 0.0- } else if denominator.abs() > 1e-12 {- -1000.0 * dx / denominator- } else {- return Err(EditError::Invalid("a selected paragraph has no horizontal advance".into()));- };- let rise = s.state.rise + dy;- if ![shift, rise, dx, dy].iter().all(|v| v.is_finite() && v.abs() <= 1e12) {- return Err(EditError::Invalid("the paragraph move is too large".into()));- }- let original = ops.get(s.op).ok_or_else(|| EditError::Invalid("a selected text operation is missing".into()))?;- let mut replacement = Vec::new();- let show = if original.is("'") || original.is("\"") {- if original.is("\"") {- let spacing = original- .operands- .get(..2)- .filter(|a| a.iter().all(|o| o.as_f64().is_some()))- .ok_or_else(|| EditError::Invalid("a text operation has invalid spacing".into()))?;- for (operator, operand) in ["Tw", "Tc"].into_iter().zip(spacing) {- replacement.push(Op::new(operator, vec![operand.clone()]));- }- }- replacement.push(Op::new("T*", vec![]));- Op::new("Tj", vec![original.operands.last().cloned().ok_or_else(|| EditError::Invalid("a text operation has no string".into()))?])- } else {- original.clone()- };- if dy != 0.0 {- replacement.push(Op::new("Ts", vec![n(rise)]));- }- if shift != 0.0 {- replacement.push(Op::new("TJ", vec![Object::Array(vec![n(shift)])]));- }- replacement.push(show);- if shift != 0.0 {- replacement.push(Op::new("TJ", vec![Object::Array(vec![n(-shift)])]));- }- if dy != 0.0 {- replacement.push(Op::new("Ts", vec![n(s.state.rise)]));- }- patches.insert(s.op, replacement);- }- if patches.len() != selected.len() {- return Err(EditError::Invalid("a selected text operation cannot be moved".into()));- }- let data = splice(&pieces, &ops, |i| patches.remove(&i).map_or((Vec::new(), true), |v| (v, false)));- let contents = rewritten_contents(doc, &streams, data);- doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;- Ok(())-}-#[cfg(test)]mod tests {use super::*;diff --git a/crates/edit/src/text/blocks.rs b/crates/edit/src/text/blocks.rsnew file mode 100644index 000000000..8d3d224da--- /dev/null+++ b/crates/edit/src/text/blocks.rs@@ -0,0 +1,424 @@+use super::interp::{Carry, interpret};+use super::lines::{content_streams, page_dict, reading_lines, rewritten_contents, splice, text_lines};+use super::rewrite::{LineEdit, coincident_ops, rewrite_block};+use super::*;++/// An editable text region: adjacent runs on visual rows, followed by aligned rows.+/// A region may contain several source fonts, sizes, colours and weights.+#[derive(Clone, Debug, PartialEq)]+pub struct TextBlock {+ /// The lines' text joined with spaces (lines that ended in a hyphen are joined directly).+ pub text: String,+ pub rect: [f64; 4],+ pub base_font: String,+ pub size: f64,+ pub bold: bool,+ pub italic: bool,+ /// The text fill colour as RGB, used by the visual editor and preserved when no colour+ /// override is requested.+ pub color: [f64; 3],+ /// Counterclockwise baseline angle in page user space, in degrees.+ pub rotation: f64,+ /// Indexes into [`text_lines`].+ pub lines: Vec<usize>,+ /// Visual rows; each contains indexes into [`text_lines`], including mixed-style runs.+ pub rows: Vec<Vec<usize>>,+ /// Text for the inline editor, with a newline only between visual rows.+ pub editor_text: String,+ /// Byte ranges in `editor_text` and their source line indexes.+ pub spans: Vec<(std::ops::Range<usize>, usize)>,+ /// Every line is invisible text (rendering mode 3): an OCR layer over a scanned image, whose+ /// pixels show the words. A rewrite draws the new text visibly (see [`BlockStyle::cover`]).+ pub invisible: bool,+}++impl TextBlock {+ /// Preserve styles outside the changed ranges; inserted characters inherit the surrounding+ /// source run. The texts are aligned word by word, so words left untouched between two edits+ /// keep their own runs (#2198); past [`MAX_CHANGED_WORDS`] the draft counts as one change.+ /// Byte ranges are always UTF-8 boundaries. Linear time, including large edits.+ pub fn edited_spans(&self, draft: &str) -> Vec<(std::ops::Range<usize>, usize)> {+ if self.editor_text.len() > 4_000_000 || draft.len() > 4_000_000 {+ return vec![(0..draft.len(), self.lines.first().copied().unwrap_or(0))];+ }+ let old: Vec<_> = self.editor_text.chars().collect();+ let new: Vec<_> = draft.char_indices().collect();+ let chars: Vec<_> = new.iter().map(|(_, c)| *c).collect();+ let mut original = Vec::with_capacity(old.len());+ let mut span = 0;+ for (byte, _) in self.editor_text.char_indices() {+ while self.spans.get(span).is_some_and(|(r, _)| byte >= r.end) {+ span += 1;+ }+ original.push(self.spans.get(span).or_else(|| self.spans.last()).map_or(0, |(_, i)| *i));+ }+ let mut sources = Vec::with_capacity(new.len());+ let slices = |text: &[char]| words(text).into_iter().map(|w| text.get(w).unwrap_or_default().to_vec()).collect::<Vec<_>>();+ let (old_words, new_words) = (slices(&old), slices(&chars));+ match edit_script(&old_words, &new_words, MAX_CHANGED_WORDS) {+ Some(script) => {+ // `(o, n)`: where the current change starts in the old and new text; `(x, y)`: where it ends.+ let ((mut o, mut n), (mut x, mut y)) = ((0, 0), (0, 0));+ let (mut a, mut b) = (old_words.iter(), new_words.iter());+ for step in script {+ match step {+ Step::Keep => {+ replaced(&original, o, old.get(o..x).unwrap_or_default(), chars.get(n..y).unwrap_or_default(), &mut sources);+ let len = a.next().map_or(0, Vec::len);+ b.next();+ sources.extend(original.get(x..x.saturating_add(len)).unwrap_or_default());+ (x, y) = (x.saturating_add(len), y.saturating_add(len));+ (o, n) = (x, y);+ }+ Step::Delete => x = x.saturating_add(a.next().map_or(0, Vec::len)),+ Step::Insert => y = y.saturating_add(b.next().map_or(0, Vec::len)),+ }+ }+ replaced(&original, o, old.get(o..x).unwrap_or_default(), chars.get(n..y).unwrap_or_default(), &mut sources);+ }+ None => replaced(&original, 0, &old, &chars, &mut sources),+ }+ let fallback = original.first().copied().unwrap_or(0);+ let mut result: Vec<(std::ops::Range<usize>, usize)> = Vec::new();+ for (i, (byte, ch)) in new.iter().enumerate() {+ let source = sources.get(i).copied().unwrap_or(fallback);+ let end = byte.saturating_add(ch.len_utf8());+ if let Some((range, _)) = result.last_mut().filter(|(_, prev)| *prev == source) {+ range.end = end;+ } else {+ result.push((*byte..end, source));+ }+ }+ result+ }+}++/// Changed words [`TextBlock::edited_spans`] aligns before it treats the draft as one change.+/// Myers' diff costs O((N + M) · D), so bounding D keeps it linear.+const MAX_CHANGED_WORDS: usize = 64;++/// `text` split into words, each with the whitespace after it, as char ranges.+fn words(text: &[char]) -> Vec<std::ops::Range<usize>> {+ let mut out = Vec::new();+ let mut start = 0;+ for (i, pair) in text.windows(2).enumerate() {+ if let [a, b] = pair+ && a.is_whitespace()+ && !b.is_whitespace()+ {+ out.push(start..i + 1);+ start = i + 1;+ }+ }+ if start < text.len() {+ out.push(start..text.len());+ }+ out+}++#[derive(Clone, Copy, Debug, PartialEq)]+enum Step {+ Keep,+ Delete,+ Insert,+}++/// Myers' shortest edit script from `a` to `b`, or `None` when it takes more than `max` steps.+fn edit_script<T: PartialEq>(a: &[T], b: &[T], max: usize) -> Option<Vec<Step>> {+ let (n, m) = (a.len() as isize, b.len() as isize);+ let max = max.min(a.len().saturating_add(b.len())) as isize;+ // Furthest x reached on each diagonal k = x - y, stored at k + max + 1.+ let at = |v: &[isize], k: isize| usize::try_from(k + max + 1).ok().and_then(|i| v.get(i).copied()).unwrap_or(0);+ let mut v = vec![0isize; (2 * max + 3) as usize];+ let mut trace = Vec::new();+ for d in 0..=max {+ trace.push(v.clone());+ for k in (-d..=d).step_by(2) {+ let down = k == -d || (k != d && at(&v, k - 1) < at(&v, k + 1));+ let mut x = if down { at(&v, k + 1) } else { at(&v, k - 1) + 1 };+ let mut y = x - k;+ while x < n && y < m && a.get(x as usize) == b.get(y as usize) {+ x += 1;+ y += 1;+ }+ if let Some(slot) = usize::try_from(k + max + 1).ok().and_then(|i| v.get_mut(i)) {+ *slot = x;+ }+ if x >= n && y >= m {+ return Some(backtrack(&trace, n, m, max));+ }+ }+ }+ None+}++/// Walk Myers' saved frontiers back from the end to the edit script.+fn backtrack(trace: &[Vec<isize>], n: isize, m: isize, max: isize) -> Vec<Step> {+ let at = |v: &[isize], k: isize| usize::try_from(k + max + 1).ok().and_then(|i| v.get(i).copied()).unwrap_or(0);+ let mut steps = Vec::new();+ let (mut x, mut y) = (n, m);+ for (d, v) in trace.iter().enumerate().rev() {+ let (d, k) = (d as isize, x - y);+ let prev_k = if k == -d || (k != d && at(v, k - 1) < at(v, k + 1)) { k + 1 } else { k - 1 };+ let prev_x = at(v, prev_k);+ let prev_y = prev_x - prev_k;+ while x > prev_x && y > prev_y {+ steps.push(Step::Keep);+ x -= 1;+ y -= 1;+ }+ if d > 0 {+ steps.push(if x == prev_x { Step::Insert } else { Step::Delete });+ }+ (x, y) = (prev_x, prev_y);+ }+ steps.reverse();+ steps+}++/// `old`, at char `at` of the source, became `new`: characters kept at either end keep their+/// runs, and the rest inherit the run just before the change (or the first one it replaces).+fn replaced(original: &[usize], at: usize, old: &[char], new: &[char], out: &mut Vec<usize>) {+ let prefix = old.iter().zip(new).take_while(|(a, b)| a == b).count();+ let suffix = old.iter().rev().zip(new.iter().rev()).take(old.len().min(new.len()).saturating_sub(prefix)).take_while(|(a, b)| a == b).count();+ let start = at.saturating_add(prefix);+ let inherited = start.checked_sub(1).and_then(|i| original.get(i)).or_else(|| original.get(start)).copied().unwrap_or(0);+ for i in 0..new.len() {+ let source = if i < prefix {+ original.get(at.saturating_add(i)).copied()+ } else if i >= new.len().saturating_sub(suffix) {+ original.get(at.saturating_add(old.len()).saturating_sub(new.len() - i)).copied()+ } else {+ Some(inherited)+ };+ out.push(source.unwrap_or(inherited));+ }+}++/// How a listing of [`text_blocks`] records a paragraph so that it can be found again.+///+/// The index of a paragraph is its position in a list regrouped from geometry on every read, so+/// an edit that merges or splits paragraphs makes the same index name another one (#2516). A key+/// names the paragraph by what it says and where it is; a paragraph that no longer exists as+/// such has no match, instead of a neighbour taking its place.+#[derive(Clone, Debug, PartialEq)]+pub struct BlockKey {+ text: String,+ rect: [f64; 4],+}++impl BlockKey {+ /// Two boxes are the same box within this many points.+ const TOLERANCE: f64 = 0.01;++ pub fn of(block: &TextBlock) -> Self {+ Self { text: block.text.clone(), rect: block.rect }+ }++ /// The paragraph's box when it was recorded (user space).+ pub fn rect(&self) -> [f64; 4] {+ self.rect+ }++ /// The paragraph in `blocks` with this text and box. `hint` is tried first, so two+ /// paragraphs drawn on top of one another are told apart by their order.+ pub fn find(&self, blocks: &[TextBlock], hint: usize) -> Option<usize> {+ let matches = |b: &TextBlock| b.text == self.text && b.rect.iter().zip(&self.rect).all(|(a, b)| (a - b).abs() <= Self::TOLERANCE);+ match blocks.get(hint) {+ Some(b) if matches(b) => Some(hint),+ _ => blocks.iter().position(matches),+ }+ }+}++/// The paragraph in `blocks` whose box overlaps `rect` the most, if any overlaps it at all. An+/// edit rewrites a paragraph in place, so this is the paragraph it became.+pub fn block_overlapping(blocks: &[TextBlock], rect: [f64; 4]) -> Option<usize> {+ // `f64::min` and `max` skip a NaN, which would make a box that isn't a number overlap anything.+ let area = |b: &TextBlock| {+ if !rect.iter().chain(&b.rect).all(|v| v.is_finite()) {+ return 0.0;+ }+ let w = b.rect[2].min(rect[2]) - b.rect[0].max(rect[0]);+ let h = b.rect[3].min(rect[3]) - b.rect[1].max(rect[1]);+ if w > 0.0 && h > 0.0 { w * h } else { 0.0 }+ };+ blocks.iter().enumerate().map(|(i, b)| (i, area(b))).filter(|(_, a)| *a > 0.0).max_by(|(_, a), (_, b)| a.total_cmp(b)).map(|(i, _)| i)+}++/// The paragraphs on a page (0-based).+pub fn text_blocks(doc: &Document, page: usize) -> Result<Vec<TextBlock>, EditError> {+ let lines = text_lines(doc, page)?;+ Ok(group_blocks(&lines))+}++/// Remove a paragraph's glyphs for a temporary editor background. Numeric TJ adjustments+/// preserve the text matrix, so unselected text positioned relative to it stays in place.+/// Call this on a clone: it is a preview operation, not a document edit.+pub fn clear_block(doc: &mut Document, page: usize, block: usize) -> Result<(), EditError> {+ let lines = text_lines(doc, page)?;+ let blocks = group_blocks(&lines);+ let target = blocks.get(block).ok_or_else(|| EditError::Invalid("the paragraph no longer exists".into()))?;+ let targets: Vec<&TextLine> = target.lines.iter().filter_map(|i| lines.get(*i)).collect();+ targets.iter().try_for_each(|line| line.ensure_editable())?;+ let mut drops = coincident_ops(&lines, &targets);+ drops.extend(target.lines.iter().filter_map(|i| lines.get(*i)).flat_map(|l| l.ops.iter().copied()));+ let p = page_dict(doc, page)?;+ let res = p.dict.get(b"Resources").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();+ let streams = content_streams(doc, &p.dict)?;+ let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ let shown = interpret(doc, &ops, &res, &mut HashMap::new(), &mut Carry::new(), None, None)?;+ let mut patches = HashMap::new();+ for s in shown.into_iter().filter(|s| drops.contains(&s.op)) {+ if s.state.render_mode >= 4 {+ return Err(EditError::Invalid("text used as a clipping path cannot be previewed for editing".into()));+ }+ let denominator = s.state.size * s.state.scale;+ let adjustment = if denominator != 0.0 { -1000.0 * s.advance / denominator } else { 0.0 };+ if !adjustment.is_finite() || (denominator == 0.0 && s.advance != 0.0) {+ return Err(EditError::Invalid("the paragraph's text advance cannot be previewed".into()));+ }+ let mut replacement = Vec::new();+ if let Some(op) = ops.get(s.op) {+ if op.is("\"") {+ replacement.push(Op::new("Tw", vec![op.operands.first().cloned().unwrap_or(Object::Int(0))]));+ replacement.push(Op::new("Tc", vec![op.operands.get(1).cloned().unwrap_or(Object::Int(0))]));+ }+ if op.is("'") || op.is("\"") {+ replacement.push(Op::new("T*", vec![]));+ }+ }+ replacement.push(Op::new("TJ", vec![Object::Array(vec![pdfcraft_content::num(adjustment)])]));+ patches.insert(s.op, replacement);+ }+ let data = splice(&pieces, &ops, |i| patches.remove(&i).map_or((Vec::new(), true), |v| (v, false)));+ let contents = rewritten_contents(doc, &streams, data);+ doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;+ Ok(())+}++/// The paragraphs on a page as a reader sees them, including text drawn by form XObjects+/// (Export to Word, HTML and RTF). Read-only: indexes into this list are not+/// [`text_blocks`] indexes, so they can't be passed to [`replace_block`] or [`rewrite_block`].+/// [`reading_blocks_checked`] also says whether text was left out.+pub fn reading_blocks(doc: &Document, page: usize) -> Result<Vec<TextBlock>, EditError> {+ reading_blocks_checked(doc, page).map(|r| r.blocks)+}++/// A page's paragraphs as a reader sees them ([`reading_blocks_checked`]).+#[derive(Clone, Debug, Default, PartialEq)]+pub struct ReadingBlocks {+ /// The paragraphs, as [`reading_blocks`] returns them.+ pub blocks: Vec<TextBlock>,+ /// The page draws forms nested deeper than [`MAX_FORM_DEPTH`], more of them than+ /// [`MAX_FORM_VISITS`], or forms that run past what the page's content left of its decode+ /// budget. Reading leaves those forms out to stay bounded on hostile files, so their text+ /// is missing from `blocks`; [`crate::reading_images`] walks the same forms and misses+ /// their images too.+ pub truncated: bool,+}++/// [`reading_blocks`], saying whether the limits that bound reading left text out. A page+/// whose `/Contents` alone runs past its decode budget is an [`EditError::Invalid`], not a+/// truncated result.+pub fn reading_blocks_checked(doc: &Document, page: usize) -> Result<ReadingBlocks, EditError> {+ let (lines, truncated) = reading_lines(doc, page)?;+ Ok(ReadingBlocks { blocks: regions::group_reading_blocks(&lines), truncated })+}++// An ideographic space carries intentional Japanese spacing, including paragraph indentation.+// Keep other whitespace normalization unchanged.+pub(crate) fn paragraph_separator(c: char) -> bool {+ c.is_whitespace() && c != '\u{3000}'+}++/// Greedy word wrapping to `width` with `advance` giving a string's width. Each `\n` starts a+/// new line. A row may also end inside a word of Chinese or Japanese text ([`crate::linebreak`]);+/// those pieces join without a space. Every white-space character is written as one space, so+/// a run of spaces typed between, before or after words stays (#4199); only the spaces where a+/// row wraps are dropped.+pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<String> {+ let mut out = Vec::new();+ for row in text.split('\n') {+ let mut line = String::new();+ let start = out.len();+ // The separators read since the last word: each one boundary between `split` pieces.+ let mut gap = 0usize;+ for (k, word) in row.split(paragraph_separator).enumerate() {+ if k > 0 {+ gap = gap.saturating_add(1);+ }+ if word.is_empty() {+ continue;+ }+ let spaces = " ".repeat(std::mem::take(&mut gap));+ for (i, piece) in crate::linebreak::pieces(word).into_iter().enumerate() {+ let candidate = if i == 0 { format!("{line}{spaces}{piece}") } else { format!("{line}{piece}") };+ // A row holding only the spaces that indent it doesn't wrap before its first word.+ if line.chars().any(|c| c != ' ') && advance(&candidate) > width {+ out.push(std::mem::take(&mut line));+ line = piece.to_string();+ } else {+ line = candidate;+ }+ }+ }+ line.push_str(&" ".repeat(gap));+ if !line.is_empty() || out.len() == start {+ out.push(line);+ }+ }+ out+}++/// Replace paragraph `block` (an index into [`text_blocks`]) with `text`, rewrapped to the+/// paragraph's width with its line spacing. The paragraph keeps its first line's position, font+/// (or Helvetica when the font can't show the text), size and colour.+pub fn replace_block(doc: &mut Document, page: usize, block: usize, text: &str) -> Result<LineEdit, EditError> {+ rewrite_block(doc, page, block, Some(text), &BlockStyle::default())+}++/// Formatting for a rewritten paragraph (`None` keeps the paragraph's own).+#[derive(Clone, Debug, Default, PartialEq)]+pub struct BlockStyle {+ /// Disjoint UTF-8 ranges in the replacement, each preserving unspecified source style.+ pub ranges: Vec<RangeStyle>,+ /// Explicit page font resource (from register_text_font or the page font inventory).+ pub resource: Option<String>,+ /// A standard font family, bold, italic.+ pub family: Option<(crate::added::Family, bool, bool)>,+ /// Override weight without choosing a different family (`None` keeps the source weight).+ pub bold: Option<bool>,+ /// Font size in points (user space).+ pub size: Option<f64>,+ /// Fill colour (RGB 0–1).+ pub color: Option<[f64; 3]>,+ pub align: Option<crate::added::Align>,+ /// Draw a line under each line of text.+ pub underline: Option<bool>,+ /// Line spacing as a multiple of the font size (1.2 is ordinary).+ pub line_spacing: Option<f64>,+ /// Character spacing (points) and horizontal scaling (percent).+ pub char_spacing: Option<f64>,+ pub scale: Option<f64>,+ /// Move the paragraph by `[dx, dy]` in user space (dragging its box).+ pub offset: Option<[f64; 2]>,+ /// Rewrap to this width in user space (dragging the box's edge).+ pub width: Option<f64>,+ /// For an invisible paragraph ([`TextBlock::invisible`]): fill its old area with this colour+ /// (RGB 0–1) before the new text, hiding the scanned word beneath it.+ pub cover: Option<[f64; 3]>,+}++#[derive(Clone, Debug, PartialEq)]+pub struct RangeStyle {+ pub range: std::ops::Range<usize>,+ pub family: Option<(crate::added::Family, bool, bool)>,+ pub resource: Option<String>,+ pub size: Option<f64>,+ pub color: Option<[f64; 3]>,+ pub underline: Option<bool>,+ pub char_spacing: Option<f64>,+ pub scale: Option<f64>,+}diff --git a/crates/edit/src/text/editor.rs b/crates/edit/src/text/editor.rsnew file mode 100644index 000000000..b2bd2b9f9--- /dev/null+++ b/crates/edit/src/text/editor.rs@@ -0,0 +1,127 @@+use super::blocks::{BlockStyle, TextBlock};+use super::fallback::MAX_TYPE3_GLYPHS;+use super::lines::{page_dict, text_lines};+use super::rewrite::rewrite_block_from;+use super::*;++/// An embedded sfnt source face, read only for the inline editor. Bytes stay in memory and+/// are never installed, copied into assets, or used as a font for another document.+#[derive(Clone, Debug)]+pub struct TextEditorFont {+ pub resource: String,+ pub face: String,+ pub bytes: Vec<u8>,+}++pub fn text_editor_fonts(doc: &Document, page: usize) -> Result<Vec<TextEditorFont>, EditError> {+ let p = page_dict(doc, page)?;+ let resources = p.dict.get(b"Resources").and_then(|o| doc.dict(o)).unwrap_or_default();+ let fonts = resources.get(b"Font").and_then(|o| doc.dict(o)).unwrap_or_default();+ let mut budget = 32_usize << 20;+ // Every program decoded counts, usable or not, so aliases of one program can't repeat the work.+ let mut decode = DecodeBudget::new(2 * budget, 0);+ let mut result = Vec::new();+ for (name, font) in fonts.iter().take(128) {+ let Some(font) = doc.dict(font) else { continue };+ let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt_within(doc, &font, &mut decode) else { continue };+ if bytes.len() > budget {+ continue;+ }+ budget -= bytes.len();+ result.push(TextEditorFont {+ resource: String::from_utf8_lossy(name).into_owned(),+ face: Metrics::from_dict(doc, &font).base_font.rsplit('+').next().unwrap_or_default().to_owned(),+ bytes,+ });+ }+ // The approved full face follows all source subsets in the editor's font stack. It can+ // display newly inserted glyphs before Apply without changing the source text's face.+ let source_faces: Vec<_> = result.iter().map(|p| p.face.clone()).collect();+ for face in source_faces {+ for full in pdfcraft_fonts::embedding::matching_faces(&face) {+ if full.bytes.len() > budget || result.iter().any(|p| p.resource == format!("PCApproved{}", full.name())) {+ continue;+ }+ budget -= full.bytes.len();+ result.push(TextEditorFont { resource: format!("PCApproved{}", full.name()), face: face.clone(), bytes: full.bytes.to_vec() });+ }+ }+ Ok(result)+}++/// Load an explicit full face into this page's resources. Nothing on the page is replaced;+/// the new resource can complete matching source subsets or be chosen in a text style.+pub fn register_text_font(doc: &mut Document, page: usize, bytes: &[u8]) -> Result<String, EditError> {+ pdfcraft_fonts::embedding::validate_document_input(bytes).map_err(EditError::Invalid)?;+ let (_, postscript) = pdfcraft_fonts::embedding::names(bytes).map_err(EditError::Invalid)?;+ let p = page_dict(doc, page)?;+ let mut resources = p.dict.get(b"Resources").and_then(|o| doc.dict(o)).unwrap_or_default();+ let mut fonts = resources.get(b"Font").and_then(|o| doc.dict(o)).unwrap_or_default();+ let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, bytes, &postscript).map_err(EditError::Invalid)?;+ resources.set(b"Font".to_vec(), Object::Dict(fonts));+ doc.update_dict(p.obj, |d| d.set(b"Resources".to_vec(), Object::Dict(resources)))?;+ Ok(name)+}++/// Read-only draft bounds, measured with the same PDF rewrite used by Apply/Save.+#[derive(Clone, Debug, PartialEq)]+pub struct TextEditLayout {+ pub source_rect: [f64; 4],+ pub draft_rect: Option<[f64; 4]>,+ pub overflow: bool,+}++pub fn text_edit_layout(doc: &Document, page: usize, block: usize, text: &str, style: &BlockStyle) -> Result<TextEditLayout, EditError> {+ TextSession::open(doc, page, block)?.layout(text, style)+}++/// A draft of paragraph `source` (number `block` among the page's `lines`) laid out by the rewrite+/// Apply runs, on a copy of `doc`.+pub(crate) fn layout_draft(+ doc: &Document,+ page: usize,+ lines: &[TextLine],+ source: &TextBlock,+ block: usize,+ text: &str,+ style: &BlockStyle,+) -> Result<TextEditLayout, EditError> {+ if text == source.editor_text && *style == BlockStyle::default() {+ return Ok(TextEditLayout { source_rect: source.rect, draft_rect: Some(source.rect), overflow: false });+ }+ // Subtract the untouched runs by value, rather than by operator offsets: a rewrite may+ // split BT/ET or add font resources. A multiset also handles coincident repeated text.+ let key =+ |line: &TextLine| (line.text.clone(), line.font.clone(), line.rect.map(f64::to_bits), line.size.to_bits(), line.color.map(f64::to_bits));+ let mut untouched = std::collections::BTreeMap::new();+ for (index, line) in lines.iter().enumerate() {+ if !source.lines.contains(&index) {+ *untouched.entry(key(line)).or_insert(0_usize) += 1;+ }+ }+ let mut draft = doc.clone();+ rewrite_block_from(&mut draft, page, lines.to_vec(), block, Some(text), style, MAX_TYPE3_GLYPHS)?;+ let mut rect: Option<[f64; 4]> = None;+ for line in text_lines(&draft, page)? {+ if let Some(count) = untouched.get_mut(&key(&line))+ && *count > 0+ {+ *count -= 1;+ continue;+ }+ // Spaces typed after a row's last word are drawn but show nothing, so an upright row is+ // measured to the end of its last word: they don't make a draft overflow (#4199).+ let mut r = line.rect;+ if line.upright() && !line.ink.is_empty() {+ if crate::bidi::rtl_base(&line.text) {+ r[0] = r[0].max(line.ink.iter().map(|i| i[0]).fold(f64::INFINITY, f64::min));+ } else {+ r[2] = r[2].min(line.ink.iter().map(|i| i[2]).fold(f64::NEG_INFINITY, f64::max));+ }+ }+ rect = Some(rect.map_or(r, |a| [a[0].min(r[0]), a[1].min(r[1]), a[2].max(r[2]), a[3].max(r[3])]));+ }+ let overflow = rect+ .is_some_and(|r| r[0] < source.rect[0] - 0.5 || r[1] < source.rect[1] - 0.5 || r[2] > source.rect[2] + 0.5 || r[3] > source.rect[3] + 0.5);+ Ok(TextEditLayout { source_rect: source.rect, draft_rect: rect, overflow })+}diff --git a/crates/edit/src/text/fallback.rs b/crates/edit/src/text/fallback.rsnew file mode 100644index 000000000..0c19a6680--- /dev/null+++ b/crates/edit/src/text/fallback.rs@@ -0,0 +1,599 @@+use super::interp::Ts;+use super::lines::page_dict;+use super::*;++/// Text → the runs that show it: each run's font resource name and the bytes shown in that font.+pub(super) type Encoder = Box<dyn Fn(&str) -> Option<Vec<(String, Vec<u8>)>>>;++fn is_win_ansi_char(c: char) -> bool {+ c == '\t' || pdfcraft_fonts::win_ansi_byte(c).is_some()+}++pub(crate) fn needs_type3(text: &str) -> bool {+ text.chars().any(|c| !is_win_ansi_char(c))+}++/// The `/Name` of the Type 3 fonts generated for Japanese text.+const JAPANESE_FONT_NAME: &str = "PCJapanese";++/// The `/Name` of the Type 3 fonts generated for Hebrew text.+const HEBREW_FONT_NAME: &str = "PCHebrew";++/// The `/Name` of the Type 3 fonts generated from the bundled Latin (Inter) face.+const LATIN_FONT_NAME: &str = "PCLatin";++/// Whether `font` is one of those generated fonts (Latin, Japanese or Hebrew): a replacement longer+/// than one of them is split across several, which read back as one line (see [`same_font`]).+pub(super) fn is_type3_fallback(font: &Dict) -> bool {+ font.name(b"Subtype") == Some(b"Type3")+ && font+ .name(b"Name")+ .is_some_and(|n| n == JAPANESE_FONT_NAME.as_bytes() || n == HEBREW_FONT_NAME.as_bytes() || n == LATIN_FONT_NAME.as_bytes())+}++/// The generated font's `/Name` and its resource prefix: the bundled Latin face, Hebrew, or the+/// Japanese ones.+fn fallback_names(face: &CraftFont, hebrew: bool) -> (&'static str, &'static str) {+ if hebrew {+ (HEBREW_FONT_NAME, "PCHe")+ } else if face.family == "Inter" {+ (LATIN_FONT_NAME, "PCLat")+ } else {+ (JAPANESE_FONT_NAME, "PCJp")+ }+}++/// Drops the generated fallback fonts ([`is_type3_fallback`]) that nothing on `page` shows any more.+/// Each rewrite generates its own, with the outlines of every character it draws, so without this+/// an earlier rewrite's fonts stay in the page's resources and the file. Only a font dictionary the+/// page owns is changed (a rewrite gives the page its own), and nothing is dropped unless every+/// content stream that may name the page's fonts can be read: the page's own, and those of form+/// XObjects and Type 3 glyphs that have no resources of their own and so use the page's.+pub(super) fn drop_unused_fallback_fonts(doc: &mut Document, page: usize) {+ let Ok(p) = page_dict(doc, page) else { return };+ let Some(Object::Dict(mut resources)) = p.dict.get(b"Resources").cloned() else { return };+ let Some(mut fonts) = resources.get(b"Font").and_then(|f| doc.dict(f)) else { return };+ let generated: Vec<Vec<u8>> =+ fonts.iter().filter(|(_, f)| doc.dict(f).is_some_and(|d| is_type3_fallback(&d))).map(|(name, _)| name.clone()).collect();+ if generated.is_empty() {+ return;+ }+ let Some(shown) = fonts_shown(doc, &p.dict, &resources) else { return };+ let unused: Vec<&Vec<u8>> = generated.iter().filter(|name| !shown.contains(*name)).collect();+ if unused.is_empty() {+ return;+ }+ for name in unused {+ fonts.remove(name);+ }+ resources.set(b"Font".to_vec(), Object::Dict(fonts));+ // Nothing is lost if this fails: the fonts just stay.+ let _ = doc.update_dict(p.obj, |d| d.set(b"Resources".to_vec(), Object::Dict(resources)));+}++/// The font resource names `Tf` selects in the page's content and in the content that uses the+/// page's resources (see [`drop_unused_fallback_fonts`]), or `None` if any of it can't be read.+fn fonts_shown(doc: &Document, page: &Dict, resources: &Dict) -> Option<std::collections::HashSet<Vec<u8>>> {+ let mut streams: Vec<Object> = match page.get(b"Contents") {+ None => Vec::new(),+ Some(c) => match &*doc.resolve(c) {+ Object::Array(a) => a.clone(),+ _ => vec![c.clone()],+ },+ };+ // Form XObjects without their own resources use the page's, however deeply they are nested+ // (ISO 32000-1 §7.8.3), so every form the page can reach is visited.+ let mut pending: Vec<Dict> = vec![resources.clone()];+ let mut seen = std::collections::HashSet::new();+ while let Some(res) = pending.pop() {+ for (_, x) in res.get(b"XObject").and_then(|x| doc.dict(x)).unwrap_or_default().iter() {+ let Some(r) = x.as_ref() else { continue };+ if !seen.insert(r) {+ continue;+ }+ if seen.len() > 4096 {+ return None;+ }+ let Object::Stream(s) = &*doc.get(r) else { continue };+ if s.dict.name(b"Subtype") != Some(b"Form") {+ continue;+ }+ match s.dict.get(b"Resources").and_then(|r| doc.dict(r)) {+ Some(own) => pending.push(own),+ None => streams.push(x.clone()),+ }+ }+ }+ // And so do Type 3 glyph procedures without their own (the generated fonts' are outlines only).+ for (_, f) in resources.get(b"Font").and_then(|f| doc.dict(f)).unwrap_or_default().iter() {+ if let Some(font) = doc.dict(f).filter(|d| d.name(b"Subtype") == Some(b"Type3") && !d.contains(b"Resources") && !is_type3_fallback(d)) {+ streams.extend(font.get(b"CharProcs").and_then(|c| doc.dict(c)).unwrap_or_default().iter().map(|(_, proc)| proc.clone()));+ }+ }+ let mut shown = std::collections::HashSet::new();+ for stream in streams {+ let Object::Stream(s) = &*doc.resolve(&stream) else { return None };+ // Strict: a stream only partly read might name a font in the part that wasn't.+ let data = s.decoded_strict().ok()?;+ for op in parse(&data).ops {+ if op.is("Tf")+ && let Some(name) = op.operands.first().and_then(|n| n.as_name())+ {+ shown.insert(name.to_vec());+ }+ }+ }+ Some(shown)+}++/// Whether a run shown in `font` (a resource name), with `/BaseFont` `base_font` and the Japanese+/// or Hebrew fallback face it subsets, if any, continues `line`: the same font resource, another+/// resource for the same font (a writer may split one font into several subsets, #3661), or+/// another subset of the same face.+pub(crate) fn same_font(line: &TextLine, font: &[u8], base_font: &str, face: Option<&str>) -> bool {+ line.font.as_bytes() == font || same_base_font(&line.base_font, base_font) || (line.face.is_some() && line.face.as_deref() == face)+}++/// Whether a run painted with `ts` continues `line` as it is painted: a line is rewritten in the+/// state of its first run, so a `Tr`, stroke colour or line width that changes partway starts+/// another run (see [`TextState::paint_ops`]; the `gs` parameters are compared as [`Paint`]).+/// The stroke colour, width, dash and cap only count for text that is stroked, so a rule drawn+/// between two words doesn't split their line. They are compared as values, wherever they were+/// set: two ExtGStates with the same settings under other names still continue a line.+///+/// Only the visible modes (`Tr` 0–2) that `paint_ops` restates are compared: a line that goes on+/// as invisible or clipping text stays one line, which the clipping refusal reads whole (#3447).+pub(super) fn same_paint(line: &TextLine, ts: &Ts) -> bool {+ let a = &line.origin.state;+ let visible = |m: i64| (0..=2).contains(&m);+ let same_mode = a.render_mode == ts.render_mode || !visible(a.render_mode) || !visible(ts.render_mode);+ let stroked = matches!((a.render_mode, ts.render_mode), (1 | 2, 1 | 2));+ let outline = a.stroke == ts.stroke && a.line_width == ts.line_width && a.dash == ts.dash && a.line_cap == ts.line_cap;+ same_mode && (!stroked || outline)+}++/// Whether two `/BaseFont` names name the same font: a subset's six-letter tag and `+` prefix do+/// not change the font (ISO 32000-2 §9.6.4), so `ABCDEF+Arial` and `GHIJKL+Arial` are one font.+/// A name that is missing, or only a tag (`ABCDEF+`), names no font and matches nothing.+pub(crate) fn same_base_font(a: &str, b: &str) -> bool {+ let (a, b) = (strip_subset_tag(a), strip_subset_tag(b));+ !a.is_empty() && a == b+}++/// `ABCDEF+Arial` → `Arial`. A name without a subset tag is returned unchanged.+pub(crate) fn strip_subset_tag(name: &str) -> &str {+ let bytes = name.as_bytes();+ let is_tag = bytes.get(6) == Some(&b'+') && bytes.get(..6).is_some_and(|tag| tag.iter().all(u8::is_ascii_uppercase));+ if is_tag { name.get(7..).unwrap_or(name) } else { name }+}++pub(crate) fn source_family(base_font: &str) -> crate::added::Family {+ let name = base_font.to_ascii_lowercase();+ if ["courier", "mono", "consolas", "menlo", "monaco", "lucida console"].iter().any(|s| name.contains(s)) {+ crate::added::Family::Courier+ } else if !name.contains("sans")+ && ["times", "serif", "roman", "mincho", "cambria", "georgia", "palatino", "garamond"].iter().any(|s| name.contains(s))+ {+ crate::added::Family::Times+ } else {+ crate::added::Family::Helvetica+ }+}++pub(crate) const MAX_TYPE3_GLYPHS: usize = 240;++/// The generated fonts for one replacement: one per run of at most `max_glyphs` unique characters,+/// in order of first appearance.+#[derive(Clone)]+pub(crate) struct Type3Fallback {+ /// The family its glyphs come from ("Shippori Mincho").+ pub(crate) family: &'static str,+ /// The fonts' resource names in order; the first is `PCJp` (`PCLat` for the bundled Latin+ /// face, `PCHe` for Hebrew text).+ pub(crate) names: Vec<String>,+ /// Every unique character with its advance (em), in order of first appearance.+ pub(super) widths: Vec<(char, f64)>,+ /// Where each character is shown: the index of its font in `names`, and its code there.+ pub(crate) codes: HashMap<char, (usize, u8)>,+}++/// One glyph of a generated font: its code there, its character, its glyph procedure and advance.+pub(crate) struct Type3Glyph {+ pub(crate) code: u8,+ pub(crate) ch: char,+ pub(crate) path: Vec<u8>,+ pub(crate) width: f64,+}++fn pdf_num(v: f64) -> String {+ if v.fract() == 0.0 { format!("{v:.0}") } else { format!("{v:.4}").trim_end_matches('0').trim_end_matches('.').to_string() }+}++fn type3_path(face: &CraftFont, ch: char) -> Result<(Vec<u8>, f64), EditError> {+ let glyph = japanese_glyph_from(face, ch).map_err(|e| match e {+ GlyphError::NoFont => no_japanese_font(),+ GlyphError::Missing => EditError::Invalid(format!("the {} fallback font has no glyph for U+{:04X}", face.family, ch as u32)),+ GlyphError::TooComplex => EditError::Invalid(format!("the {} fallback glyph U+{:04X} is too complex", face.family, ch as u32)),+ })?;+ let (dx, width) = proportional(ch, &glyph);+ let scale = 1000.0;+ // d1 is `wx wy llx lly urx ury` (ISO 32000-2 §9.6.4) with a box enclosing the glyph;+ // Acrobat draws a bullet in place of a glyph whose d1 is malformed.+ let b = if glyph.contours.is_empty() { [0.0; 4] } else { glyph.bbox };+ let mut out = format!(+ "{} 0 {} {} {} {} d1\n",+ pdf_num(width * scale),+ pdf_num(((b[0] + dx) * scale).floor()),+ pdf_num((b[1] * scale).floor()),+ pdf_num(((b[2] + dx) * scale).ceil()),+ pdf_num((b[3] * scale).ceil())+ )+ .into_bytes();+ for contour in glyph.contours {+ let Some(first) = contour.first() else { continue };+ out.extend_from_slice(format!("{} {} m\n", pdf_num((first[0] + dx) * scale), pdf_num(first[1] * scale)).as_bytes());+ for p in contour.iter().skip(1) {+ out.extend_from_slice(format!("{} {} l\n", pdf_num((p[0] + dx) * scale), pdf_num(p[1] * scale)).as_bytes());+ }+ out.extend_from_slice(b"h\n");+ }+ out.extend_from_slice(b"f\n");+ Ok((out, width))+}++/// Side bearing (em) given to a respaced glyph on each side.+const SIDE_BEARING: f64 = 0.05;++/// Shift and advance for a fallback glyph. Japanese faces draw Cyrillic and Greek full-width+/// (one em each, as in JIS X 0208) and have no proportional (`palt`) metrics for them, so a+/// word set that way reads as letter-spaced. Those letters get their ink width plus a side+/// bearing instead; everything else keeps the face's own advance.+fn proportional(ch: char, glyph: &pdfcraft_fonts::GlyphOutline) -> (f64, f64) {+ let respace = matches!(ch, '\u{0370}'..='\u{03FF}' | '\u{0400}'..='\u{052F}' | '\u{1F00}'..='\u{1FFF}');+ let ink = glyph.bbox[2] - glyph.bbox[0];+ if !respace || glyph.contours.is_empty() || !(ink > 0.0 && ink < glyph.width) {+ return (0.0, glyph.width);+ }+ (SIDE_BEARING - glyph.bbox[0], ink + 2.0 * SIDE_BEARING)+}++fn unicode_hex(ch: char) -> String {+ let mut units = [0u16; 2];+ let encoded = ch.encode_utf16(&mut units);+ encoded.iter().map(|u| format!("{u:04X}")).collect()+}++/// The same outline for a face that may simply lack the glyph: `None` then, so the caller can try+/// the next face (and report the character once none of them has it).+pub(crate) fn type3_glyph(face: &CraftFont, ch: char) -> Result<Option<(Vec<u8>, f64)>, EditError> {+ match japanese_glyph_from(face, ch) {+ Err(GlyphError::Missing) => Ok(None),+ _ => type3_path(face, ch).map(Some),+ }+}++/// No face this build has can draw `text`. Only Japanese text is about the Japanese face: other+/// characters are missing from the paragraph's font, and choosing a font that has them works too.+pub(crate) fn no_fallback_font(text: &str) -> EditError {+ if text.chars().any(needs_japanese) {+ return no_japanese_font();+ }+ let Some(ch) = text.chars().find(|c| !c.is_whitespace() && !is_win_ansi_char(*c)) else { return no_japanese_font() };+ EditError::Invalid(format!(+ "the paragraph's font has no glyph for {ch} (U+{:04X}) and this build has no fallback font for it; \+ choose a font that has it (Load font… or Installed fonts…), or use an official release, which includes \+ PdfCraft's fallback fonts (to build them in, set CRAFT_FONTS_DIR to a craft-fonts checkout)",+ u32::from(ch)+ ))+}++/// The character the craft-fonts Japanese faces are for: kana, CJK ideographs and their compatibility+/// and full-width forms.+fn needs_japanese(ch: char) -> bool {+ matches!(u32::from(ch), 0x3000..=0x30FF | 0x3400..=0x4DBF | 0x4E00..=0x9FFF | 0xF900..=0xFAFF | 0xFF00..=0xFFEF)+}++/// The chosen face has no outline for `ch`, and neither has any other: say which character it is and+/// what the writer can do about it. A CJK character without a Japanese face in the build is about+/// that build input, which is the one answer that changes it.+pub(crate) fn no_glyph_for(face: &CraftFont, ch: char) -> EditError {+ if needs_japanese(ch) && pdfcraft_fonts::document_japanese_font().is_none() {+ return no_japanese_font();+ }+ EditError::Invalid(format!(+ "the {} fallback font has no glyph for {ch} (U+{:04X}), and no fallback face covers the text; \+ choose a font that has it (Load font… or Installed fonts…), or use an official release, which includes \+ PdfCraft's fallback fonts (to build them in, set CRAFT_FONTS_DIR to a craft-fonts checkout)",+ face.family,+ u32::from(ch)+ ))+}++/// This build has no Japanese face to draw replacement text with.+pub(super) fn no_japanese_font() -> EditError {+ EditError::Invalid(+ "this text needs PdfCraft's Japanese fallback font, which this build doesn't include \+ (official releases do; to build it in, set CRAFT_FONTS_DIR to a craft-fonts checkout)"+ .into(),+ )+}++/// The first of `faces` (best match first) that has a glyph for every one of `chars`, else the first.+pub(crate) fn fallback_face<'a>(faces: &[&'a CraftFont], chars: &[char], has_glyph: impl Fn(&CraftFont, char) -> bool) -> Option<&'a CraftFont> {+ faces.iter().copied().find(|face| chars.iter().all(|ch| has_glyph(face, *ch))).or_else(|| faces.first().copied())+}++/// This build has no Hebrew face to draw replacement text with.+fn no_hebrew_font() -> EditError {+ EditError::Invalid(+ "this text needs PdfCraft's Hebrew fallback font (Noto Sans Hebrew), which this build doesn't include \+ (to build it in, set CRAFT_FONTS_DIR to a craft-fonts checkout that has it)"+ .into(),+ )+}++/// The faces a Type 3 replacement may draw `text` with, best first. Text with Hebrew takes the+/// Hebrew face first (its Latin and digits too, so a line keeps one look), then the Japanese faces+/// and the bundled Latin one for anything it lacks; other text takes the Japanese faces, and the+/// bundled Latin face behind them, which covers the Latin, Greek and Cyrillic letters they lack+/// (#2593: the Japanese faces have no қ, ғ, ҳ, ә, ө, ү, ұ or һ).+pub(crate) fn type3_faces(text: &str, family: crate::added::Family, bold: bool) -> Result<(Vec<&'static CraftFont>, bool), EditError> {+ let japanese = pdfcraft_fonts::document_japanese_fonts_for_style(family == crate::added::Family::Times, bold);+ let latin = pdfcraft_fonts::document_latin_fonts(bold);+ if !text.chars().any(crate::bidi::is_hebrew) {+ return Ok((japanese.into_iter().chain(latin).collect(), false));+ }+ // Points are drawn on their letter with the font's positioning, which a one-glyph-per-+ // character Type 3 font can't do; refuse rather than print them beside the letter.+ if text.chars().any(crate::bidi::is_hebrew_mark) {+ return Err(EditError::Invalid("Hebrew points (niqqud) can't be written into a PDF yet; type the text without them".into()));+ }+ let hebrew = pdfcraft_fonts::document_hebrew_font(bold).ok_or_else(no_hebrew_font)?;+ Ok((std::iter::once(hebrew).chain(japanese).chain(latin).collect(), true))+}++pub(super) fn type3_font(+ doc: &mut Document,+ fonts_res: &mut Dict,+ text: &str,+ family: crate::added::Family,+ bold: bool,+ max_glyphs: usize,+) -> Result<Type3Fallback, EditError> {+ let (faces, hebrew) = type3_faces(text, family, bold)?;+ // Each unique character once, in order of first appearance.+ let mut chars = Vec::new();+ let mut seen = std::collections::HashSet::new();+ for ch in text.chars() {+ if seen.insert(ch) {+ chars.push(ch);+ }+ }+ if chars.is_empty() {+ return Err(EditError::Invalid("replacement text is empty".into()));+ }+ // The faces differ in coverage (e.g. of Cyrillic), so use the best face that has every+ // character. When none has them all, the best face reports the character it lacks. Hebrew+ // text keeps the Hebrew face and takes each character it lacks from the next face that has it.+ let face = if hebrew { faces.first().copied() } else { fallback_face(&faces, &chars, |face, ch| japanese_glyph_from(face, ch).is_ok()) }+ .ok_or_else(|| no_fallback_font(text))?;+ let others: &[&CraftFont] = if hebrew { faces.get(1..).unwrap_or_default() } else { &[] };+ // Every outline is read before the document is touched, so a character that fails leaves it+ // as it was. Each font takes the next `per_font` characters; codes restart at 1 in each.+ let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);+ let mut glyphs = Vec::with_capacity(chars.len());+ for (i, ch) in chars.into_iter().enumerate() {+ // The chosen face first, then the faces after it (Hebrew text takes a character the Hebrew+ // face lacks from the next face that has it); a character no face draws is reported once.+ let mut drawn = type3_glyph(face, ch)?;+ for f in others.iter().copied() {+ if drawn.is_some() {+ break;+ }+ drawn = type3_glyph(f, ch)?;+ }+ let Some((path, width)) = drawn else { return Err(no_glyph_for(face, ch)) };+ let code = u8::try_from((i % per_font).saturating_add(1))+ .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;+ glyphs.push(Type3Glyph { code, ch, path, width });+ }+ Ok(write_type3_glyphs(doc, fonts_res, face, hebrew, glyphs, per_font))+}++/// Write already validated outlines; callers can prepare every face before adding any objects.+pub(crate) fn write_type3_glyphs(+ doc: &mut Document,+ fonts_res: &mut Dict,+ face: &CraftFont,+ hebrew: bool,+ glyphs: Vec<Type3Glyph>,+ per_font: usize,+) -> Type3Fallback {+ let per_font = per_font.clamp(1, MAX_TYPE3_GLYPHS);+ let mut codes = HashMap::with_capacity(glyphs.len());+ let mut widths = Vec::with_capacity(glyphs.len());+ let mut names = Vec::new();+ let mut glyphs = glyphs.into_iter();+ loop {+ let group: Vec<Type3Glyph> = glyphs.by_ref().take(per_font).collect();+ if group.is_empty() {+ break;+ }+ for glyph in &group {+ codes.insert(glyph.ch, (names.len(), glyph.code));+ widths.push((glyph.ch, glyph.width));+ }+ names.push(add_type3_font(doc, fonts_res, face, hebrew, group));+ }+ Type3Fallback { family: face.family, names, widths, codes }+}++/// Adds one generated font whose codes 1 to `glyphs.len()` show `glyphs`, and returns its resource+/// name (`PCLat`, `PCJp`, then `PCJp1`, ...; `PCHe`, ... for Hebrew text). Nothing here can fail: the+/// outlines were read already.+pub(super) fn add_type3_font(doc: &mut Document, fonts_res: &mut Dict, face: &CraftFont, hebrew: bool, glyphs: Vec<Type3Glyph>) -> String {+ let last_char = glyphs.len();+ let mut charprocs = Dict::new();+ let mut widths = Vec::with_capacity(last_char);+ let mut differences = vec![Object::Int(1)];+ let mut cmap = String::from(+ "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CMapType 2 def\n1 begincodespacerange\n<01> <FF>\nendcodespacerange\n",+ );+ cmap.push_str(&format!("{last_char} beginbfchar\n"));+ for glyph in glyphs {+ let glyph_name = format!("g{:02X}", glyph.code);+ let mut pd = Dict::new();+ pd.set(b"Length".to_vec(), glyph.path.len() as i64);+ let proc_ref = doc.add(Object::Stream(Stream::from_raw(pd, glyph.path)));+ charprocs.set(glyph_name.as_bytes().to_vec(), Object::Ref(proc_ref));+ differences.push(Object::name(&glyph_name));+ widths.push(Object::Real((glyph.width * 1000.0).round()));+ cmap.push_str(&format!("<{:02X}> <{}>\n", glyph.code, unicode_hex(glyph.ch)));+ }+ cmap.push_str("endbfchar\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");+ let mut cmap_dict = Dict::new();+ cmap_dict.set(b"Length".to_vec(), cmap.len() as i64);+ let cmap_ref = doc.add(Object::Stream(Stream::from_raw(cmap_dict, cmap.into_bytes())));+ let mut encoding = Dict::new();+ encoding.set(b"Type".to_vec(), Object::name("Encoding"));+ encoding.set(b"Differences".to_vec(), Object::Array(differences));+ let mut font = Dict::new();+ font.set(b"Type".to_vec(), Object::name("Font"));+ font.set(b"Subtype".to_vec(), Object::name("Type3"));+ let (font_name, prefix) = fallback_names(face, hebrew);+ font.set(b"Name".to_vec(), Object::name(font_name));+ let mut descriptor = Dict::new();+ descriptor.set(b"Type".to_vec(), Object::name("FontDescriptor"));+ descriptor.set(b"FontName".to_vec(), Object::name(&format!("{}-{}", face.family, face.style).replace(' ', "")));+ descriptor.set(b"FontFamily".to_vec(), Object::String(PdfString::literal(face.family.as_bytes().to_vec())));+ descriptor.set(b"Flags".to_vec(), Object::Int(if face.family.contains("Mincho") { 6 } else { 4 }));+ descriptor.set(b"ItalicAngle".to_vec(), Object::Int(0));+ // PDF 1.7 tables 5.9 and 5.19: a Type 3 descriptor is indirect; Ascent/Descent may be omitted.+ font.set(b"FontDescriptor".to_vec(), Object::Ref(doc.add(Object::Dict(descriptor))));+ font.set(b"FontBBox".to_vec(), Object::Array(vec![Object::Int(0), Object::Int(-300), Object::Int(1000), Object::Int(1000)]));+ font.set(+ b"FontMatrix".to_vec(),+ Object::Array(vec![Object::Real(0.001), Object::Int(0), Object::Int(0), Object::Real(0.001), Object::Int(0), Object::Int(0)]),+ );+ font.set(b"FirstChar".to_vec(), Object::Int(1));+ font.set(b"LastChar".to_vec(), Object::Int(last_char as i64));+ font.set(b"Widths".to_vec(), Object::Array(widths));+ font.set(b"Encoding".to_vec(), Object::Dict(encoding));+ font.set(b"CharProcs".to_vec(), Object::Dict(charprocs));+ font.set(b"ToUnicode".to_vec(), Object::Ref(cmap_ref));+ let mut name = String::from(prefix);+ let mut suffix = 0usize;+ while fonts_res.contains(name.as_bytes()) {+ suffix = suffix.saturating_add(1);+ name = format!("{prefix}{suffix}");+ }+ fonts_res.set(name.as_bytes().to_vec(), Object::Dict(font));+ name+}++/// The runs that show `text` in the fallback: consecutive characters in one font form one run, so+/// a font is switched only where the text moves to another font. `None` if a character has no code.+pub(super) fn type3_encode(fallback: &Type3Fallback, text: &str) -> Option<Vec<(String, Vec<u8>)>> {+ let mut runs: Vec<(usize, Vec<u8>)> = Vec::new();+ for ch in text.chars() {+ let (font, code) = *fallback.codes.get(&ch)?;+ match runs.last_mut() {+ Some((last, bytes)) if *last == font => bytes.push(code),+ _ => runs.push((font, vec![code])),+ }+ }+ runs.into_iter().map(|(font, bytes)| Some((fallback.names.get(font)?.clone(), bytes))).collect()+}++/// The source font's own TrueType/OpenType program, when the document embeds a complete one whose+/// licence allows editable embedding. A subset (an `ABCDEF+` name) is left out: a character can keep+/// its mapping there after the subsetter dropped its outline.+pub(crate) fn source_program(doc: &Document, fonts: &Dict, name: &str) -> Option<Vec<u8>> {+ let font = fonts.get(name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned())?;+ let base = Metrics::from_dict(doc, &font).base_font;+ if base.split_once('+').is_some_and(|(tag, _)| tag.len() == 6 && tag.bytes().all(|b| b.is_ascii_uppercase())) {+ return None;+ }+ let bytes = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)?;+ pdfcraft_fonts::embedding::validate(&bytes).is_ok().then_some(bytes)+}++/// Whether `text` has characters `line`'s font can't encode that its own program can draw.+pub(super) fn source_program_completes(doc: &Document, fonts: &Dict, line: &TextLine, text: &str) -> bool {+ let Some(metrics) = fonts.get(line.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|f| Metrics::from_dict(doc, &f)) else {+ return false;+ };+ let missing: String = text.chars().filter(|c| !c.is_whitespace() && !source_encodes(&metrics, &c.to_string())).collect();+ !missing.is_empty() && source_program(doc, fonts, &line.font).is_some_and(|bytes| pdfcraft_fonts::embedding::covers(&bytes, &missing))+}++/// A subset may contain all the letters but no space glyph: producers use another subset+/// or a positioning operator for spaces. Do the same instead of substituting the whole font.+pub(crate) fn source_encodes(metrics: &Metrics, text: &str) -> bool {+ text.split(' ').all(|word| metrics.encode(word).is_some())+}++#[cfg(test)]+thread_local! {+ /// How often [`source_space`] ran on this thread, for the test that pins it out of per-character loops.+ pub(crate) static SOURCE_SPACE_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+}++pub(crate) fn source_space(doc: &Document, fonts: &Dict, metrics: &Metrics) -> f64 {+ #[cfg(test)]+ SOURCE_SPACE_CALLS.with(|c| c.set(c.get().saturating_add(1)));+ let width = |m: &Metrics| m.encode(" ").map(|b| m.codes(&b).iter().map(|(c, _)| m.width(*c)).sum::<f64>());+ if let Some(w) = width(metrics) {+ return w;+ }+ let family = metrics.base_font.rsplit('+').next().unwrap_or(&metrics.base_font);+ for (_, font) in fonts.iter() {+ if let Some(dict) = doc.resolve(font).as_dict() {+ let m = Metrics::from_dict(doc, dict);+ if m.base_font.rsplit('+').next() == Some(family)+ && let Some(w) = width(&m)+ {+ return w;+ }+ }+ }+ 0.33+}++pub(crate) fn source_width(metrics: &Metrics, text: &str, size: f64, space: f64, char_spacing: f64, word_spacing: f64) -> f64 {+ if let Some(bytes) = metrics.encode(text) {+ // PDF word spacing applies only to single-byte code 32, even for a Unicode space.+ return metrics+ .codes(&bytes)+ .iter()+ .map(|(c, len)| metrics.width(*c) * size + char_spacing + if metrics.is_space(*c, *len) { word_spacing } else { 0.0 })+ .sum();+ }+ let words: f64 = text+ .split(' ')+ .filter_map(|w| metrics.encode(w))+ .map(|b| metrics.codes(&b).iter().map(|(c, _)| metrics.width(*c) * size + char_spacing).sum::<f64>())+ .sum();+ words + text.matches(' ').count() as f64 * (space * size + char_spacing + word_spacing)+}++pub(crate) fn source_show(metrics: &Metrics, text: &str, size: f64, space: f64, char_spacing: f64, word_spacing: f64) -> Result<Vec<Op>, EditError> {+ if let Some(bytes) = metrics.encode(text) {+ return Ok(vec![Op::new("Tj", vec![Object::String(PdfString::literal(bytes))])]);+ }+ let adjustment = -1000.0 * (space + (char_spacing + word_spacing) / size);+ if !adjustment.is_finite() {+ return Err(EditError::Invalid("the source font's space advance is invalid".into()));+ }+ let mut out = Vec::new();+ for (i, word) in text.split(' ').enumerate() {+ if i > 0 {+ out.push(Op::new("TJ", vec![Object::Array(vec![pdfcraft_content::num(adjustment)])]));+ }+ if !word.is_empty() {+ let bytes = metrics.encode(word).ok_or_else(|| EditError::Invalid("the source font cannot show the replacement text".into()))?;+ out.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));+ }+ }+ Ok(out)+}diff --git a/crates/edit/src/text/interp.rs b/crates/edit/src/text/interp.rsnew file mode 100644index 000000000..ca0d63cef--- /dev/null+++ b/crates/edit/src/text/interp.rs@@ -0,0 +1,856 @@+use super::fallback::is_type3_fallback;+use super::rewrite::vertical_advance;+use super::*;++/// Text and graphics state captured for rewriting.+#[derive(Clone, Debug, PartialEq)]+pub(super) struct TextState {+ pub(crate) font: Option<(String, f64)>,+ pub(crate) char_spacing: f64,+ pub(crate) word_spacing: f64,+ pub(crate) scale: f64,+ pub(super) leading: f64,+ pub(crate) rise: f64,+ pub(crate) fill: Vec<Op>,+ /// The text rendering mode (`Tr`); 3 is invisible text, as in an OCR layer over a scan.+ pub(crate) render_mode: i64,+ /// The stroke colour operators, the line width and the ExtGStates selected (see [`Ts`]):+ /// graphics state the text was painted with that [`TextState::ops`] doesn't restate.+ pub(super) stroke: Vec<Op>,+ pub(super) line_width: Option<f64>,+ ext_gstate: Vec<Vec<u8>>,+ /// The dash pattern and line cap in force (see [`Ts`]): compared, not restated.+ pub(super) dash: Dash,+ pub(super) line_cap: i64,+}++impl TextState {+ pub(super) fn of(ts: &Ts) -> Self {+ TextState {+ font: ts.font.as_ref().map(|(n, _)| (String::from_utf8_lossy(n).into_owned(), ts.size)),+ char_spacing: ts.char_spacing,+ word_spacing: ts.word_spacing,+ scale: ts.scale,+ leading: ts.leading,+ rise: ts.rise,+ fill: ts.fill.clone(),+ render_mode: ts.render_mode,+ stroke: ts.stroke.clone(),+ line_width: ts.line_width,+ ext_gstate: ts.ext_gstate.clone(),+ dash: ts.dash.clone(),+ line_cap: ts.line_cap,+ }+ }++ /// Operators that change how text is painted from `current` (the state where they run) to+ /// this one: the ExtGStates, stroke colour, line width and a visible rendering mode. A+ /// rewritten paragraph is drawn before its text object, so whatever that object set before+ /// its first show (`/GS1 gs`, `1 Tr 1 0 0 RG 2 w` inside `BT`, #3508/#3509) must be stated+ /// again. Empty when nothing differs.+ ///+ /// Only fill, stroke and fill-then-stroke (`Tr` 0–2) are restated: invisible text is revealed+ /// by [`reveal_ops`] and clipping text is refused, so neither is ever drawn this way.+ ///+ /// A `gs` has no inverse, so a selection `current` has and this state doesn't stays in force:+ /// run these inside a `q`/`Q` that starts from `current`, one per state drawn.+ pub(crate) fn paint_ops(&self, current: &TextState) -> Vec<Op> {+ let n = pdfcraft_content::num;+ let mut v = Vec::new();+ // The selections both share stay in force; the ones after them are selected again in order.+ let shared = self.ext_gstate.iter().zip(¤t.ext_gstate).take_while(|(a, b)| a == b).count();+ for name in self.ext_gstate.iter().skip(shared) {+ v.push(Op::new("gs", vec![Object::Name(name.clone())]));+ }+ // A reselected ExtGState may set `/LW`, so the width (already the effective one) follows it.+ let reselected = !v.is_empty();+ if self.stroke != current.stroke {+ if self.stroke.is_empty() {+ // The initial stroke colour: black in DeviceGray.+ v.push(Op::new("G", vec![n(0.0)]));+ } else {+ v.extend(self.stroke.iter().cloned());+ }+ }+ let width = self.line_width.unwrap_or(1.0);+ if reselected || width != current.line_width.unwrap_or(1.0) {+ v.push(Op::new("w", vec![n(width)]));+ }+ if (0..=2).contains(&self.render_mode) && self.render_mode != current.render_mode {+ v.push(Op::new("Tr", vec![Object::Int(self.render_mode)]));+ }+ v+ }++ /// Operators that set this state (inside a text object).+ pub(crate) fn ops(&self) -> Vec<Op> {+ let n = pdfcraft_content::num;+ let mut v = Vec::new();+ if let Some((f, size)) = &self.font {+ v.push(Op::new("Tf", vec![Object::name(f), n(*size)]));+ }+ v.push(Op::new("Tc", vec![n(self.char_spacing)]));+ v.push(Op::new("Tw", vec![n(self.word_spacing)]));+ v.push(Op::new("Tz", vec![n(self.scale * 100.0)]));+ v.push(Op::new("TL", vec![n(self.leading)]));+ v.push(Op::new("Ts", vec![n(self.rise)]));+ v.extend(self.fill.iter().cloned());+ v+ }+}++/// What a run is drawn in beyond its text state: the optional content groups of the `/OC`+/// marked-content sequences around it, and the effective graphics state parameters (`gs`) in+/// force. A rewrite writes a paragraph in its first run's place, so runs that differ here are+/// never joined: one in a hidden layer or at another opacity would lose it.+#[derive(Clone, Debug, Default, PartialEq)]+pub(super) struct Paint {+ layers: Vec<Vec<u8>>,+ gs: Gs,+}++/// The transparency parameters of the graphics state: what the `gs` operators have set, resolved,+/// so a repeated `gs` or two names with the same settings leave it as it was.+#[derive(Clone, Debug, PartialEq)]+pub(super) struct Gs {+ /// `ca`, the fill opacity.+ fill_alpha: f64,+ /// `CA`, the stroke opacity.+ stroke_alpha: f64,+ /// `BM`, the blend mode (`Compatible` is `Normal`).+ blend: Vec<u8>,+ /// `SMask`, when it is not `None`: the reference of an indirect soft mask, else the dictionary.+ soft_mask: Option<Object>,+}++impl Default for Gs {+ fn default() -> Self {+ Gs { fill_alpha: 1.0, stroke_alpha: 1.0, blend: b"Normal".to_vec(), soft_mask: None }+ }+}++impl Gs {+ /// Applies the parameters a graphics state parameter dictionary sets; the others stay.+ fn apply(&mut self, doc: &Document, params: &Dict) {+ let num = |key: &[u8]| params.get(key).and_then(|o| doc.resolve(o).as_f64()).filter(|v| v.is_finite());+ if let Some(v) = num(b"ca") {+ self.fill_alpha = v;+ }+ if let Some(v) = num(b"CA") {+ self.stroke_alpha = v;+ }+ if let Some(bm) = params.get(b"BM").map(|o| doc.resolve(o)) {+ let first = bm+ .as_name()+ .map(<[u8]>::to_vec)+ .or_else(|| bm.as_array().and_then(|a| a.iter().find_map(|o| doc.resolve(o).as_name().map(<[u8]>::to_vec))));+ if let Some(name) = first {+ self.blend = if name == b"Compatible" { b"Normal".to_vec() } else { name };+ }+ }+ if let Some(mask) = params.get(b"SMask") {+ self.soft_mask = match (mask.as_ref(), &*doc.resolve(mask)) {+ (_, Object::Name(_)) => None,+ (Some(r), _) => Some(Object::Ref(r)),+ (None, Object::Dict(d)) => Some(Object::Dict(d.clone())),+ (None, _) => None,+ };+ }+ }+}++#[derive(Clone, Debug, PartialEq)]+pub(super) struct Origin {+ pub(crate) tm: [f64; 6],+ /// The text line matrix there (where the next line's Td/T* starts from).+ pub(crate) tlm: [f64; 6],+ /// Text-space units → user space (the scale of the text rendering matrix's y axis).+ pub(crate) k: f64,+ /// The CTM there (current space → page space), for moving the paragraph in page space.+ pub(crate) ctm: [f64; 6],+ pub(crate) baseline: f64,+ pub(crate) x: f64,+ pub(crate) state: TextState,+ pub(crate) bt_op: usize,+ pub(crate) bt_state: TextState,+}++/// The unit x axis of a text rendering matrix in user space (`(1, 0)` when it is degenerate).+pub(super) fn direction(m: &Matrix) -> (f64, f64) {+ let (x, y) = (m.0[0], m.0[1]);+ let length = x.hypot(y);+ if length.is_finite() && length > 1e-9 { (x / length, y / length) } else { (1.0, 0.0) }+}++/// User-space point `p` as `(along, across)` a baseline running in unit direction `dir`. Upright+/// text (`dir` = `(1, 0)`) keeps its coordinates, so lines and rows of turned text are found the+/// same way (#1443).+pub(super) fn to_frame(dir: (f64, f64), p: (f64, f64)) -> (f64, f64) {+ (p.0 * dir.0 + p.1 * dir.1, p.1 * dir.0 - p.0 * dir.1)+}++/// The box covering both `[x0, y0, x1, y1]` boxes.+pub(crate) fn union(a: [f64; 4], b: [f64; 4]) -> [f64; 4] {+ [a[0].min(b[0]), a[1].min(b[1]), a[2].max(b[2]), a[3].max(b[3])]+}++#[derive(Clone)]+pub(super) struct Ts {+ pub(super) ctm: Matrix,+ /// The operators that set the current fill colour (`g`, `rg`, `k`, or `cs` + `sc`/`scn`).+ pub(super) fill: Vec<Op>,+ pub(super) font: Option<(Vec<u8>, Rc<Metrics>)>,+ /// The Japanese or Hebrew fallback face the font subsets, when the font is one (see [`is_type3_fallback`]).+ pub(super) face: Option<String>,+ pub(super) size: f64,+ pub(super) char_spacing: f64,+ pub(super) word_spacing: f64,+ pub(super) scale: f64,+ pub(super) leading: f64,+ pub(super) rise: f64,+ pub(super) render_mode: i64,+ /// The transparency parameters the `gs` operators have set so far (see [`Paint`]).+ pub(super) gs: Gs,+ /// The font's vertical advance per unit of font size (`/DW2`'s w1, normally −1) when its+ /// CMap writes vertically (`WMode 1`, §9.7.4.3): each glyph then moves the pen down, not right.+ pub(super) vertical: Option<f64>,+ /// Why the font's writing mode couldn't be read (a broken or cyclic CMap). Its text is then+ /// listed as horizontal, but the lines in it are refused for editing.+ pub(super) unreadable: Option<Rc<str>>,+ /// The operators that set the current stroke colour (`G`, `RG`, `K`, or `CS` + `SC`/`SCN`).+ pub(super) stroke: Vec<Op>,+ /// The line width a `w` or an ExtGState's `/LW` set (`None`: the initial 1.0).+ pub(super) line_width: Option<f64>,+ /// The ExtGState resources selected with `gs`, oldest first (see [`select_gs`]).+ pub(super) ext_gstate: Vec<Vec<u8>>,+ /// The dash pattern a `d` or an ExtGState's `/D` set (initially solid: `[] 0`).+ pub(super) dash: Dash,+ /// The line cap a `J` or an ExtGState's `/LC` set (initially 0, butt).+ pub(super) line_cap: i64,+}++/// A dash pattern (ISO 32000-2 §8.4.3.6): the dash array and the phase.+type Dash = (Vec<f64>, f64);++/// The most dash array entries a pattern keeps; a longer one is ignored, as is a malformed one.+const MAX_DASH: usize = 32;++/// The dash pattern `array phase`, as `d` takes it and an ExtGState's `/D` holds it.+fn dash_pattern(doc: &Document, array: Option<&Object>, phase: Option<&Object>) -> Option<Dash> {+ let array = doc.resolve(array?);+ let items = array.as_array().filter(|a| a.len() <= MAX_DASH)?;+ let finite = |o: &Object| doc.resolve(o).as_f64().filter(|v| v.is_finite());+ Some((items.iter().map(finite).collect::<Option<Vec<_>>>()?, finite(phase?)?))+}++/// A line cap style, as `J` takes it and an ExtGState's `/LC` holds it: 0, 1 or 2.+fn line_cap(doc: &Document, cap: Option<&Object>) -> Option<i64> {+ doc.resolve(cap?).as_int().filter(|c| (0..=2).contains(c))+}++/// The most `gs` selections a state remembers. Repeating a selection moves it to the end, so+/// this bounds the distinct ExtGStates in force, not the operators a hostile stream repeats.+const MAX_GS: usize = 32;++/// Record `gs /name` in `list`. A `gs` sets every parameter its dictionary names to an absolute+/// value, so a later selection of the same dictionary overrides the earlier one completely: the+/// earlier entry goes, which keeps replaying the list equivalent to replaying the stream.+fn select_gs(list: &mut Vec<Vec<u8>>, name: &[u8]) {+ list.retain(|n| n != name);+ if list.len() >= MAX_GS {+ list.remove(0);+ }+ list.push(name.to_vec());+}++/// The text-showing operators of one stream with their text, font, box and baseline.+pub(super) struct Shown {+ pub(super) op: usize,+ pub(super) extra_ops: Vec<usize>,+ /// Encoded glyphs, not bytes or Unicode characters (a ligature can represent several).+ pub(super) glyph_count: usize,+ /// Advance in text space, including spacing and TJ adjustments.+ pub(super) advance: f64,+ pub(super) tracking: f64,+ /// The text matrix where it starts (text space), and the state there and at its `BT`.+ pub(super) tm: Matrix,+ pub(super) tlm: Matrix,+ pub(super) state: Ts,+ pub(super) bt_op: usize,+ pub(super) bt_state: Ts,+ pub(super) text: String,+ pub(super) rect: [f64; 4],+ /// Its box along and across its baseline (see [`TextLine::frame`]).+ pub(super) frame: [f64; 4],+ /// The boxes of its words (see [`TextLine::ink`]).+ pub(super) ink: Vec<[f64; 4]>,+ pub(super) baseline: f64,+ pub(super) start_x: f64,+ end_x: f64,+ end_y: f64,+ pub(super) bt: usize,+ pub(super) font: Vec<u8>,+ pub(super) base_font: String,+ pub(super) face: Option<String>,+ pub(super) size: f64,+ pub(super) bold: bool,+ pub(super) italic: bool,+ pub(super) visual_order: bool,+ pub(super) decodable: bool,+ pub(super) scope: Option<usize>,+ pub(super) paint: Paint,+ pub(super) logical_order: bool,+ pub(super) actual_text: bool,+}++impl Shown {+ /// The unit direction of its baseline, where it starts and ends along it, and the baseline's+ /// offset across it (for upright text: the user-space x, x and y). A vertical run goes along+ /// its column instead, the way the pen moves: for upright text down, with the column's x+ /// across.+ fn span(&self) -> ((f64, f64), f64, f64, f64) {+ let m = self.tm.then(&self.state.ctm);+ let dir = match self.state.vertical {+ Some(w1) => direction(&Matrix([m.0[2] * w1.signum(), m.0[3] * w1.signum(), 0.0, 0.0, 0.0, 0.0])),+ None => direction(&m),+ };+ let (start, across) = to_frame(dir, (self.start_x, self.baseline));+ (dir, start, to_frame(dir, (self.end_x, self.end_y)).0, across)+ }+}++/// Where the previous run of a line ended: its text object, baseline direction, offset across+/// the baseline, end along it and size.+#[derive(Clone, Copy)]+pub(super) struct Pen {+ pub(super) bt: usize,+ dir: (f64, f64),+ across: f64,+ end: f64,+ pub(super) size: f64,+ vertical: bool,+}++impl Pen {+ pub(super) fn after(s: &Shown) -> Self {+ let (dir, _, end, across) = s.span();+ Pen { bt: s.bt, dir, across, end, size: s.size.max(1.0), vertical: s.state.vertical.is_some() }+ }++ /// Whether `s` could continue the same line on geometry alone: on the same baseline, starting+ /// at most a word gap (`reach` sizes) after it. Also the gap along the baseline.+ pub(super) fn continues(&self, s: &Shown, reach: f64) -> (bool, f64) {+ let (dir, start, _, across) = s.span();+ let gap = start - self.end;+ let same_dir = (dir.0 - self.dir.0).abs() < 1e-3 && (dir.1 - self.dir.1).abs() < 1e-3;+ // A column continues a column (along which the pen moves), a baseline a baseline.+ let same_dir = same_dir && self.vertical == s.state.vertical.is_some();+ (same_dir && (across - self.across).abs() < self.size * 0.3 && gap > -self.size && gap < self.size * reach, gap)+ }+}++/// Use the lower third of letter gaps, not word gaps. A pair of isolated labels is not+/// evidence of tracking; unadjusted neighbours inside a string contribute zero too.+/// The tracking a run of glyphs was set with: the lower third of its gaps, when that is at+/// most half an em (`limit`). A wider "tracking" is word or cell spacing between one-glyph+/// words (`a b c`, a column of digits or Y/N ticks), which must keep its spaces.+fn typical_tracking(gaps: &mut [f64], limit: f64) -> f64 {+ if gaps.len() < 3 {+ return 0.0;+ }+ let at = gaps.len() / 3;+ gaps.select_nth_unstable_by(at, f64::total_cmp);+ gaps.get(at).copied().filter(|n| n.is_finite() && *n <= limit).unwrap_or(0.0).max(0.0)+}++fn tj_tracking(pieces: &[Object], metrics: &Metrics, size: f64, scale: f64) -> f64 {+ let mut gaps = Vec::new();+ let mut previous = false;+ let mut gap = 0.0;+ for piece in pieces {+ if let Object::String(s) = piece {+ for (code, len) in metrics.codes(&s.bytes) {+ let blank = metrics.is_space(code, len) || metrics.text_of(code).is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));+ if previous && !blank {+ gaps.push(gap);+ }+ previous = !blank;+ gap = 0.0;+ }+ } else if let Some(n) = piece.as_f64() {+ gap += -n / 1000.0 * size * scale;+ }+ }+ typical_tracking(&mut gaps, size * scale.abs() * 0.5)+}++fn positioned_tracking(shown: &mut [Shown]) {+ let mut start = 0;+ while start < shown.len() {+ let mut end = start.saturating_add(1);+ while let (Some(prev), Some(next)) = (shown.get(end.saturating_sub(1)), shown.get(end)) {+ if prev.glyph_count != 1+ || next.glyph_count != 1+ || prev.font != next.font+ || prev.scope != next.scope+ || (prev.size - next.size).abs() > 0.01+ || prev.state.char_spacing != next.state.char_spacing+ || prev.state.scale != next.state.scale+ || !Pen::after(prev).continues(next, 1.5).0+ {+ break;+ }+ end = end.saturating_add(1);+ }+ if let Some(run) = shown.get_mut(start..end) {+ let mut gaps: Vec<f64> = run+ .windows(2)+ .filter_map(|pair| {+ let [prev, next] = pair else { return None };+ (!prev.text.trim().is_empty() && !next.text.trim().is_empty()).then(|| Pen::after(prev).continues(next, 0.0).1)+ })+ .collect();+ let limit = run.first().map_or(0.0, |s| s.size * s.state.scale.abs() * 0.5);+ let tracking = typical_tracking(&mut gaps, limit);+ for s in run.iter_mut().skip(1) {+ s.tracking = tracking;+ }+ }+ start = end;+ }+}++/// The graphics state carried from one of a page's content streams to the next: the streams+/// are one stream in pieces (§7.8.2), so a `cm` (AutoCAD scales the whole page in the first+/// stream), an unbalanced `q`, the font and the colour still apply in the streams after it.+pub(super) struct Carry {+ pub(super) ts: Ts,+ pub(super) stack: Vec<Ts>,+ pub(super) marked: Vec<Option<usize>>,+ /// For each open marked-content sequence, its optional content group when it is `/OC`.+ pub(super) layers: Vec<Option<Vec<u8>>>,+ /// Bytes of glyph text the rest of the page may still produce (see [`MAX_PAGE_TEXT`]).+ pub(super) text_left: usize,+}++/// The most glyph text one page's extraction produces, in bytes. A ToUnicode destination is+/// copied for every glyph showing its code, so a small page can otherwise expand into gigabytes;+/// real pages hold far less (a whole novel is about 1 MB).+const MAX_PAGE_TEXT: usize = 16 << 20;++impl Carry {+ pub(super) fn new() -> Self {+ let ts = Ts {+ ctm: Matrix::IDENTITY,+ fill: Vec::new(),+ font: None,+ face: None,+ size: 0.0,+ char_spacing: 0.0,+ word_spacing: 0.0,+ scale: 1.0,+ leading: 0.0,+ rise: 0.0,+ render_mode: 0,+ gs: Gs::default(),+ vertical: None,+ unreadable: None,+ stroke: Vec::new(),+ line_width: None,+ ext_gstate: Vec::new(),+ dash: (Vec::new(), 0.0),+ line_cap: 0,+ };+ Carry { ts, stack: Vec::new(), marked: Vec::new(), layers: Vec::new(), text_left: MAX_PAGE_TEXT }+ }+}++/// A font resource's metrics, fallback face and vertical advance (see [`Ts`]), read once per page.+/// The advance is an error message when the font's writing mode can't be read.+type CachedFont = (Rc<Metrics>, Option<String>, Result<Option<f64>, String>);++/// A `Do` met while interpreting: its operator index, XObject name and the state there.+type Invocation = (usize, Vec<u8>, Ts);++pub(super) fn interpret(+ doc: &Document,+ ops: &[Op],+ resources: &Dict,+ cache: &mut HashMap<Vec<u8>, CachedFont>,+ carry: &mut Carry,+ mut invoked: Option<&mut Vec<Invocation>>,+ // `Some(properties)`: read `/ActualText`, looking named property lists up in `properties`.+ logical_text: Option<&Dict>,+) -> Result<Vec<Shown>, EditError> {+ let fonts_res = resources.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();+ let states = resources.get(b"ExtGState").map(|g| doc.resolve(g)).and_then(|g| g.as_dict().cloned()).unwrap_or_default();+ let mut out: Vec<Shown> = Vec::new();+ let mut ts = carry.ts.clone();+ let mut at_bt = (0usize, ts.clone());+ let mut stack: Vec<Ts> = std::mem::take(&mut carry.stack);+ let (mut tm, mut tlm) = (Matrix::IDENTITY, Matrix::IDENTITY);+ let mut bt = 0usize;+ let mut marked = std::mem::take(&mut carry.marked);+ let mut layers = std::mem::take(&mut carry.layers);+ let mut actual: Vec<Option<(usize, usize, String)>> = Vec::new();+ for (i, op) in ops.iter().enumerate() {+ match op.op.as_slice() {+ // No depth cap: every `EMC` pops, so a capped push would pair it with the enclosing+ // sequence (#3573). Both stacks stay bounded by the number of operators.+ b"BMC" | b"BDC" => {+ // Marked text paragraphs/headings are authoritative boundaries. Ignore+ // artifacts and inner spans, which inherit their enclosing region.+ let region = matches!(op.name(0), Some(b"P" | b"H" | b"H1" | b"H2" | b"H3" | b"H4" | b"H5" | b"H6" | b"LI" | b"TD" | b"TH"));+ marked.push(if region { Some(i) } else { marked.last().copied().flatten() });+ // A layer named in the resources is told apart by its name, an inline one by where it opens.+ let layer = op.is("BDC") && op.name(0) == Some(b"OC".as_slice());+ layers.push(layer.then(|| op.operands.get(1).and_then(Object::as_name).map_or_else(|| format!("@{i}").into_bytes(), <[u8]>::to_vec)));+ // The property list is inline or named in the resources' /Properties (§14.6.2).+ let list = logical_text.and_then(|properties| match op.operands.get(1) {+ Some(Object::Name(n)) => properties.get(n).and_then(|o| doc.dict(o)),+ other => other.and_then(Object::as_dict).cloned(),+ });+ let logical = list.as_ref().and_then(|d| d.get(b"ActualText")).and_then(|s| match s {+ Object::String(s) if s.bytes.len() <= 4_000_000 => Some(s.to_text()),+ _ => None,+ });+ actual.push(logical.map(|s| (out.len(), i, s)));+ }+ b"EMC" => {+ marked.pop();+ layers.pop();+ if let Some(Some((start, open, logical))) = actual.pop() {+ let tail = out.split_off(start.min(out.len()));+ let mut items = tail.into_iter();+ if let Some(mut first) = items.next() {+ for shown in items {+ first.glyph_count = first.glyph_count.saturating_add(shown.glyph_count);+ first.extra_ops.push(shown.op);+ first.extra_ops.extend(shown.extra_ops);+ first.rect = [+ first.rect[0].min(shown.rect[0]),+ first.rect[1].min(shown.rect[1]),+ first.rect[2].max(shown.rect[2]),+ first.rect[3].max(shown.rect[3]),+ ];+ first.frame = union(first.frame, shown.frame);+ first.ink.extend(shown.ink);+ }+ first.extra_ops.extend([open, i]);+ // Only right-to-left ActualText is already in typing order and must stay+ // out of the line's bidi recovery. Word and Chrome wrap Latin ligatures+ // (`fi`, `fl`) in ActualText spans mid-word; those keep joining their line.+ first.logical_order = logical.chars().any(crate::bidi::is_rtl);+ first.actual_text = true;+ first.text = logical;+ first.start_x = first.rect[0];+ first.end_x = first.rect[2];+ first.end_y = first.baseline;+ first.advance = (first.end_x - first.start_x) / first.tm.then(&first.state.ctm).0[0].abs().max(1e-6);+ out.push(first);+ }+ }+ }+ b"q" => stack.push(ts.clone()),+ b"Q" => {+ if let Some(s) = stack.pop() {+ ts = s;+ }+ }+ b"cm" => {+ if let Some(m) = op.nums::<6>() {+ ts.ctm = Matrix(m).then(&ts.ctm);+ }+ }+ b"BT" => {+ tm = Matrix::IDENTITY;+ tlm = Matrix::IDENTITY;+ bt += 1;+ at_bt = (i, ts.clone());+ }+ b"g" | b"rg" | b"k" | b"cs" => ts.fill = vec![op.clone()],+ b"sc" | b"scn" => {+ ts.fill.retain(|o| o.is("cs"));+ ts.fill.push(op.clone());+ }+ b"G" | b"RG" | b"K" | b"CS" => ts.stroke = vec![op.clone()],+ b"SC" | b"SCN" => {+ ts.stroke.retain(|o| o.is("CS"));+ ts.stroke.push(op.clone());+ }+ b"w" => ts.line_width = op.num(0).filter(|w| w.is_finite()).or(ts.line_width),+ b"d" => ts.dash = dash_pattern(doc, op.operands.first(), op.operands.get(1)).unwrap_or_else(|| ts.dash.clone()),+ b"J" => ts.line_cap = line_cap(doc, op.operands.first()).unwrap_or(ts.line_cap),+ b"Tf" => {+ ts.size = op.num(1).unwrap_or(ts.size);+ if let Some(name) = op.name(0) {+ let (m, face, vertical) = cache.entry(name.to_vec()).or_insert_with(|| {+ let dict = fonts_res.get(name).and_then(|f| doc.resolve(f).as_dict().cloned());+ let metrics = dict.as_ref().map_or_else(Metrics::fallback, |d| Metrics::from_dict(doc, d));+ let vertical = dict.as_ref().map_or(Ok(None), |d| vertical_advance(doc, d).map_err(|e| e.to_string()));+ let face = dict.filter(is_type3_fallback).map(|_| metrics.base_font.clone());+ (Rc::new(metrics), face, vertical)+ });+ ts.font = Some((name.to_vec(), m.clone()));+ ts.face = face.clone();+ // Which way the glyphs advance is unknown (§9.7.4.3): list the font's text as+ // horizontal and record why, so editing its lines is refused (not the page).+ match vertical {+ Ok(v) => (ts.vertical, ts.unreadable) = (*v, None),+ Err(e) => (ts.vertical, ts.unreadable) = (None, Some(Rc::from(e.as_str()))),+ }+ }+ }+ b"Tc" => ts.char_spacing = op.num(0).unwrap_or(0.0),+ b"Tw" => ts.word_spacing = op.num(0).unwrap_or(0.0),+ b"Tz" => ts.scale = op.num(0).unwrap_or(100.0) / 100.0,+ b"TL" => ts.leading = op.num(0).unwrap_or(0.0),+ b"Ts" => ts.rise = op.num(0).unwrap_or(0.0),+ b"Tr" => ts.render_mode = op.operands.first().and_then(Object::as_int).unwrap_or(-1),+ b"gs" => {+ if let Some(name) = op.name(0) {+ select_gs(&mut ts.ext_gstate, name);+ }+ let params = op.name(0).and_then(|name| states.get(name)).map(|p| doc.resolve(p));+ if let Some(params) = params.as_deref().and_then(Object::as_dict) {+ ts.gs.apply(doc, params);+ // `/LW` sets the line width as `w` does (ISO 32000-2 §8.4.5).+ let lw = params.get(b"LW").and_then(|w| doc.resolve(w).as_f64()).filter(|w| w.is_finite());+ ts.line_width = lw.or(ts.line_width);+ let dash = params.get(b"D").map(|d| doc.resolve(d));+ let dash = dash.as_deref().and_then(Object::as_array);+ if let Some(d) = dash.and_then(|d| dash_pattern(doc, d.first(), d.get(1))) {+ ts.dash = d;+ }+ ts.line_cap = line_cap(doc, params.get(b"LC")).unwrap_or(ts.line_cap);+ }+ }+ b"Do" => {+ if let (Some(list), Some(name)) = (invoked.as_deref_mut(), op.name(0)) {+ list.push((i, name.to_vec(), ts.clone()));+ }+ }+ b"Td" | b"TD" => {+ if let Some([x, y]) = op.nums::<2>() {+ if op.is("TD") {+ ts.leading = -y;+ }+ tlm = Matrix([1.0, 0.0, 0.0, 1.0, x, y]).then(&tlm);+ tm = tlm;+ }+ }+ b"Tm" => {+ if let Some(m) = op.nums::<6>() {+ tlm = Matrix(m);+ tm = tlm;+ }+ }+ b"T*" => {+ tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(&tlm);+ tm = tlm;+ }+ b"Tj" | b"TJ" | b"'" | b"\"" => {+ if matches!(op.op.as_slice(), b"'" | b"\"") {+ if op.is("\"") {+ ts.word_spacing = op.num(0).unwrap_or(ts.word_spacing);+ ts.char_spacing = op.num(1).unwrap_or(ts.char_spacing);+ }+ tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(&tlm);+ tm = tlm;+ }+ let Some((name, m)) = ts.font.clone() else { continue };+ // Pieces: strings, and TJ number adjustments.+ let pieces: Vec<Object> = match op.op.as_slice() {+ // A surplus array (`[(A)] [(B)] TJ`) is malformed, but the operator still+ // takes the one immediately before it, as the renderer and every other+ // reader here do (#3569) -- not the first, which a reader counting operands+ // from the front of a surplus list would otherwise take.+ b"TJ" => op.operands.last().and_then(Object::as_array).cloned().unwrap_or_default(),+ _ => op.operands.last().cloned().into_iter().collect(),+ };+ // Tc is already included in the pen advance; TJ may encode tracking instead.+ let tracking = if op.is("TJ") { tj_tracking(&pieces, &m, ts.size, ts.scale) } else { 0.0 };+ let trm0 = tm.then(&ts.ctm);+ let start = trm0.apply(0.0, ts.rise);+ let mut text = String::new();+ let mut decodable = true;+ let mut x_text = 0.0;+ // Vertical text (§9.4.4): the pen moves along y instead, and each glyph is centred+ // on it horizontally; `half` is half the widest glyph.+ let vertical = ts.vertical;+ let (mut y_text, mut half) = (0.0, 0.0_f64);+ // Where each word's glyphs start and end along the run (text space), and whether+ // the next glyph continues the last word.+ let mut words: Vec<(f64, f64)> = Vec::new();+ let mut in_word = false;+ let mut glyph_count = 0_usize;+ for p in &pieces {+ match p {+ Object::String(s) => {+ for (code, len) in m.codes(&s.bytes) {+ glyph_count = glyph_count.saturating_add(1);+ let shown = m.text_of(code);+ let blank =+ m.is_space(code, len) || shown.as_deref().is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));+ match shown {+ Some(t) => {+ carry.text_left = carry+ .text_left+ .checked_sub(t.len())+ .ok_or_else(|| EditError::Invalid("the page's text is too large to read".into()))?;+ text.push_str(&t);+ }+ None => decodable = false,+ }+ let spacing = ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };+ if let Some(w1) = vertical {+ half = half.max((m.width(code) * ts.size * ts.scale).abs() / 2.0);+ if !blank {+ let ink_end = y_text + w1 * ts.size;+ let (lo, hi) = (y_text.min(ink_end), y_text.max(ink_end));+ match words.last_mut() {+ Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),+ _ => words.push((lo, hi)),+ }+ }+ in_word = !blank;+ y_text += w1 * ts.size + spacing;+ continue;+ }+ if !blank {+ let ink_end = x_text + m.width(code) * ts.size * ts.scale;+ // A negative font size or `Tz` runs the glyphs backwards:+ // the word is the union of its glyphs, whichever way they go.+ let (lo, hi) = (x_text.min(ink_end), x_text.max(ink_end));+ match words.last_mut() {+ Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),+ _ => words.push((lo, hi)),+ }+ }+ in_word = !blank;+ let w = m.width(code) * ts.size + ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };+ x_text += w * ts.scale;+ }+ }+ other => {+ if let Some(n) = other.as_f64() {+ if vertical.is_some() {+ // Down by n/1000 em, not scaled by `Tz`.+ let dy = -n / 1000.0 * ts.size;+ if -dy > ts.size * 0.2 && !text.ends_with(' ') {+ text.push(' ');+ }+ if dy.abs() > ts.size.abs() * 0.2 {+ in_word = false;+ }+ y_text += dy;+ continue;+ }+ let dx = -n / 1000.0 * ts.size * ts.scale;+ // A large gap inside TJ reads as a space.+ if dx - tracking > (ts.size * ts.scale).abs() * 0.2 && !text.ends_with(' ') {+ text.push(' ');+ }+ // Tracking and kerning keep a word together; a larger jump+ // ends it (whatever the sign of the size or `Tz`).+ if dx - tracking > (ts.size * ts.scale).abs() * 0.2 || dx < -(ts.size * ts.scale).abs() * 0.2 {+ in_word = false;+ }+ x_text += dx;+ }+ }+ }+ }+ tm = Matrix([1.0, 0.0, 0.0, 1.0, x_text, y_text]).then(&tm);+ let end = tm.then(&ts.ctm).apply(0.0, ts.rise);+ // The box from `a` to `b` along the run: from descent to ascent across it, or for+ // vertical text, the widest glyph's width centred on the pen.+ let span = |a: f64, b: f64| match vertical {+ Some(_) => {+ [trm0.apply(-half, ts.rise + a), trm0.apply(half, ts.rise + a), trm0.apply(-half, ts.rise + b), trm0.apply(half, ts.rise + b)]+ }+ None => [+ trm0.apply(a, ts.rise + m.descent * ts.size),+ trm0.apply(b, ts.rise + m.descent * ts.size),+ trm0.apply(a, ts.rise + m.ascent * ts.size),+ trm0.apply(b, ts.rise + m.ascent * ts.size),+ ],+ };+ let corners = span(0.0, if vertical.is_some() { y_text } else { x_text });+ let rect = corners+ .iter()+ .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);+ // The same corners along and across the baseline: the run's own box, not its+ // upright bounding box turned (which is wider by the box's height on a slant).+ let dir = direction(&trm0);+ let frame = corners+ .iter()+ .map(|&p| to_frame(dir, p))+ .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);+ let ink = words+ .iter()+ .map(|&(a, b)| {+ span(a, b)+ .iter()+ .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |r, p| [r[0].min(p.0), r[1].min(p.1), r[2].max(p.0), r[3].max(p.1)])+ })+ .collect();+ let size_user = (trm0.0[2].powi(2) + trm0.0[3].powi(2)).sqrt() * ts.size;+ // A numeric-only TJ adjusts the current text matrix but paints no glyphs.+ // It must not create a phantom editable line or enlarge its neighbours' boxes.+ if !pieces.iter().any(|p| matches!(p, Object::String(s) if !s.bytes.is_empty())) {+ continue;+ }+ out.push(Shown {+ op: i,+ extra_ops: Vec::new(),+ glyph_count,+ // Vertical text: the TJ adjustment that undoes the run is n = -1000 y / size; the+ // preview divides by size × `Tz`, so `Tz` is put back here.+ advance: if vertical.is_some() { y_text * ts.scale } else { x_text },+ tracking: 0.0,+ tm: Matrix([+ tm.0[0],+ tm.0[1],+ tm.0[2],+ tm.0[3],+ tm.0[4] - x_text * tm.0[0] - y_text * tm.0[2],+ tm.0[5] - x_text * tm.0[1] - y_text * tm.0[3],+ ]),+ state: ts.clone(),+ tlm,+ bt_op: at_bt.0,+ bt_state: at_bt.1.clone(),+ text,+ rect,+ frame,+ ink,+ baseline: start.1,+ start_x: start.0,+ end_x: end.0,+ end_y: end.1,+ bt,+ font: name,+ base_font: m.base_font.clone(),+ face: ts.face.clone(),+ size: if size_user > 0.0 { size_user } else { ts.size },+ bold: m.bold,+ italic: m.italic,+ visual_order: m.visual_order,+ decodable,+ scope: marked.last().copied().flatten(),+ paint: Paint { layers: layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },+ logical_order: false,+ actual_text: false,+ });+ }+ _ => {}+ }+ }+ carry.ts = ts;+ carry.stack = stack;+ carry.marked = marked;+ carry.layers = layers;+ positioned_tracking(&mut out);+ Ok(out)+}diff --git a/crates/edit/src/text/lines.rs b/crates/edit/src/text/lines.rsnew file mode 100644index 000000000..7543adeb3--- /dev/null+++ b/crates/edit/src/text/lines.rs@@ -0,0 +1,585 @@+use super::fallback::{same_font, same_paint};+use super::interp::{Carry, Origin, Pen, Shown, TextState, Ts, direction, interpret, to_frame, union};+use super::*;++impl TextLine {+ /// The baseline's height in user space.+ pub fn origin_baseline(&self) -> f64 {+ self.origin.baseline+ }++ /// Paint position of the line's first operator: `(content-stream index, operator index in+ /// the page's joined stream)`. A line joins runs painted at different times, so anything+ /// painted after this position may lie on top of part of it.+ /// (Lines from `text_lines` never come from form XObjects, so `stream` is always a+ /// page content-stream index and `ops` are indices into the joined operator list.)+ pub fn first_paint_pos(&self) -> (usize, usize) {+ (self.stream, self.ops.iter().min().copied().unwrap_or(0))+ }++ /// The runs of text the line joins, in content order: each run's text as its glyphs show it,+ /// the boxes of its words (a part of `ink`), and whether joining put a space between it and+ /// the run before (`text` has one there; runs closer together join with none, so one word+ /// can span runs). None when the line's text was reordered for reading (right-to-left or+ /// visual-order Indic text): then only the line's text as a whole says what it reads.+ pub fn runs(&self) -> impl Iterator<Item = (&str, &[[f64; 4]], bool)> {+ let mut start = 0;+ self.runs.iter().map(move |(text, end, spaced)| {+ let ink = self.ink.get(start..*end).unwrap_or_default();+ start = *end;+ (text.as_str(), ink, *spaced)+ })+ }++ pub(crate) fn rotation(&self) -> f64 {+ let m = Matrix(self.origin.tm).then(&Matrix(self.origin.ctm)).0;+ m[1].atan2(m[0]).to_degrees()+ }++ /// The unit direction its baseline runs in, in user space.+ pub(super) fn direction(&self) -> (f64, f64) {+ direction(&Matrix(self.origin.tm).then(&Matrix(self.origin.ctm)))+ }++ /// Whether it reads left to right along the page's x axis (most text; a page drawn+ /// turned a quarter, as landscape pages often are, isn't).+ pub(crate) fn upright(&self) -> bool {+ let (x, y) = self.direction();+ (x - 1.0).abs() < 1e-3 && y.abs() < 1e-3+ }++ /// Where it starts as `(along, across)` its baseline: user space turned to the text's direction.+ pub(crate) fn frame_origin(&self) -> (f64, f64) {+ to_frame(self.direction(), (self.origin.x, self.origin.baseline))+ }++ /// Its box in the same frame, `[along0, across0, along1, across1]` (for upright text, `rect`).+ pub(crate) fn frame_rect(&self) -> [f64; 4] {+ self.frame+ }+}++/// The page's content streams as listed, each with its decoded data (empty when it doesn't+/// decode), within one page's [`DecodeBudget`]. An error when the content runs past it: reading+/// or rewriting a page from part of its content would lose the rest.+pub(crate) fn content_streams(doc: &Document, page: &Dict) -> Result<Vec<(Object, Vec<u8>)>, EditError> {+ content_streams_within(doc, page, &mut DecodeBudget::page())+}++/// [`content_streams`], decoded against `budget`, which a walk of the page's forms then goes on+/// spending.+pub(crate) fn content_streams_within(doc: &Document, page: &Dict, budget: &mut DecodeBudget) -> Result<Vec<(Object, Vec<u8>)>, EditError> {+ let list: Vec<Object> = match page.get(b"Contents") {+ None => Vec::new(),+ Some(c) => match &*doc.resolve(c) {+ Object::Array(a) => a.clone(),+ _ => vec![c.clone()],+ },+ };+ let mut out = Vec::with_capacity(list.len());+ for o in list {+ let data = match &*doc.resolve(&o) {+ Object::Stream(s) => match budget.decode(s) {+ Ok(data) => data,+ Err(e) if budget.remaining() == 0 => return Err(EditError::Invalid(format!("the page content is too large to read: {e}"))),+ Err(_) => Vec::new(),+ },+ _ => Vec::new(),+ };+ out.push((o, data));+ }+ Ok(out)+}++/// Rewrite a page's content (its streams joined, see [`Pieces`]): `edit(i)` gives the operators+/// to insert before operator `i` of `ops` (parsed from the joined pieces) and whether to keep it.+/// Everything else is copied byte for byte. A page's streams are one stream in pieces, split+/// between any two tokens (ISO 32000-2 §7.8.2), so an operator's operands can end one piece and+/// its keyword start the next; removing or replacing it rewrites every piece it spans. Returns+/// each piece's new bytes.+pub(crate) fn splice(pieces: &Pieces, ops: &[Op], mut edit: impl FnMut(usize) -> (Vec<Op>, bool)) -> Vec<Vec<u8>> {+ let data = pieces.data();+ let mut edits = Vec::new();+ for (i, op) in ops.iter().enumerate() {+ let (insert, keep) = edit(i);+ if insert.is_empty() && keep {+ continue;+ }+ let mut bytes = Vec::new();+ if !insert.is_empty() {+ if op.span.start.checked_sub(1).and_then(|p| data.get(p)).is_some_and(|b| !b.is_ascii_whitespace()) {+ bytes.push(b'\n');+ }+ bytes.extend_from_slice(&serialize_ops(&insert));+ }+ let end = if keep { op.span.start } else { op.span.end };+ edits.push((op.span.start..end, bytes));+ }+ pieces.splice(edits)+}++/// The page's `/Contents` after a [`splice`]: pieces whose bytes changed become new streams+/// (keeping their dictionaries), the others stay as they were.+pub(crate) fn rewritten_contents(doc: &mut Document, streams: &[(Object, Vec<u8>)], new: Vec<Vec<u8>>) -> Object {+ let mut contents: Vec<Object> = Vec::with_capacity(streams.len());+ for ((obj, old), data) in streams.iter().zip(new) {+ if *old == data {+ contents.push(obj.clone());+ continue;+ }+ let mut dict = match &*doc.resolve(obj) {+ Object::Stream(s) => s.dict.clone(),+ _ => Dict::new(),+ };+ dict.remove(b"Length");+ contents.push(Object::Ref(doc.add(Object::Stream(Stream::flate(dict, &data)))));+ }+ match <[Object; 1]>::try_from(contents) {+ Ok([one]) => one,+ Err(many) => Object::Array(many),+ }+}++pub(crate) fn page_dict(doc: &Document, page: usize) -> Result<pdfcraft_model::Page, EditError> {+ pdfcraft_model::pages(doc).into_iter().nth(page).ok_or(EditError::NoSuchPage(page))+}++fn fill_color(fill: &[Op]) -> [f64; 3] {+ let Some(op) = fill.iter().rev().find(|op| matches!(op.op.as_slice(), b"g" | b"rg" | b"k" | b"sc" | b"scn")) else {+ return [0.0, 0.0, 0.0];+ };+ let space = match op.op.as_slice() {+ b"sc" | b"scn" => match op.operands.len() {+ 1 => b"g".as_slice(),+ 3 => b"rg".as_slice(),+ 4 => b"k".as_slice(),+ _ => return [0.0; 3],+ },+ other => other,+ };+ match space {+ b"g" => {+ let v = op.operands.first().and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0);+ [v, v, v]+ }+ b"rg" => [+ op.operands.first().and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),+ op.operands.get(1).and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),+ op.operands.get(2).and_then(Object::as_f64).unwrap_or(0.0).clamp(0.0, 1.0),+ ],+ b"k" => {+ let c = op.operands.first().and_then(Object::as_f64).unwrap_or(0.0);+ let m = op.operands.get(1).and_then(Object::as_f64).unwrap_or(0.0);+ let y = op.operands.get(2).and_then(Object::as_f64).unwrap_or(0.0);+ let k = op.operands.get(3).and_then(Object::as_f64).unwrap_or(0.0);+ [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)]+ }+ _ => [0.0, 0.0, 0.0],+ }+}++/// The lines of text on a page (0-based), in content order.+pub fn text_lines(doc: &Document, page: usize) -> Result<Vec<TextLine>, EditError> {+ text_lines_in(doc, &page_dict(doc, page)?, true)+}++/// The lines `page`'s glyphs show, in content order, without `/ActualText` replacements: what the+/// page draws, not what its marked-content metadata says the glyphs mean. For checks that must+/// not trust that metadata (the redaction audit). Takes the page itself, so a caller going+/// through every page doesn't walk the page tree again for each.+pub fn glyph_text_lines(doc: &Document, page: &pdfcraft_model::Page) -> Result<Vec<TextLine>, EditError> {+ text_lines_in(doc, page, false)+}++/// [`text_lines`] of `p`; with `actual_text`, `/ActualText` replaces the glyphs it spans.+fn text_lines_in(doc: &Document, p: &pdfcraft_model::Page, actual_text: bool) -> Result<Vec<TextLine>, EditError> {+ let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let mut cache = HashMap::new();+ let mut lines: Vec<TextLine> = Vec::new();+ let mut carry = Carry::new();+ // The streams are one stream in pieces (§7.8.2), split between any two tokens: parse them+ // joined, so an operator whose operands end one piece still has them.+ let pieces = Pieces::join(&content_streams(doc, &p.dict)?.into_iter().map(|(_, d)| d).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ let properties = res.get(b"Properties").and_then(|o| doc.dict(o)).unwrap_or_default();+ let shown = interpret(doc, &ops, &res, &mut cache, &mut carry, None, actual_text.then_some(&properties))?;+ let mut last: Option<(usize, Pen)> = None; // the stream piece and where its last run ended+ for mut s in shown {+ // A single RTL glyph's ActualText (e.g. lam-alef) is an inline ligature, not a+ // separate logical line. Put its letters into visual order before joining the+ // surrounding glyphs; the completed line is recovered to typing order below.+ // Multi-glyph and mixed-direction replacements keep their authoritative order.+ if s.logical_order && s.glyph_count == 1 && s.text.chars().all(crate::bidi::is_rtl) {+ s.text = crate::bidi::to_visual(&s.text);+ s.logical_order = false;+ }+ // A line belongs to one stream piece. Within it, PDF producers often put every word+ // in its own BT/ET: geometry and text state, not object boundaries, define a line.+ let si = ops.get(s.op).map_or(0, |op| pieces.pieces_of(op).0);+ let joins = last.is_some_and(|(piece, pen)| {+ let bt = pen.bt;+ let (near, gap) = pen.continues(&s, if bt == s.bt { 3.0 } else { 1.5 });+ piece == si+ && lines.last().is_some_and(|l| l.scope == s.scope && l.paint == s.paint && l.logical_order == s.logical_order)+ && (bt == s.bt || lines.last().is_some_and(|l| compatible_word(l, &s)))+ && (s.text.trim().is_empty() || lines.last().is_some_and(|l| same_font(l, &s.font, &s.base_font, s.face.as_deref())))+ && (s.text.trim().is_empty()+ || lines.last().is_some_and(|l| {+ (s.size - l.size).abs() < 0.01+ && s.bold == l.bold+ && s.italic == l.italic+ && fill_color(&s.state.fill) == l.color+ && same_paint(l, &s.state)+ }))+ && near+ // An OCR layer is one text object over the whole scan: its words continue a line+ // only across a word space, not across a table cell or a tab stop.+ && (s.state.render_mode != 3 || gap < pen.size * 0.6)+ });+ if joins && let Some(l) = lines.last_mut() {+ let gap = last.map_or(0.0, |(_, pen)| pen.continues(&s, 0.0).1);+ let spaced = gap - s.tracking > l.size * s.state.scale.abs() * 0.2 && !l.text.ends_with(' ') && !s.text.starts_with(' ');+ if spaced {+ l.text.push(' ');+ }+ l.text.push_str(&s.text);+ l.rect = [l.rect[0].min(s.rect[0]), l.rect[1].min(s.rect[1]), l.rect[2].max(s.rect[2]), l.rect[3].max(s.rect[3])];+ l.frame = union(l.frame, s.frame);+ l.ink.extend(s.ink.iter().copied());+ l.runs.push((s.text.clone(), l.ink.len(), spaced));+ l.ops.push(s.op);+ l.ops.extend(s.extra_ops.iter().copied());+ l.decodable &= s.decodable;+ l.visual_order |= s.visual_order;+ l.actual_text |= s.actual_text;+ l.clips |= s.state.render_mode >= 4;+ if l.unreadable_mode.is_none() {+ l.unreadable_mode = s.state.unreadable.as_deref().map(str::to_owned);+ }+ // Spaces may use a separate subset font; they do not change the visible style.+ } else {+ lines.push(TextLine {+ text: s.text.clone(),+ rect: s.rect,+ frame: s.frame,+ ink: s.ink.clone(),+ font: String::from_utf8_lossy(&s.font).into_owned(),+ base_font: s.base_font.clone(),+ size: s.size,+ bold: s.bold,+ italic: s.italic,+ color: fill_color(&s.state.fill),+ decodable: s.decodable,+ visual_order: s.visual_order,+ face: s.face.clone(),+ stream: si,+ scope: s.scope,+ paint: s.paint.clone(),+ logical_order: s.logical_order,+ actual_text: s.actual_text,+ clips: s.state.render_mode >= 4,+ unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),+ runs: vec![(s.text.clone(), s.ink.len(), false)],+ ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),+ origin: Origin {+ tm: s.tm.0,+ tlm: s.tlm.0,+ k: (s.tm.then(&s.state.ctm).0[2].powi(2) + s.tm.then(&s.state.ctm).0[3].powi(2)).sqrt(),+ ctm: s.state.ctm.0,+ baseline: s.baseline,+ x: s.start_x,+ state: TextState::of(&s.state),+ bt_op: s.bt_op,+ bt_state: TextState::of(&s.bt_state),+ },+ });+ }+ last = Some((si, Pen::after(&s)));+ }+ // Content streams draw right-to-left lines in visual order; the editor works in typing order.+ for l in lines.iter_mut().filter(|l| !l.logical_order) {+ // A visual-order Indic font draws pre-base vowel signs before their consonant.+ let shown = l.text.clone();+ if l.visual_order && !l.actual_text {+ l.text = crate::indic::to_logical(&l.text);+ }+ l.text = crate::bidi::to_logical(&l.text);+ // The runs hold the text in drawing order, which no longer reads as the line does.+ if l.text != shown {+ l.runs.clear();+ }+ }+ // Lines of only spaces aren't editable text.+ lines.retain(|l| !l.text.trim().is_empty());+ Ok(lines)+}++/// Joining independent text objects is safe only when they use the same text and graphics+/// transforms and spacing. In particular, a nearby rotated label isn't part of this line.+fn compatible_word(line: &TextLine, shown: &Shown) -> bool {+ let within = |a: &[f64], b: &[f64], tolerance: f64| a.iter().zip(b).all(|(a, b)| (a - b).abs() < tolerance);+ let same = |a: &[f64], b: &[f64]| within(a, b, 1e-6);+ let (a, b) = (&line.origin.state, TextState::of(&shown.state));+ // Spacing that differs by less than a thousandth of an em, the unit glyph widths are given in,+ // can't be seen. Some producers still write it (`0.0001 Tc` on one word of a line).+ let em = shown.state.size.abs() / 1000.0;+ line.scope == shown.scope+ && line.paint == shown.paint+ && same(&line.origin.tm[..4], &shown.tm.0[..4])+ && same(&line.origin.ctm, &shown.state.ctm.0)+ && within(&[a.char_spacing, a.word_spacing], &[b.char_spacing, b.word_spacing], em.max(1e-6))+ && same(&[a.scale, a.rise], &[b.scale, b.rise])+ && a.fill.len() == b.fill.len()+ && a.fill.iter().zip(&b.fill).all(|(a, b)| a.op == b.op && a.operands == b.operands)+}++/// The line `s` continues, or a new one: `last` is the previous run of the same stream+/// (`bt`, baseline, end x, size).+fn add_shown(lines: &mut Vec<TextLine>, last: &mut Option<Pen>, s: Shown, stream: usize) {+ let joins = last.is_some_and(|pen| {+ let bt = pen.bt;+ lines.last().is_some_and(|l| l.scope == s.scope && l.paint == s.paint && l.logical_order == s.logical_order)+ && (bt == s.bt || lines.last().is_some_and(|l| compatible_word(l, &s)))+ && (s.text.trim().is_empty() || lines.last().is_some_and(|l| same_font(l, &s.font, &s.base_font, s.face.as_deref())))+ && (s.text.trim().is_empty()+ || lines.last().is_some_and(|l| {+ (s.size - l.size).abs() < 0.01+ && s.bold == l.bold+ && s.italic == l.italic+ && fill_color(&s.state.fill) == l.color+ && same_paint(l, &s.state)+ }))+ && pen.continues(&s, if bt == s.bt { 3.0 } else { 1.5 }).0+ });+ if joins && let Some(l) = lines.last_mut() {+ let gap = last.map_or(0.0, |pen| pen.continues(&s, 0.0).1);+ let spaced = gap - s.tracking > l.size * s.state.scale.abs() * 0.2 && !l.text.ends_with(' ') && !s.text.starts_with(' ');+ if spaced {+ l.text.push(' ');+ }+ l.text.push_str(&s.text);+ l.rect = [l.rect[0].min(s.rect[0]), l.rect[1].min(s.rect[1]), l.rect[2].max(s.rect[2]), l.rect[3].max(s.rect[3])];+ l.frame = union(l.frame, s.frame);+ l.ink.extend(s.ink.iter().copied());+ l.runs.push((s.text.clone(), l.ink.len(), spaced));+ l.ops.push(s.op);+ l.ops.extend(s.extra_ops.iter().copied());+ l.decodable &= s.decodable;+ l.visual_order |= s.visual_order;+ l.actual_text |= s.actual_text;+ l.clips |= s.state.render_mode >= 4;+ if l.unreadable_mode.is_none() {+ l.unreadable_mode = s.state.unreadable.as_deref().map(str::to_owned);+ }+ } else {+ lines.push(TextLine {+ text: s.text.clone(),+ rect: s.rect,+ frame: s.frame,+ ink: s.ink.clone(),+ font: String::from_utf8_lossy(&s.font).into_owned(),+ base_font: s.base_font.clone(),+ size: s.size,+ bold: s.bold,+ italic: s.italic,+ color: fill_color(&s.state.fill),+ decodable: s.decodable,+ visual_order: s.visual_order,+ face: s.face.clone(),+ stream,+ scope: s.scope,+ paint: s.paint.clone(),+ logical_order: s.logical_order,+ actual_text: s.actual_text,+ clips: s.state.render_mode >= 4,+ unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),+ runs: vec![(s.text.clone(), s.ink.len(), false)],+ ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),+ origin: Origin {+ tm: s.tm.0,+ tlm: s.tlm.0,+ k: (s.tm.then(&s.state.ctm).0[2].powi(2) + s.tm.then(&s.state.ctm).0[3].powi(2)).sqrt(),+ ctm: s.state.ctm.0,+ baseline: s.baseline,+ x: s.start_x,+ state: TextState::of(&s.state),+ bt_op: s.bt_op,+ bt_state: TextState::of(&s.bt_state),+ },+ });+ }+ *last = Some(Pen::after(&s));+}++/// How deep form XObjects nest before reading stops (they may also refer to themselves). The+/// renderer stops at the same depth, so export reads the text the page shows (#3120).+pub const MAX_FORM_DEPTH: usize = 50;++/// The most form XObjects one page's walk enters, at any depth. The depth cap alone still lets+/// a form that draws another form many times fan out exponentially (100 `Do`s on each of 50+/// levels), which would hang export on a hostile PDF. The renderer paints as many forms nested+/// in forms; this budget also counts the forms the page draws itself, so a page that draws one+/// a million times stays bounded too. A label or table cell drawn as a form a few thousand+/// times is read in full (#3120).+pub const MAX_FORM_VISITS: usize = 50_000;++/// One page's walk through the form XObjects it draws: how many it entered (the page's+/// [`MAX_FORM_VISITS`]), the bytes the page's content and forms may still decode to, and whether+/// a limit left a form unread.+pub(crate) struct FormBudget {+ visits: usize,+ decode: DecodeBudget,+ /// A form was left unread because it nests deeper than [`MAX_FORM_DEPTH`], comes past+ /// [`MAX_FORM_VISITS`] or past the decode budget: what it draws is missing from the walk.+ pub(crate) truncated: bool,+}++impl FormBudget {+ /// The walk of a page's forms, spending what `decode` has left after the page's content.+ pub(crate) fn new(decode: DecodeBudget) -> Self {+ Self { visits: 0, decode, truncated: false }+ }+}++/// A form XObject a page draws: its object, content, resources and its matrix composed with the+/// CTM at the `Do`.+pub(crate) struct FormCall {+ pub(crate) obj: Option<pdfcraft_cos::ObjRef>,+ pub(crate) data: Vec<u8>,+ pub(crate) resources: Dict,+ pub(crate) ctm: Matrix,+}++/// The form XObject `name` in `resources`, drawn with `ctm`. `None` for images, missing names+/// and forms already being read (`path`), and for forms nested too deep or past the page's+/// budget, which `budget` records as truncated; each form entered counts one visit.+pub(crate) fn form_call(+ doc: &Document,+ resources: &Dict,+ name: &[u8],+ ctm: Matrix,+ path: &[pdfcraft_cos::ObjRef],+ budget: &mut FormBudget,+) -> Option<FormCall> {+ let limited = path.len() >= MAX_FORM_DEPTH || budget.visits >= MAX_FORM_VISITS || budget.decode.remaining() == 0;+ // Once a limit has cut the page short, refusing the rest costs nothing more.+ if limited && budget.truncated {+ return None;+ }+ let xobjects = resources.get(b"XObject").map(|x| doc.resolve(x)).and_then(|x| x.as_dict().cloned())?;+ let o = xobjects.get(name)?;+ let obj = o.as_ref();+ if obj.is_some_and(|r| path.contains(&r)) {+ return None;+ }+ let Object::Stream(s) = &*doc.resolve(o) else { return None };+ if s.dict.name(b"Subtype") != Some(b"Form") {+ return None;+ }+ // Only a form left unread loses content; an image at the limit is still read by its caller.+ if limited {+ budget.truncated = true;+ return None;+ }+ let m = s.dict.get(b"Matrix").map(|m| doc.resolve(m)).and_then(|m| {+ let a = m.as_array()?;+ let v: Vec<f64> = a.iter().filter_map(|x| doc.resolve(x).as_f64()).collect();+ <[f64; 6]>::try_from(v).ok().filter(|v| v.iter().all(|x| x.is_finite()))+ });+ // A form without its own resources uses the ones it was drawn with (PDF 1.1 files).+ let own = s.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned());+ let data = match budget.decode.decode(s) {+ Ok(data) => data,+ Err(_) if budget.decode.remaining() == 0 => {+ budget.truncated = true;+ return None;+ }+ Err(_) => Vec::new(),+ };+ budget.visits = budget.visits.saturating_add(1);+ Some(FormCall { obj, data, resources: own.unwrap_or_else(|| resources.clone()), ctm: m.map_or(ctm, |m| Matrix(m).then(&ctm)) })+}++/// The lines a page shows as it reads, including text drawn by form XObjects (which+/// [`text_lines`] leaves out because it can only rewrite the page's own streams). Lines from a+/// form carry a stream number past the page's streams, one per form drawn. The flag is `true`+/// when forms past [`MAX_FORM_DEPTH`] or [`MAX_FORM_VISITS`] were left unread.+pub(super) fn reading_lines(doc: &Document, page: usize) -> Result<(Vec<TextLine>, bool), EditError> {+ struct Walk<'a> {+ doc: &'a Document,+ lines: Vec<TextLine>,+ next_stream: usize,+ path: Vec<pdfcraft_cos::ObjRef>,+ budget: FormBudget,+ }+ /// `stream` gives the stream number of the operator at an index of `ops`.+ fn walk(w: &mut Walk, ops: &[Op], resources: &Dict, carry: &mut Carry, stream: &dyn Fn(usize) -> usize) -> Result<(), EditError> {+ let mut cache = HashMap::new();+ let mut invoked = Vec::new();+ let properties = resources.get(b"Properties").and_then(|o| w.doc.dict(o)).unwrap_or_default();+ let shown = interpret(w.doc, ops, resources, &mut cache, carry, Some(&mut invoked), Some(&properties))?;+ let mut last = None;+ let mut last_stream = None;+ let mut forms = invoked.into_iter().peekable();+ for s in shown {+ while let Some((_, name, ts)) = forms.next_if(|f| f.0 < s.op) {+ enter(w, resources, &name, ts, &mut carry.text_left)?;+ // Text after a form starts a new line.+ last = None;+ }+ let si = stream(s.op);+ // Text from another stream starts a new line, as when each stream was read alone.+ if last_stream.replace(si).is_some_and(|prev| prev != si) {+ last = None;+ }+ add_shown(&mut w.lines, &mut last, s, si);+ }+ for (_, name, ts) in forms {+ enter(w, resources, &name, ts, &mut carry.text_left)?;+ }+ Ok(())+ }+ /// `text_left`: the page's text budget, shared with the forms the page draws.+ fn enter(w: &mut Walk, resources: &Dict, name: &[u8], ts: Ts, text_left: &mut usize) -> Result<(), EditError> {+ let Some(form) = form_call(w.doc, resources, name, ts.ctm, &w.path, &mut w.budget) else { return Ok(()) };+ let ops = parse(&form.data).ops;+ // The form starts with the graphics state at its `Do`, its own matrix applied.+ let mut carry = Carry { ts: Ts { ctm: form.ctm, ..ts }, stack: Vec::new(), marked: Vec::new(), layers: Vec::new(), text_left: *text_left };+ let stream = w.next_stream;+ w.next_stream = w.next_stream.saturating_add(1);+ if let Some(r) = form.obj {+ w.path.push(r);+ }+ walk(w, &ops, &form.resources, &mut carry, &|_| stream)?;+ *text_left = carry.text_left;+ if form.obj.is_some() {+ w.path.pop();+ }+ Ok(())+ }+ let p = page_dict(doc, page)?;+ let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let mut decode = DecodeBudget::page();+ let streams = content_streams_within(doc, &p.dict, &mut decode)?;+ let mut w = Walk { doc, lines: Vec::new(), next_stream: streams.len(), path: Vec::new(), budget: FormBudget::new(decode) };+ let mut carry = Carry::new();+ // Read the page's streams as the one stream they are, in one pass, as rendering and editing+ // do: a comment, an operator's operands or a marked-content sequence (its /ActualText too)+ // can run on from one stream into the next. Text still counts as the stream its operator+ // starts in, which keeps lines from different streams apart.+ let pieces = Pieces::join(&streams.into_iter().map(|(_, data)| data).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ let stream_of = |i: usize| ops.get(i).map_or(0, |op| pieces.pieces_of(op).0);+ walk(&mut w, &ops, &res, &mut carry, &stream_of)?;+ let mut lines = w.lines;+ // A visual-order Indic font draws pre-base vowel signs before their consonant.+ for l in lines.iter_mut().filter(|l| l.visual_order && !l.actual_text) {+ let shown = l.text.clone();+ l.text = crate::indic::to_logical(&l.text);+ if l.text != shown {+ l.runs.clear();+ }+ }+ lines.retain(|l| !l.text.trim().is_empty());+ Ok((lines, w.budget.truncated))+}diff --git a/crates/edit/src/text/rewrite.rs b/crates/edit/src/text/rewrite.rsnew file mode 100644index 000000000..dd58c7289--- /dev/null+++ b/crates/edit/src/text/rewrite.rs@@ -0,0 +1,857 @@+use super::blocks::{BlockStyle, TextBlock, paragraph_separator, wrap};+use super::fallback::{+ Encoder, MAX_TYPE3_GLYPHS, drop_unused_fallback_fonts, needs_type3, no_japanese_font, source_encodes, source_family, source_program_completes,+ source_show, source_space, source_width, type3_encode, type3_font,+};+use super::interp::{Carry, interpret};+use super::lines::{content_streams, page_dict, rewritten_contents, splice, text_lines};+use super::*;++/// What replacing a line did.+#[derive(Clone, Debug, PartialEq)]+pub struct LineEdit {+ /// `Some(font)` when the line's font couldn't show the new text and Helvetica was used.+ pub substituted: Option<String>,+}++/// Replace the text of line `line` (an index into [`text_lines`]) on `page` with `text`.+pub fn replace_line(doc: &mut Document, page: usize, line: usize, text: &str) -> Result<LineEdit, EditError> {+ let edit = replace_line_with_limit(doc, page, line, text, MAX_TYPE3_GLYPHS)?;+ drop_unused_fallback_fonts(doc, page);+ Ok(edit)+}++/// Refuses a rewrite that would remove text drawn as a clipping path (`4 Tr` to `7 Tr`). Such+/// glyphs are not ink but a mask, and whatever is painted through them takes their shape.+/// Removing the glyphs removes the mask, and the fill or image behind floods its own rectangle+/// instead -- the artwork is destroyed, in a file that still opens without a warning (#3429).+/// `clear_block` already refuses these for the same reason.+///+/// Every line the rewrite drops is checked, not only the one being replaced: a line's runs need+/// not share a rendering mode (see [`TextLine::clips`]), and [`coincident_ops`] drops a whole+/// overlapping line without regard to its mode -- so a mask could go with text that is ink.+fn refuse_clipping_text(lines: &[TextLine], dropped: &std::collections::HashSet<usize>) -> Result<(), EditError> {+ if lines.iter().any(|l| l.clips && l.ops.iter().any(|op| dropped.contains(op))) {+ return Err(EditError::Invalid("text used as a clipping path cannot be edited: its glyphs mask the artwork behind them".into()));+ }+ Ok(())+}++/// [`replace_line`] with the most unique characters one generated font may hold (tests lower it).+pub(crate) fn replace_line_with_limit(doc: &mut Document, page: usize, line: usize, text: &str, max_glyphs: usize) -> Result<LineEdit, EditError> {+ let text = text.replace(['\n', '\r'], " ");+ let lines = text_lines(doc, page)?;+ let target = lines.get(line).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no line {}", page + 1, line + 1)))?;+ target.ensure_editable()?;+ // Copies of the line drawn on the same baseline go with it, so the replacement is all that+ // shows. Which operators go is settled here, before any font is generated, so that a refusal+ // leaves the document untouched.+ let mut drops = coincident_ops(&lines, &[&target]);+ drops.extend(target.ops.iter().copied());+ refuse_clipping_text(&lines, &drops)?;+ let p = page_dict(doc, page)?;+ let mut res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let mut fonts_res = res.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();+ let streams = content_streams(doc, &p.dict)?;+ let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ let first = target.ops.first().copied().filter(|i| *i < ops.len()).ok_or_else(|| EditError::Invalid("the page's content changed".into()))?;+ // The line's own font, when it can show every character.+ let font = fonts_res.get(target.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));+ let visual_indic = font.as_ref().is_some_and(|m| m.visual_order) || target.visual_order;+ let indic_text = if visual_indic { crate::indic::to_visual(&text) } else { text.clone() };+ // Typed in logical order; drawn left to right (right-to-left runs reversed).+ let shown = crate::bidi::to_visual(&indic_text);+ let reused = font.as_ref().filter(|m| source_encodes(m, &shown));+ let mut substituted = None;+ let mut replacement: Vec<Op> = Vec::new();+ // ' and " also move to the next line; keep that.+ match ops[first].op.as_slice() {+ b"'" => replacement.push(Op::new("T*", vec![])),+ b"\"" => {+ replacement.push(Op::new("Tw", vec![ops[first].operands.first().cloned().unwrap_or(Object::Int(0))]));+ replacement.push(Op::new("Tc", vec![ops[first].operands.get(1).cloned().unwrap_or(Object::Int(0))]));+ replacement.push(Op::new("T*", vec![]));+ }+ _ => {}+ }+ match reused {+ Some(metrics) => replacement.extend(source_show(+ metrics,+ &shown,+ target.origin.state.font.as_ref().map_or(target.size, |(_, size)| *size),+ source_space(doc, &fonts_res, metrics),+ target.origin.state.char_spacing,+ target.origin.state.word_spacing,+ )?),+ None => {+ let fallback_shown = crate::bidi::to_visual(&text);+ if needs_type3(&text) {+ let fallback = type3_font(doc, &mut fonts_res, &text, source_family(&target.base_font), target.bold, max_glyphs)?;+ let runs = type3_encode(&fallback, &fallback_shown)+ .ok_or_else(|| EditError::Invalid(format!("\"{text}\" can't be shown by the {} fallback", fallback.family)))?;+ let size = font_size_before(&ops, first).unwrap_or(target.size);+ for (name, bytes) in runs {+ replacement.push(Op::new("Tf", vec![Object::name(&name), pdfcraft_content::num(size)]));+ replacement.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));+ }+ replacement.push(Op::new("Tf", vec![Object::name(&target.font), pdfcraft_content::num(size)]));+ substituted = Some(format!("{} Type3", fallback.family));+ } else {+ let win = pdfcraft_fonts::win_ansi(&fallback_shown);+ // WinAnsi turns what it can't show into '?'; refuse rather than print the wrong thing.+ let back: String = win.iter().map(|b| char::from_u32(u32::from(*b)).unwrap_or('?')).collect();+ if fallback_shown.chars().zip(back.chars()).any(|(a, b)| b == '?' && a != '?') {+ return Err(EditError::Invalid(format!("\"{text}\" has characters neither {} nor Helvetica can show", target.base_font)));+ }+ // The size in text space: the current Tf's size.+ let size = font_size_before(&ops, first).unwrap_or(target.size);+ let family = source_family(&target.base_font);+ let base = family.base_font(target.bold, target.italic);+ let substitute_name = format!("PCEd{}", base.replace('-', ""));+ replacement.push(Op::new("Tf", vec![Object::name(&substitute_name), pdfcraft_content::num(size)]));+ replacement.push(Op::new("Tj", vec![Object::String(PdfString::literal(win))]));+ replacement.push(Op::new("Tf", vec![Object::name(&target.font), pdfcraft_content::num(size)]));+ substituted = Some(base.to_string());+ let mut f = Dict::new();+ f.set(b"Type".to_vec(), Object::name("Font"));+ f.set(b"Subtype".to_vec(), Object::name("Type1"));+ f.set(b"BaseFont".to_vec(), Object::name(base));+ f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));+ fonts_res.set(substitute_name.into_bytes(), Object::Dict(f));+ }+ }+ }+ // Rebuild: the line's first operator becomes the replacement, its others go.+ let new_data = splice(&pieces, &ops, |i| if i == first { (std::mem::take(&mut replacement), false) } else { (Vec::new(), !drops.contains(&i)) });+ let contents = rewritten_contents(doc, &streams, new_data);+ let page_ref = p.obj;+ if substituted.is_some() {+ res.set(b"Font".to_vec(), Object::Dict(fonts_res));+ }+ doc.update_dict(page_ref, |d| {+ d.set(b"Contents".to_vec(), contents);+ if substituted.is_some() {+ d.set(b"Resources".to_vec(), Object::Dict(res));+ }+ })?;+ Ok(LineEdit { substituted })+}++/// The size of the last `Tf` before operator `at`.+fn font_size_before(ops: &[Op], at: usize) -> Option<f64> {+ ops[..at].iter().rev().find(|o| o.is("Tf")).and_then(|o| o.num(1))+}++/// Operators of every line that is another drawing of one of `targets` (fake bold, an invisible+/// text layer). A surviving copy would show the old text under the replacement.+///+/// A copy overlaps a target by more than half the smaller box and sits on the same baseline+/// (within the tolerance that joins showing operators onto one line). A neighbouring line can+/// share box area when the leading is tighter than the font's ascent plus descent; its baseline+/// is farther away, so it stays.+pub(crate) fn coincident_ops(lines: &[TextLine], targets: &[&TextLine]) -> std::collections::HashSet<usize> {+ let area = |r: [f64; 4]| ((r[2] - r[0]) * (r[3] - r[1])).max(0.0);+ let mut drop = std::collections::HashSet::new();+ for line in lines {+ let copy = targets.iter().any(|target| {+ let same_text = line.text.trim() == target.text.trim() || (line.origin.state.render_mode == 3) != (target.origin.state.render_mode == 3);+ same_text && overlaps_half(line.rect, target.rect, area) && on_same_baseline(line, target)+ });+ if copy {+ drop.extend(line.ops.iter().copied());+ }+ }+ drop+}++fn overlaps_half(a: [f64; 4], b: [f64; 4], area: impl Fn([f64; 4]) -> f64) -> bool {+ let ix = (b[2].min(a[2]) - b[0].max(a[0])).max(0.0);+ let iy = (b[3].min(a[3]) - b[1].max(a[1])).max(0.0);+ let small = area(b).min(area(a));+ small > 0.0 && ix * iy / small > 0.5+}++/// Perpendicular distance between baselines, in user space. Horizontal text compares height;+/// turned text compares the distance across the writing direction.+fn on_same_baseline(line: &TextLine, target: &TextLine) -> bool {+ let (dir, target_dir) = (line.direction(), target.direction());+ let same_dir = (dir.0 - target_dir.0).abs() < 1e-3 && (dir.1 - target_dir.1).abs() < 1e-3;+ let same_size = line.size.min(target.size) >= line.size.max(target.size) * 0.8;+ let angle = target.rotation().to_radians();+ let (sin, cos) = if angle.is_finite() { angle.sin_cos() } else { (0.0, 1.0) };+ let dx = line.origin.x - target.origin.x;+ let dy = line.origin.baseline - target.origin.baseline;+ let offset = dx.mul_add(-sin, dy * cos).abs();+ let size = line.size.min(target.size).max(1.0);+ same_dir && same_size && offset.is_finite() && offset < size * 0.3+}++/// Rewrite paragraph `block` with new text (or its own) and formatting, rewrapped to its width.+pub fn rewrite_block(doc: &mut Document, page: usize, block: usize, text: Option<&str>, style: &BlockStyle) -> Result<LineEdit, EditError> {+ let edit = rewrite_block_with_limit(doc, page, block, text, style, MAX_TYPE3_GLYPHS)?;+ drop_unused_fallback_fonts(doc, page);+ Ok(edit)+}++/// [`rewrite_block`] with the most unique characters one generated font may hold (tests lower it).+pub(crate) fn rewrite_block_with_limit(+ doc: &mut Document,+ page: usize,+ block: usize,+ text: Option<&str>,+ style: &BlockStyle,+ max_glyphs: usize,+) -> Result<LineEdit, EditError> {+ TextSession::open(doc, page, block)?.commit_with_limit(doc, text, style, max_glyphs)+}++/// [`rewrite_block_with_limit`] with the page's [`text_lines`], read from `doc` as it is now.+pub(crate) fn rewrite_block_from(+ doc: &mut Document,+ page: usize,+ lines: Vec<TextLine>,+ block: usize,+ text: Option<&str>,+ style: &BlockStyle,+ max_glyphs: usize,+) -> Result<LineEdit, EditError> {+ let blocks = group_blocks(&lines);+ let b = blocks.get(block).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no paragraph {}", page + 1, block + 1)))?;+ let members: Vec<&TextLine> = b.lines.iter().map(|i| &lines[*i]).collect();+ // One clipping run is enough: rewriting the paragraph would drop its mask with the rest.+ let mut dropped = coincident_ops(&lines, &members);+ dropped.extend(members.iter().flat_map(|l| l.ops.iter().copied()));+ refuse_clipping_text(&lines, &dropped)?;+ let first = members.first().copied().ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;+ members.iter().try_for_each(|line| line.ensure_editable())?;+ let p = page_dict(doc, page)?;+ let mut res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let mut fonts_res = res.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();+ let registered_face = fonts_res.iter().any(|(name, _)| name.starts_with(b"PCFull"));+ // Hebrew is written back in drawing order (and with the Hebrew fallback face) by the+ // single-style path below; the styled region path does not reorder right-to-left runs.+ let hebrew = text.unwrap_or(&b.text).chars().any(crate::bidi::is_hebrew);+ if hebrew && (!style.ranges.is_empty() || style.resource.is_some()) {+ return Err(EditError::Invalid(+ "formatting part of right-to-left (Hebrew) text, or choosing a document font for it, isn't supported yet".into(),+ ));+ }+ // Text turned on the page (a landscape page drawn a quarter turn round) is rewritten in its+ // own text space below; the styled region path lays rows out along the page's x axis.+ let upright = members.iter().all(|line| line.upright());+ if !upright && (!style.ranges.is_empty() || style.resource.is_some()) {+ return Err(EditError::Invalid("formatting part of turned text, or choosing a document font for it, isn't supported yet".into()));+ }+ let visual_indic = members.iter().any(|line| line.visual_order);+ if upright+ && !hebrew+ && !visual_indic+ && (!style.ranges.is_empty()+ || style.resource.is_some()+ || (text.is_some_and(|draft| {+ // A row break, `\n` or a carriage return, takes the path that keeps untouched rows.+ draft.contains(['\n', '\r'])+ || pdfcraft_fonts::source_shaping::required(draft)+ || !pdfcraft_fonts::embedding::matching_faces(&b.base_font).is_empty()+ }) || registered_face+ || text.is_some_and(|draft| source_program_completes(doc, &fonts_res, first, draft))+ || b.rows.iter().any(|row| row.len() > 1)+ || members.iter().any(|line| line.font != first.font || line.size != first.size || line.color != first.color))+ && style.family.is_none()+ && style.bold.is_none())+ {+ return rewrite_styled_block(doc, page, &b, &lines, text, style, max_glyphs);+ }+ let streams = content_streams(doc, &p.dict)?;+ let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ // Explicit line breaks stay (#1443), and so does each typed U+0020 space: a run of them is+ // not folded into one (#4199, #3797). `\r\n` and a lone `\r` are breaks too; other white+ // space is written as one space.+ let text: String = text+ .unwrap_or(&b.text)+ .replace("\r\n", "\n")+ .chars()+ .map(|c| match c {+ '\r' => '\n',+ c if c != '\n' && paragraph_separator(c) => ' ',+ c => c,+ })+ .collect();+ // The characters to show, for choosing fonts: the breaks are moves, not glyphs.+ let flat = text.replace('\n', " ");+ let o = &first.origin;+ let last = members.last().copied().unwrap_or(first);+ let emit = &last.origin;+ let (font_name, old_size) = o.state.font.clone().ok_or_else(|| EditError::Invalid("the paragraph has no font".into()))?;+ let k = o.k.max(1e-6);+ // The size in text space: points ÷ the text-to-user scale.+ let size = style.size.map_or(old_size, |pt| (pt / k).max(0.1));+ // Spacing and scaling (text state), with the chosen values.+ let mut ts_state = o.state.clone();+ if let Some(c) = style.char_spacing {+ ts_state.char_spacing = c / k;+ }+ if let Some(sc) = style.scale {+ ts_state.scale = (sc / 100.0).clamp(0.1, 10.0);+ }+ let o_state = ts_state.clone();+ let metrics = fonts_res.get(font_name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));+ let visual_indic = metrics.as_ref().is_some_and(|m| m.visual_order) || first.visual_order;+ let indic_text = if visual_indic { crate::indic::to_visual(&flat) } else { flat.clone() };+ let reuse = style.family.is_none() && style.bold.is_none() && metrics.as_ref().is_some_and(|m| source_encodes(m, &indic_text));+ let space = metrics.as_ref().map_or(0.33, |m| source_space(doc, &fonts_res, m));+ // The chosen style also determines the real Japanese fallback outlines and advances.+ let (family, bold, italic) = style.family.unwrap_or((source_family(&b.base_font), b.bold, b.italic));+ let bold = style.bold.unwrap_or(bold);+ // The face is chosen after `bold` settles, so a bold request measures with the bold metrics.+ let face = family.std14(bold, italic);+ let std_width = move |s: &str, size: f64| -> f64 { face.text_width(s, size) };+ let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);+ if !(dx.is_finite() && dy.is_finite()) {+ return Err(EditError::Invalid("the paragraph can't be moved that far".into()));+ }+ // Right-to-left text (more Hebrew or Arabic letters than Latin) is right-aligned unless an+ // alignment is asked for, and a single right-to-left line keeps its right edge as it grows.+ let rtl = crate::bidi::rtl_base(&flat);+ let anchored_right = rtl && upright && style.width.is_none() && members.len() == 1;+ // The paragraph's width along its lines: in user space unless it is turned.+ let frame = if upright {+ b.rect+ } else {+ members.iter().map(|l| l.frame_rect()).reduce(|a, f| [a[0].min(f[0]), a[1].min(f[1]), a[2].max(f[2]), a[3].max(f[3])]).unwrap_or(b.rect)+ };+ // A centred title is laid out in the box it already sits in, so it keeps its centre as it+ // grows or wraps, rather than being grown to the right up to the page's margin (#2581).+ // Turned text is left alone: its centre lives along its own baseline, not in page space.+ let crop = p.crop(doc);+ let centred = upright && !rtl && style.width.is_none() && style.align.is_none() && is_centred(&b, &lines, (crop[0] + crop[2]) / 2.0, first.size);+ // A paragraph keeps its width (or takes the one asked for); a single line grows to the right+ // (to the left when right-to-left), up to the page's margin.+ let width = match style.width {+ // Capped at the largest page PDF allows (14 400 pt), even for text set larger than that+ // (`clamp` panics when its minimum is the larger, or NaN).+ Some(w) if w.is_finite() => w.clamp((size * k).min(14_400.0), 14_400.0),+ Some(_) => return Err(EditError::Invalid("the paragraph's width must be a number".into())),+ // Turned text: the page's margins are along another axis. A single line grows (below).+ None if !upright => (frame[2] - frame[0]).max(size * k),+ None if anchored_right => (b.rect[2] - b.rect[0]).max(size * k).max(b.rect[2] + dx - (crop[0] + 36.0)),+ // A centred line is not stretched to the margin: its own box is the frame it is centred in.+ None if members.len() == 1 && !centred => (b.rect[2] - b.rect[0]).max(size * k).max(crop[2] - 36.0 - (b.rect[0] + dx)),+ None => (b.rect[2] - b.rect[0]).max(size * k),+ };+ if !width.is_finite() {+ return Err(EditError::Invalid("the paragraph's width must be a number".into()));+ }+ let align = if centred { Some(crate::added::Align::Center) } else { style.align.or(rtl.then_some(crate::added::Align::Right)) };+ // Where a right-aligned line ends, from the paragraph's left edge (user space).+ let right_edge = if anchored_right { (b.rect[2] - b.rect[0]).max(0.0) } else { width };+ // The move and the width are checked here, before the fallback fonts are written: a refused+ // paragraph leaves the document as it was. The move is in page space, so it is taken back through+ // the CTM's linear part into the space the paragraph is drawn in.+ let movement = if dx != 0.0 || dy != 0.0 {+ let c = emit.ctm;+ let back = Matrix([c[0], c[1], c[2], c[3], 0.0, 0.0])+ .invert()+ .ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be moved in".into()))?;+ Some(back.apply(dx, dy))+ } else {+ None+ };+ let tm = if o.ctm == emit.ctm {+ o.tm+ } else {+ let emit_inv = Matrix(emit.ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph has a singular transform".into()))?;+ Matrix(o.tm).then(&Matrix(o.ctm)).then(&emit_inv).0+ };+ let type3 = if !reuse && needs_type3(&flat) { Some(type3_font(doc, &mut fonts_res, &flat, family, bold, max_glyphs)?) } else { None };+ let advance = |s: &str| -> f64 {+ let t = match (&metrics, reuse) {+ (Some(m), true) => {+ let visual_s = if m.visual_order { crate::indic::to_visual(s) } else { s.to_owned() };+ source_width(m, &visual_s, size, space, o_state.char_spacing, o_state.word_spacing)+ }+ _ if let Some(fallback) = &type3 => {+ // Each character's count in `s`, from one pass over `s`.+ let mut counts: HashMap<char, usize> = HashMap::new();+ for c in s.chars() {+ let count = counts.entry(c).or_insert(0);+ *count = count.saturating_add(1);+ }+ fallback.widths.iter().map(|(ch, width)| counts.get(ch).copied().unwrap_or(0) as f64 * width * size).sum::<f64>()+ + s.chars().count() as f64 * o_state.char_spacing+ }+ _ => std_width(s, size) + s.chars().count() as f64 * o_state.char_spacing,+ };+ t * o_state.scale * k+ };+ // A turned single line grows to fit, up to where its baseline reaches the page's margin.+ let width = if !upright && style.width.is_none() && members.len() == 1 {+ let crop = p.crop(doc);+ let (x0, y0) = (first.origin.x + dx, first.origin.baseline + dy);+ let (ux, uy) = first.direction();+ let tx = if ux > 1e-6 {+ (crop[2] - 36.0 - x0) / ux+ } else if ux < -1e-6 {+ (crop[0] + 36.0 - x0) / ux+ } else {+ f64::INFINITY+ };+ let ty = if uy > 1e-6 {+ (crop[3] - 36.0 - y0) / uy+ } else if uy < -1e-6 {+ (crop[1] + 36.0 - y0) / uy+ } else {+ f64::INFINITY+ };+ let cap = width.max(tx.min(ty)).min(14_400.0);+ text.split('\n').map(&advance).fold(width, f64::max).min(cap)+ } else {+ width+ };+ let right_edge = if anchored_right { right_edge } else { width };+ let wrapped = wrap(&text, width + 0.5, advance);+ let mut substituted = None;+ let new_font = !reuse;+ let (show_font, encode): (String, Encoder) = if let Some(m) = metrics.clone().filter(|_| reuse) {+ let name = font_name.clone();+ (font_name.clone(), Box::new(move |s: &str| m.encode(s).map(|bytes| vec![(name.clone(), bytes)])))+ } else if let Some(fallback) = type3.clone() {+ substituted = Some(format!("{} Type3", fallback.family));+ let first = fallback.names.first().cloned().ok_or_else(no_japanese_font)?;+ (first, Box::new(move |s: &str| type3_encode(&fallback, s)))+ } else {+ let win = pdfcraft_fonts::win_ansi(&flat);+ let back: String = win.iter().map(|c| char::from_u32(u32::from(*c)).unwrap_or('?')).collect();+ let base = family.base_font(bold, italic);+ if flat.chars().zip(back.chars()).any(|(a, c)| c == '?' && a != '?') {+ return Err(EditError::Invalid(format!("\"{flat}\" has characters neither {} nor {base} can show", b.base_font)));+ }+ let mut f = Dict::new();+ f.set(b"Type".to_vec(), Object::name("Font"));+ f.set(b"Subtype".to_vec(), Object::name("Type1"));+ f.set(b"BaseFont".to_vec(), Object::name(base));+ f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));+ // Named after its face, as the line and region rewrites name theirs: one name for every+ // stand-in would repoint the paragraphs set in an earlier one at this face (#4280).+ let name = format!("PCEd{}", base.replace('-', ""));+ fonts_res.set(name.clone().into_bytes(), Object::Dict(f));+ if style.family.is_none() {+ substituted = Some(base.to_string());+ }+ let shown = name.clone();+ (name, Box::new(move |s: &str| Some(vec![(shown.clone(), pdfcraft_fonts::win_ansi(s))])))+ };+ // Line spacing in text space: the paragraph's own (scaled with the size), or 1.2 × the size.+ let lead = match style.line_spacing {+ Some(m) => size * m.clamp(0.5, 5.0),+ // From the first two rows (a row may hold several runs).+ None if let Some((upper, lower)) = b+ .rows+ .first()+ .zip(b.rows.get(1))+ .and_then(|(upper, lower)| upper.first().zip(lower.first()))+ .and_then(|(upper, lower)| lines.get(*upper).zip(lines.get(*lower))) =>+ {+ (upper.frame_origin().1 - lower.frame_origin().1) / k * size / old_size+ }+ None if o_state.leading > 0.0 => o_state.leading,+ None => size * 1.2,+ };+ let n = pdfcraft_content::num;+ // The paragraph's operators go, and so does another drawing on the same baseline (a fake-bold+ // second copy, an invisible text layer): the new text is all that may show.+ let drop = dropped;+ // Text shown earlier in the same text object stays first: the paragraph then goes where its+ // last row was, after any backgrounds between the rows, or between two halves of the text object.+ let start = last.ops.first().copied().unwrap_or(emit.bt_op);+ let split = ops+ .get(emit.bt_op..start)+ .unwrap_or_default()+ .iter()+ .enumerate()+ .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(emit.bt_op + i)));+ // What the text after the paragraph expects, and what is in force where the paragraph is+ // drawn: the state at its BT (or where it was split).+ let after = if split { &emit.state } else { &emit.bt_state };+ // In its own graphics state, so a new colour (or anything else) stops at the paragraph.+ let mut block_ops = vec![Op::new("q", vec![])];+ block_ops.extend(reveal_ops(&b, &lines, style, emit.ctm)?);+ // Moved: a translation inside that state.+ if let Some((ax, ay)) = movement {+ block_ops.push(Op::new("cm", vec![n(1.0), n(0.0), n(0.0), n(1.0), n(ax), n(ay)]));+ }+ // Painted as the paragraph was, including what its text object set before the first show.+ block_ops.extend(o_state.paint_ops(after));+ block_ops.push(Op::new("BT", vec![]));+ let mut state = o_state.clone();+ state.word_spacing = 0.0;+ // The font the next run is shown in: the one the BT sets, until a run of another fallback subset.+ let mut shown_font = show_font.clone();+ state.font = Some((show_font, size));+ if let Some([r, g, bl]) = style.color {+ state.fill = vec![Op::new("rg", vec![n(r), n(g), n(bl)])];+ }+ block_ops.extend(state.ops());+ block_ops.push(Op::new("Tm", tm.iter().map(|v| n(*v)).collect()));+ // Alignment: each line's offset from the left edge, in text space.+ // `visible` is the width the line is aligned on (see the loop below).+ let offset = |visible: f64| -> f64 {+ let free = (width - visible).max(0.0) / k;+ match align {+ Some(crate::added::Align::Center) => free / 2.0,+ // A right-to-left line anchored at its right edge may start left of the old box.+ Some(crate::added::Align::Right) if anchored_right => (right_edge - visible) / k,+ Some(crate::added::Align::Right) => free,+ // A justified right-to-left paragraph ends its last line at the right edge.+ Some(crate::added::Align::Justify) if rtl => free,+ _ => 0.0,+ }+ };+ // Justify: each line but the last fills the width. Word spacing reaches only single-byte code 32+ // (ISO 32000-1 §9.3.3), so where a space is shown with another code (a composite font, a+ // generated Type 3 font, a subset without a space) the extra space follows each space as a+ // TJ adjustment instead, and code 32, which may then be a letter, gets none.+ let justify = align == Some(crate::added::Align::Justify);+ let word_spacing_reaches_spaces = match metrics.as_ref().filter(|_| reuse) {+ Some(m) => m.encode(" ").is_some_and(|b| m.codes(&b).iter().all(|(c, len)| m.is_space(*c, *len))),+ None => type3.is_none(),+ };+ let mut x = 0.0;+ let mut tw_set = 0.0;+ let mut underlines: Vec<(f64, f64, f64)> = Vec::new(); // (x0, x1, y) in text space+ for (i, line) in wrapped.iter().enumerate() {+ // A stretched (justified) line shows only its words, as before #4199: word spacing would+ // reach the spaces before its first word and after its last, so they are left out, and+ // the line fills the width from the left edge. Nothing to stretch over, or a paragraph+ // drawn at `0 Tz`, isn't justified.+ let body = line.trim_matches(' ');+ let interior = body.matches(' ').count();+ let tw = if justify && i + 1 < wrapped.len() && interior > 0 && o_state.scale.abs() > 1e-6 {+ Some((width - advance(body)).max(0.0) / k / o_state.scale / interior as f64).filter(|tw| tw.is_finite())+ } else {+ None+ }+ .unwrap_or(0.0);+ // Other lines show every space typed. A left-to-right one is aligned on its width up to+ // its last word; a right-to-left one on its whole width, since the spaces typed after its+ // last word are drawn on its left and the ones before its first on its right.+ let (shown, visible) = if tw > 0.0 {+ (body, advance(body))+ } else if crate::bidi::rtl_base(line) {+ (line.as_str(), advance(line))+ } else {+ (line.as_str(), advance(line.trim_end_matches(' ')))+ };+ let dx = if tw > 0.0 { 0.0 } else { offset(visible) };+ if i > 0 || dx != 0.0 {+ block_ops.push(Op::new("Td", vec![n(dx - x), n(if i > 0 { -lead } else { 0.0 })]));+ }+ x = dx;+ let stretch = if word_spacing_reaches_spaces { 0.0 } else { tw };+ let tw = tw - stretch;+ if tw != tw_set {+ block_ops.push(Op::new("Tw", vec![n(tw)]));+ tw_set = tw;+ }+ // Each wrapped line in typing order; drawn left to right (right-to-left runs reversed).+ let visual = crate::bidi::to_visual(shown);+ // Stretched without word spacing: shown up to and including each space, then moved on.+ let pieces = if stretch > 0.0 { visual.split_inclusive(' ').collect() } else { vec![visual.as_str()] };+ for piece in pieces {+ if let Some(metrics) = metrics.as_ref().filter(|_| reuse) {+ let indic_piece = if metrics.visual_order { crate::indic::to_visual(piece) } else { piece.to_owned() };+ block_ops.extend(source_show(metrics, &indic_piece, size, space, o_state.char_spacing, tw)?);+ } else {+ for (font, bytes) in encode(piece).ok_or_else(|| EditError::Invalid(format!("\"{line}\" can't be shown")))? {+ if font != shown_font {+ block_ops.push(Op::new("Tf", vec![Object::name(&font), n(size)]));+ shown_font = font;+ }+ block_ops.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));+ }+ }+ if stretch > 0.0 && piece.ends_with(' ') {+ block_ops.push(Op::new("TJ", vec![Object::Array(vec![n(-1000.0 * stretch / size)])]));+ }+ }+ let tw = tw + stretch;+ // Underlined to the line's last word, over its stretched gaps.+ let w = (visible + tw * interior as f64 * o_state.scale * k) / k;+ underlines.push((dx, dx + w, -(i as f64) * lead - size * 0.12));+ }+ block_ops.push(Op::new("ET", vec![]));+ if style.underline == Some(true) {+ // In text space (the paragraph's text matrix), in its fill colour.+ let colour: Vec<Op> = state+ .fill+ .iter()+ .map(|f| match f.op.as_slice() {+ b"g" => Op::new("G", f.operands.clone()),+ b"rg" => Op::new("RG", f.operands.clone()),+ b"k" => Op::new("K", f.operands.clone()),+ b"cs" => Op::new("CS", f.operands.clone()),+ b"sc" => Op::new("SC", f.operands.clone()),+ _ => Op::new("SCN", f.operands.clone()),+ })+ .collect();+ block_ops.push(Op::new("q", vec![]));+ block_ops.push(Op::new("cm", tm.iter().map(|v| n(*v)).collect()));+ block_ops.extend(colour);+ block_ops.push(Op::new("w", vec![n(size * 0.06)]));+ for (x0, x1, y) in underlines {+ block_ops.push(Op::new("m", vec![n(x0), n(y)]));+ block_ops.push(Op::new("l", vec![n(x1), n(y)]));+ }+ block_ops.push(Op::new("S", vec![]));+ block_ops.push(Op::new("Q", vec![]));+ }+ block_ops.push(Op::new("Q", vec![]));+ block_ops.extend(after.ops().into_iter().filter(|op| !op.is("Tf") || after.font.is_some()));+ if split {+ block_ops.insert(0, Op::new("ET", vec![]));+ block_ops.push(Op::new("BT", vec![]));+ block_ops.push(Op::new("Tm", emit.tlm.iter().map(|v| n(*v)).collect()));+ }+ let at = if split { start } else { emit.bt_op };+ let new_data = splice(&pieces, &ops, |i| {+ let insert = if i == at { std::mem::take(&mut block_ops) } else { Vec::new() };+ (insert, !drop.contains(&i))+ });+ let contents = rewritten_contents(doc, &streams, new_data);+ if new_font {+ res.set(b"Font".to_vec(), Object::Dict(fonts_res));+ }+ let page_ref = p.obj;+ doc.update_dict(page_ref, |d| {+ d.set(b"Contents".to_vec(), contents);+ if new_font {+ d.set(b"Resources".to_vec(), Object::Dict(res));+ }+ })?;+ Ok(LineEdit { substituted })+}++/// The cover (when [`BlockStyle::cover`] asks for one) and visible rendering that start a+/// rewritten invisible paragraph, drawn in the space whose CTM is `ctm`. Nothing for visible text.+/// The paragraph's `q`/`Q` restores the rendering mode for the invisible text after it.+pub(crate) fn reveal_ops(block: &TextBlock, lines: &[TextLine], style: &BlockStyle, ctm: [f64; 6]) -> Result<Vec<Op>, EditError> {+ if !block.invisible {+ return Ok(Vec::new());+ }+ let n = pdfcraft_content::num;+ let mut ops = Vec::new();+ if let Some(colour) = style.cover {+ if colour.iter().any(|c| !c.is_finite() || !(0.0..=1.0).contains(c)) {+ return Err(EditError::Invalid("the cover colour must be RGB values from 0 to 1".into()));+ }+ let back = Matrix(ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be covered in".into()))?;+ ops.push(Op::new("q", vec![]));+ ops.push(Op::new("rg", colour.map(n).to_vec()));+ for rect in block.lines.iter().filter_map(|i| lines.get(*i)).map(|l| l.rect) {+ // Scanned ink reaches a little past the recognised box.+ let pad = ((rect[3] - rect[1]).abs() * 0.1).clamp(0.5, 2.0);+ let corners =+ [[rect[0] - pad, rect[1] - pad], [rect[2] + pad, rect[1] - pad], [rect[2] + pad, rect[3] + pad], [rect[0] - pad, rect[3] + pad]];+ for (i, [x, y]) in corners.into_iter().enumerate() {+ let (x, y) = back.apply(x, y);+ if !(x.is_finite() && y.is_finite()) {+ return Err(EditError::Invalid("the paragraph's area can't be covered".into()));+ }+ ops.push(Op::new(if i == 0 { "m" } else { "l" }, vec![n(x), n(y)]));+ }+ ops.push(Op::new("h", vec![]));+ }+ ops.push(Op::new("f", vec![]));+ ops.push(Op::new("Q", vec![]));+ }+ ops.push(Op::new("Tr", vec![Object::Int(0)]));+ Ok(ops)+}++/// Existing paragraph indexes, excluding streams owned by an added-content item.+pub(crate) fn selectable_blocks(+ doc: &Document,+ page: usize,+ excluded: &std::collections::BTreeSet<pdfcraft_cos::ObjRef>,+) -> Result<Vec<(usize, TextBlock)>, EditError> {+ let p = page_dict(doc, page)?;+ let streams = content_streams(doc, &p.dict)?;+ let lines = text_lines(doc, page)?;+ Ok(group_blocks(&lines)+ .into_iter()+ .enumerate()+ .filter(|(_, b)| {+ !b.lines+ .iter()+ .filter_map(|i| lines.get(*i))+ .any(|l| streams.get(l.stream).and_then(|(o, _)| o.as_ref()).is_some_and(|r| excluded.contains(&r)))+ })+ .collect())+}++/// The vertical advance per unit of font size of a font that writes vertically: `/DW2`'s w1+/// (default −1000, §9.7.4.3), or `None` for horizontal text. Per-glyph `/W2` entries are not+/// read. An encoding whose writing mode can't be read is an error, as in [`vertical_encoding`];+/// listing text treats it as horizontal and records the error (see [`Ts::unreadable`]).+pub(super) fn vertical_advance(doc: &Document, font: &Dict) -> Result<Option<f64>, EditError> {+ if !vertical_encoding(doc, font)? {+ return Ok(None);+ }+ let descendant = font.get(b"DescendantFonts").and_then(|d| doc.resolve(d).as_array().and_then(|a| a.first().cloned()));+ let w1 = descendant+ .and_then(|d| doc.resolve(&d).as_dict().and_then(|d| d.get(b"DW2").cloned()))+ .and_then(|a| doc.resolve(&a).as_array().and_then(|a| a.get(1).cloned()))+ .and_then(|w| doc.resolve(&w).as_f64())+ .filter(|w| w.is_finite())+ .unwrap_or(-1000.0);+ Ok(Some(w1 / 1000.0))+}++/// Detect vertical CMaps before moving horizontal text. A broken/cyclic embedded CMap is+/// refused rather than guessing which direction TJ advances its text matrix.+fn vertical_encoding(doc: &Document, font: &Dict) -> Result<bool, EditError> {+ if font.name(b"Subtype") != Some(b"Type0") {+ return Ok(false);+ }+ let mut next = font.get(b"Encoding").cloned();+ let mut seen = std::collections::BTreeSet::new();+ for _ in 0..8 {+ let Some(o) = next.take() else { return Ok(false) };+ if let Some(r) = o.as_ref()+ && !seen.insert(r)+ {+ return Err(EditError::Invalid("the text encoding is cyclic".into()));+ }+ match &*doc.resolve(&o) {+ Object::Name(n) => return Ok(n.ends_with(b"-V")),+ Object::Stream(stream) => {+ if let Some(mode) = stream.dict.get(b"WMode") {+ match mode.as_int() {+ Some(1) => return Ok(true),+ Some(0) => {}+ _ => return Err(EditError::Invalid("the text writing mode is invalid".into())),+ }+ }+ let bytes = stream+ .decoded_within(8 * 1024 * 1024)+ .map_err(|_| EditError::Invalid("the text encoding cannot be decoded within its size limit".into()))?;+ let ops = parse(&bytes).ops;+ if let Some(mode) = ops.iter().rev().find(|op| op.is("def") && op.name(0) == Some(b"WMode")) {+ return match mode.num(1) {+ Some(0.0) => Ok(false),+ Some(1.0) => Ok(true),+ _ => Err(EditError::Invalid("the text writing mode is invalid".into())),+ };+ }+ next = stream+ .dict+ .get(b"UseCMap")+ .cloned()+ .or_else(|| ops.iter().rev().find(|op| op.is("usecmap")).and_then(|op| op.operands.first().cloned()));+ }+ _ => return Err(EditError::Invalid("the text encoding is invalid".into())),+ }+ }+ Err(EditError::Invalid("the text encoding is nested too deeply".into()))+}++/// Translate paragraphs together without re-encoding glyphs, changing fonts or reflowing.+/// Numeric TJ offsets and text rise temporarily move each selected show operation, then+/// restore both advances and rise. The PDF reader advances the original glyph bytes itself:+/// no approximate font metrics are used to position following, unselected text (§9.4.4).+pub(crate) fn translate_blocks(doc: &mut Document, page: usize, indexes: &[usize], offset: [f64; 2]) -> Result<(), EditError> {+ if indexes.is_empty() {+ return Ok(());+ }+ let p = page_dict(doc, page)?;+ let streams = content_streams(doc, &p.dict)?;+ let lines = text_lines(doc, page)?;+ let blocks = group_blocks(&lines);+ let mut selected = std::collections::BTreeSet::new();+ for index in indexes {+ let b = blocks.get(*index).ok_or_else(|| EditError::Invalid("a selected paragraph no longer exists".into()))?;+ for line in &b.lines {+ let l = lines.get(*line).ok_or_else(|| EditError::Invalid("a selected text line no longer exists".into()))?;+ l.ensure_editable()?;+ selected.extend(l.ops.iter().copied());+ }+ }+ let res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let fonts = res.get(b"Font").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();+ let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());+ let ops = pieces.parse().ops;+ let shown = interpret(doc, &ops, &res, &mut HashMap::new(), &mut Carry::new(), None, None)?;+ let mut patches = HashMap::new();+ // Keep full precision: a tiny rounded text-space change can be magnified by a CTM,+ // and restoring rise/spacing must not alter following unselected text.+ let n = Object::Real;+ for s in shown.into_iter().filter(|s| selected.contains(&s.op)) {+ if !(0..=3).contains(&s.state.render_mode) {+ return Err(EditError::Invalid("text used as a clipping path cannot be moved in a group".into()));+ }+ let font = fonts+ .get(&s.font)+ .map(|f| doc.resolve(f))+ .and_then(|f| f.as_dict().cloned())+ .ok_or_else(|| EditError::Invalid("a selected paragraph has no font".into()))?;+ if vertical_encoding(doc, &font)? {+ return Err(EditError::Invalid("vertical text cannot be moved in a group".into()));+ }+ let inverse = s.tm.then(&s.state.ctm).invert().ok_or_else(|| EditError::Invalid("a selected paragraph has no area".into()))?;+ let [a, b, c, d, _, _] = inverse.0;+ let (dx, dy) = (a * offset[0] + c * offset[1], b * offset[0] + d * offset[1]);+ let denominator = s.state.size * s.state.scale;+ let shift = if dx == 0.0 {+ 0.0+ } else if denominator.abs() > 1e-12 {+ -1000.0 * dx / denominator+ } else {+ return Err(EditError::Invalid("a selected paragraph has no horizontal advance".into()));+ };+ let rise = s.state.rise + dy;+ if ![shift, rise, dx, dy].iter().all(|v| v.is_finite() && v.abs() <= 1e12) {+ return Err(EditError::Invalid("the paragraph move is too large".into()));+ }+ let original = ops.get(s.op).ok_or_else(|| EditError::Invalid("a selected text operation is missing".into()))?;+ let mut replacement = Vec::new();+ let show = if original.is("'") || original.is("\"") {+ if original.is("\"") {+ let spacing = original+ .operands+ .get(..2)+ .filter(|a| a.iter().all(|o| o.as_f64().is_some()))+ .ok_or_else(|| EditError::Invalid("a text operation has invalid spacing".into()))?;+ for (operator, operand) in ["Tw", "Tc"].into_iter().zip(spacing) {+ replacement.push(Op::new(operator, vec![operand.clone()]));+ }+ }+ replacement.push(Op::new("T*", vec![]));+ Op::new("Tj", vec![original.operands.last().cloned().ok_or_else(|| EditError::Invalid("a text operation has no string".into()))?])+ } else {+ original.clone()+ };+ if dy != 0.0 {+ replacement.push(Op::new("Ts", vec![n(rise)]));+ }+ if shift != 0.0 {+ replacement.push(Op::new("TJ", vec![Object::Array(vec![n(shift)])]));+ }+ replacement.push(show);+ if shift != 0.0 {+ replacement.push(Op::new("TJ", vec![Object::Array(vec![n(-shift)])]));+ }+ if dy != 0.0 {+ replacement.push(Op::new("Ts", vec![n(s.state.rise)]));+ }+ patches.insert(s.op, replacement);+ }+ if patches.len() != selected.len() {+ return Err(EditError::Invalid("a selected text operation cannot be moved".into()));+ }+ let data = splice(&pieces, &ops, |i| patches.remove(&i).map_or((Vec::new(), true), |v| (v, false)));+ let contents = rewritten_contents(doc, &streams, data);+ doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;+ Ok(())+}