PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
Refactor edit for strict Clippy checks
Dylan M. Taylorde73c35e174a
diff --git a/crates/edit/src/added/draw.rs b/crates/edit/src/added/draw.rsindex 0fc7aa510..61297bcf2 100644--- a/crates/edit/src/added/draw.rs+++ b/crates/edit/src/added/draw.rs@@ -2,7 +2,10 @@ use super::layout::{Piece, arabic_error, hebrew_error, is_arabic, is_hebrew, is_thai, latin_width, lines, norm, shaped_layout, text_rect, thai_error, wrapped,};use super::types::{AddedText, Align, Family};-use super::*;+use super::{+ Content, Dict, Document, EditError, GlyphError, GlyphOutline, HashMap, HashSet, ObjRef, Object, PdfString, ShapedCluster, ShapedScript, Stream,+ literal, matrix_number, n, shaped_glyph, win_ansi,+};fn font_name(base: &str) -> String {format!("PCF{}", base.replace('-', ""))diff --git a/crates/edit/src/added/layout.rs b/crates/edit/src/added/layout.rsindex 0e971b92c..67d80be40 100644--- a/crates/edit/src/added/layout.rs+++ b/crates/edit/src/added/layout.rs@@ -1,5 +1,8 @@use super::types::{AddedImage, AddedText};-use super::*;+use super::{+ Content, Document, EditError, GlyphError, Level, ObjRef, Object, ParagraphBidiInfo, ShapedCluster, ShapedScript, shape_arabic, shape_hebrew,+ shape_thai,+};pub(super) fn nums(doc: &Document, o: Option<&Object>) -> Vec<f64> {o.map(|o| doc.resolve(o)).and_then(|a| a.as_array().map(|a| a.iter().filter_map(Object::as_f64).collect())).unwrap_or_default()diff --git a/crates/edit/src/added/store.rs b/crates/edit/src/added/store.rsindex b89d42900..5ce5e15d1 100644--- a/crates/edit/src/added/store.rs+++ b/crates/edit/src/added/store.rs@@ -1,7 +1,7 @@use super::draw::{draw, params};use super::layout::{first_undrawable, is_thai, nums, shaped_arabic, thai_error};use super::types::{Added, AddedImage, AddedText, Align, CHAR_SPACING_LIMIT, Family, MarkerScan, TAG};-use super::*;+use super::{Content, Dict, Document, EditError, GlyphError, MarkKind, ObjRef, Object, Stream, check, contents, page_list, place_tagged};fn parse(doc: &Document, d: &Dict) -> Option<Content> {let r = nums(doc, d.get(b"Rect"));diff --git a/crates/edit/src/added/types.rs b/crates/edit/src/added/types.rsindex 0a9f92f92..28b61d586 100644--- a/crates/edit/src/added/types.rs+++ b/crates/edit/src/added/types.rs@@ -1,5 +1,5 @@use super::layout::norm;-use super::*;+use super::{Content, MarkKind, ObjRef, Std14};pub(super) const TAG: &str = "Added";diff --git a/crates/edit/src/apply.rs b/crates/edit/src/apply.rsindex 1461dc78e..427f51f94 100644--- a/crates/edit/src/apply.rs+++ b/crates/edit/src/apply.rs@@ -5,7 +5,7 @@ use super::place::{END, Isolation, add_page_resources, add_resources, begin, check, check_on_top, contents, free_font_name, isolation, page_fonts, page_list, place,place_inside_wrapper, stream_tag, text_op, undrawable, wrapper_role,};-use super::*;+use super::{Document, EditError, Object, added, helvetica_width};/// Add a header and footer to `pages` (0-based). With `replace`, existing headers and footers on/// those pages are removed first (Acrobat's Replace Existing).diff --git a/crates/edit/src/marks.rs b/crates/edit/src/marks.rsindex 507e2afa8..00c53ec27 100644--- a/crates/edit/src/marks.rs+++ b/crates/edit/src/marks.rs@@ -1,4 +1,4 @@-use super::*;+use super::{Document, EditError, Object, Rgb, added};/// The kinds of page marks.#[derive(Clone, Copy, Debug, PartialEq, Eq)]diff --git a/crates/edit/src/place.rs b/crates/edit/src/place.rsindex b6d50a646..2f2c24c86 100644--- a/crates/edit/src/place.rs+++ b/crates/edit/src/place.rs@@ -1,5 +1,5 @@use super::marks::{MarkKind, matrix_number, n};-use super::*;+use super::{Dict, Document, EditError, ObjRef, Object, Stream, literal, win_ansi};pub(crate) fn page_list(doc: &Document) -> Vec<pdfcraft_model::Page> {pdfcraft_model::pages(doc)diff --git a/crates/edit/src/tests.rs b/crates/edit/src/tests.rsindex 0f8adc651..7c78d31fc 100644--- a/crates/edit/src/tests.rs+++ b/crates/edit/src/tests.rs@@ -6664,93 +6664,136 @@ fn actual_text_pairs_past_the_marked_content_cap() {}}-/// #2992: the colour a page is painted with before anything else is its background, for exports-/// that keep a page colour. Edit a PDF ▸ Background's fill is found under the text it goes-/// behind; a page that paints anything else first, a fill that doesn't cover the page, a-/// translucent or clipped one, or a colour that isn't plain gray, RGB or CMYK has none.-#[test]-fn a_page_painted_first_with_a_full_page_fill_has_that_background() {- let mut doc = fixture();- assert_eq!(page_background(&doc, 0).unwrap(), None, "text first");- add_background(&mut doc, &[0, 1], &Background { color: [0.0, 0.5, 0.5], opacity: 1.0, ..Background::default() }, false).unwrap();- let doc = reopen(&doc);- let teal = page_background(&doc, 0).unwrap().expect("Background's fill");- assert!(teal.iter().zip([0.0, 0.5, 0.5]).all(|(a, b)| (a - b).abs() < 1e-6), "{teal:?}");- assert!(page_background(&doc, 1).unwrap().is_some(), "on a turned page too");- assert_eq!(page_background(&doc, 2).unwrap(), None, "a page with no content");- assert!(page_background(&doc, 9).is_err());-- let page = |content: &str, resources: &str| {- let objs: Vec<String> = vec![- "<< /Type /Catalog /Pages 2 0 R >>".into(),- "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into(),- format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 600 800] /CropBox [0 0 500 700] /Contents 4 0 R /Resources << {resources} >> >>"),- format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()),- ];- let mut out = b"%PDF-1.7\n".to_vec();- let mut offs = Vec::new();- for (i, o) in objs.iter().enumerate() {- offs.push(out.len());- out.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());- }- let x = out.len();- out.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");- for o in offs {- out.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());- }- out.extend_from_slice(format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{x}\n%%EOF\n").as_bytes());- page_background(&Document::open(Arc::new(out)).unwrap(), 0).unwrap()- };- let gs = "/ExtGState << /Half << /ca 0.5 >> /Mul << /BM /Multiply >> /Full << /ca 1 /SMask /None >> >>";- assert_eq!(page("1 g 0 0 600 800 re f", ""), Some([1.0; 3]), "a producer's white page fill");- assert_eq!(page("0 0 1 0 k 0 0 500 700 re f", ""), Some([1.0, 1.0, 0.0]), "CMYK, covering the crop box");- assert_eq!(page("/DeviceRGB cs 1 0 0 sc 0 0 500 700 re f", ""), Some([1.0, 0.0, 0.0]), "cs and sc");- assert_eq!(page("/Full gs q 2 0 0 2 0 0 cm 0 1 0 rg 0 0 300 400 re f Q", gs), Some([0.0, 1.0, 0.0]), "under a cm");- assert_eq!(page("1 0 0 rg 0 0 300 800 re f", ""), None, "half the page");- assert_eq!(page("1 0 0 rg 0 0 300 800 re 300 0 300 800 re f", ""), None, "two halves are not one covering rectangle");- assert_eq!(page("1 0 0 rg 0 0 300 800 re 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "one of the rectangles covers it");+fn page_background_from_content(content: &str, resources: &str) -> Option<[f64; 3]> {+ let objects = [+ "<< /Type /Catalog /Pages 2 0 R >>".to_string(),+ "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(),+ format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 600 800] /CropBox [0 0 500 700] /Contents 4 0 R /Resources << {resources} >> >>"),+ format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()),+ ];+ let mut bytes = b"%PDF-1.7\n".to_vec();+ let mut offsets = Vec::new();+ for (index, object) in objects.iter().enumerate() {+ offsets.push(bytes.len());+ bytes.extend_from_slice(format!("{} 0 obj\n{object}\nendobj\n", index + 1).as_bytes());+ }+ let xref_offset = bytes.len();+ bytes.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");+ for offset in offsets {+ bytes.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());+ }+ bytes.extend_from_slice(format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());+ page_background(&Document::open(Arc::new(bytes)).unwrap(), 0).unwrap()+}++fn assert_page_background_fill_cases(gs: &str) {+ assert_eq!(page_background_from_content("1 g 0 0 600 800 re f", ""), Some([1.0; 3]), "a producer's white page fill");+ assert_eq!(page_background_from_content("0 0 1 0 k 0 0 500 700 re f", ""), Some([1.0, 1.0, 0.0]), "CMYK, covering the crop box");+ assert_eq!(page_background_from_content("/DeviceRGB cs 1 0 0 sc 0 0 500 700 re f", ""), Some([1.0, 0.0, 0.0]), "cs and sc");+ assert_eq!(page_background_from_content("/Full gs q 2 0 0 2 0 0 cm 0 1 0 rg 0 0 300 400 re f Q", gs), Some([0.0, 1.0, 0.0]), "under a cm");+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 300 800 re f", ""), None, "half the page");+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 300 800 re 300 0 300 800 re f", ""), None, "two halves are not one covering rectangle");+ assert_eq!(+ page_background_from_content("1 0 0 rg 0 0 300 800 re 0 0 600 800 re f", ""),+ Some([1.0, 0.0, 0.0]),+ "one of the rectangles covers it"+ );// #2994 review: a second rectangle that cuts a hole: any one under even-odd, one wound the// other way under nonzero.- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f*", ""), None, "even-odd hole");- assert_eq!(page("1 0 0 rg 0 0 600 800 re 300 100 -200 200 re f", ""), None, "nonzero, reversed inner rectangle");- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f", ""), Some([1.0, 0.0, 0.0]), "nonzero, same winding: no hole");- assert_eq!(page("1 0 0 rg q -1 0 0 1 600 0 cm 0 0 600 800 re Q 100 100 200 200 re f", ""), None, "reversed by a mirroring cm");- assert_eq!(page("/Half gs 1 0 0 rg 0 0 600 800 re f", gs), None, "translucent");- assert_eq!(page("/Mul gs 1 0 0 rg 0 0 600 800 re f", gs), None, "blended");- assert_eq!(page("0 0 100 100 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "clipped to a corner");- assert_eq!(page("0 0 600 800 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "a page-sized clip");- assert_eq!(page("/Pattern cs /P1 scn 0 0 600 800 re f", ""), None, "a pattern");- assert_eq!(page("BT ET 0 0 600 800 re S 1 0 0 rg 0 0 600 800 re f", ""), None, "a stroke first");- assert_eq!(page("0 0 m 600 0 l 600 800 l 0 800 l h f", ""), None, "a path that isn't a rectangle");- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 m 200 100 l 200 200 l h f*", ""), None, "a page fill with a hole cut in it");+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f*", ""), None, "even-odd hole");+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 600 800 re 300 100 -200 200 re f", ""), None, "nonzero, reversed inner rectangle");+ assert_eq!(+ page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f", ""),+ Some([1.0, 0.0, 0.0]),+ "nonzero, same winding: no hole"+ );+ assert_eq!(+ page_background_from_content("1 0 0 rg q -1 0 0 1 600 0 cm 0 0 600 800 re Q 100 100 200 200 re f", ""),+ None,+ "reversed by a mirroring cm"+ );+ assert_eq!(page_background_from_content("/Half gs 1 0 0 rg 0 0 600 800 re f", gs), None, "translucent");+ assert_eq!(page_background_from_content("/Mul gs 1 0 0 rg 0 0 600 800 re f", gs), None, "blended");+ assert_eq!(page_background_from_content("0 0 100 100 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "clipped to a corner");+ assert_eq!(page_background_from_content("0 0 600 800 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "a page-sized clip");+ assert_eq!(page_background_from_content("/Pattern cs /P1 scn 0 0 600 800 re f", ""), None, "a pattern");+ assert_eq!(page_background_from_content("BT ET 0 0 600 800 re S 1 0 0 rg 0 0 600 800 re f", ""), None, "a stroke first");+ assert_eq!(page_background_from_content("0 0 m 600 0 l 600 800 l 0 800 l h f", ""), None, "a path that isn't a rectangle");+ assert_eq!(+ page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 m 200 100 l 200 200 l h f*", ""),+ None,+ "a page fill with a hole cut in it"+ );+}++fn assert_page_background_transform_and_clip_cases() {// #2994 review: a rectangle turned 45° about the crop box's centre covers it only if the crop// box's corners are inside it; its bounding box covering the crop box isn't enough. This one// reaches 500 from the centre along each axis (its box covers the 500 × 700 crop box) but// 354 along the diagonals, short of the corners. One reaching 707 covers them.let turned = "0.70710678 0.70710678 -0.70710678 0.70710678 250 350 cm";- assert_eq!(page(&format!("1 0 0 rg {turned} -353.553 -353.553 707.107 707.107 re f"), ""), None, "a turned fill short of the corners");- assert_eq!(page(&format!("1 0 0 rg {turned} -500 -500 1000 1000 re f"), ""), Some([1.0, 0.0, 0.0]), "a turned fill over them");+ assert_eq!(+ page_background_from_content(&format!("1 0 0 rg {turned} -353.553 -353.553 707.107 707.107 re f"), ""),+ None,+ "a turned fill short of the corners"+ );+ assert_eq!(+ page_background_from_content(&format!("1 0 0 rg {turned} -500 -500 1000 1000 re f"), ""),+ Some([1.0, 0.0, 0.0]),+ "a turned fill over them"+ );// The same for a clip.- assert_eq!(page(&format!("{turned} -353.553 -353.553 707.107 707.107 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""), None, "a turned clip");assert_eq!(- page(&format!("{turned} -500 -500 1000 1000 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),+ page_background_from_content(&format!("{turned} -353.553 -353.553 707.107 707.107 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),+ None,+ "a turned clip"+ );+ assert_eq!(+ page_background_from_content(&format!("{turned} -500 -500 1000 1000 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),Some([1.0, 0.0, 0.0]),"a turned clip over the corners");// Clips add up: two that each cover the page leave it covered, one that doesn't among them// doesn't.- assert_eq!(page("0 0 600 800 re W n 0 0 550 750 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "two covering clips");- assert_eq!(page("0 0 600 800 re W n 0 0 300 750 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "the second clip doesn't cover");+ assert_eq!(+ page_background_from_content("0 0 600 800 re W n 0 0 550 750 re W n 1 0 0 rg 0 0 600 800 re f", ""),+ Some([1.0, 0.0, 0.0]),+ "two covering clips"+ );+ assert_eq!(+ page_background_from_content("0 0 600 800 re W n 0 0 300 750 re W n 1 0 0 rg 0 0 600 800 re f", ""),+ None,+ "the second clip doesn't cover"+ );// Past 64 clipping rectangles the clip counts as unknown.let clips = "0 0 600 800 re W n ".repeat(65);- assert_eq!(page(&format!("{clips}1 0 0 rg 0 0 600 800 re f"), ""), None, "too many clips to follow");+ assert_eq!(page_background_from_content(&format!("{clips}1 0 0 rg 0 0 600 800 re f"), ""), None, "too many clips to follow");// A rectangle drawn the other way round (negative width) covers the page all the same.- assert_eq!(page("1 0 0 rg 600 0 -600 800 re f", ""), Some([1.0, 0.0, 0.0]), "drawn clockwise");+ assert_eq!(page_background_from_content("1 0 0 rg 600 0 -600 800 re f", ""), Some([1.0, 0.0, 0.0]), "drawn clockwise");// The crop box counts as covered within half a percent of its size (2.5 × 3.5 here), the// edge of that included.- assert_eq!(page("1 0 0 rg 2 3 496 694 re f", ""), Some([1.0, 0.0, 0.0]), "within the tolerance");- assert_eq!(page("1 0 0 rg 2.5 3.5 495 693 re f", ""), Some([1.0, 0.0, 0.0]), "on the tolerance's edge");- assert_eq!(page("1 0 0 rg 3 4 494 692 re f", ""), None, "past the tolerance");+ assert_eq!(page_background_from_content("1 0 0 rg 2 3 496 694 re f", ""), Some([1.0, 0.0, 0.0]), "within the tolerance");+ assert_eq!(page_background_from_content("1 0 0 rg 2.5 3.5 495 693 re f", ""), Some([1.0, 0.0, 0.0]), "on the tolerance's edge");+ assert_eq!(page_background_from_content("1 0 0 rg 3 4 494 692 re f", ""), None, "past the tolerance");+}++/// #2992: page background detection follows the first full-page fill under text and ignores+/// partial, translucent, clipped, or unsupported fills.+#[test]+fn a_page_painted_first_with_a_full_page_fill_has_that_background() {+ let gs = "/ExtGState << /Half << /ca 0.5 >> /Mul << /BM /Multiply >> /Full << /ca 1 /SMask /None >> >>";+ let mut doc = fixture();+ assert_eq!(page_background(&doc, 0).unwrap(), None, "text first");+ add_background(&mut doc, &[0, 1], &Background { color: [0.0, 0.5, 0.5], opacity: 1.0, ..Background::default() }, false).unwrap();+ let doc = reopen(&doc);+ let teal = page_background(&doc, 0).unwrap().expect("Background's fill");+ assert!(teal.iter().zip([0.0, 0.5, 0.5]).all(|(a, b)| (a - b).abs() < 1e-6), "{teal:?}");+ assert!(page_background(&doc, 1).unwrap().is_some(), "on a turned page too");+ assert_eq!(page_background(&doc, 2).unwrap(), None, "a page with no content");+ assert!(page_background(&doc, 9).is_err());++ assert_page_background_fill_cases(gs);+ assert_page_background_transform_and_clip_cases();}#[test]diff --git a/crates/edit/src/text/blocks.rs b/crates/edit/src/text/blocks.rsindex 8d3d224da..615e7699a 100644--- a/crates/edit/src/text/blocks.rs+++ b/crates/edit/src/text/blocks.rs@@ -1,7 +1,7 @@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::*;+use super::{Document, EditError, HashMap, Object, Op, Pieces, TextLine, group_blocks, regions};/// An editable text region: adjacent runs on visual rows, followed by aligned rows./// A region may contain several source fonts, sizes, colours and weights.diff --git a/crates/edit/src/text/editor.rs b/crates/edit/src/text/editor.rsindex b2bd2b9f9..f7aa1f47b 100644--- a/crates/edit/src/text/editor.rs+++ b/crates/edit/src/text/editor.rs@@ -2,7 +2,7 @@ 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::*;+use super::{DecodeBudget, Document, EditError, Metrics, Object, TextLine, TextSession};/// 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.diff --git a/crates/edit/src/text/fallback.rs b/crates/edit/src/text/fallback.rsindex 0c19a6680..b8f45a221 100644--- a/crates/edit/src/text/fallback.rs+++ b/crates/edit/src/text/fallback.rs@@ -1,6 +1,8 @@use super::interp::Ts;use super::lines::page_dict;-use super::*;+use super::{+ CraftFont, Dict, Document, EditError, GlyphError, HashMap, Metrics, Object, Op, PdfString, Stream, TextLine, japanese_glyph_from, parse,+};/// 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>)>>>;diff --git a/crates/edit/src/text/interp.rs b/crates/edit/src/text/interp.rsindex ca0d63cef..e4248aede 100644--- a/crates/edit/src/text/interp.rs+++ b/crates/edit/src/text/interp.rs@@ -1,6 +1,6 @@use super::fallback::is_type3_fallback;use super::rewrite::vertical_advance;-use super::*;+use super::{Dict, Document, EditError, HashMap, Matrix, Metrics, Object, Op, Rc};/// Text and graphics state captured for rewriting.#[derive(Clone, Debug, PartialEq)]@@ -472,6 +472,280 @@ 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);+#[derive(Default)]+struct MarkedContent {+ regions: Vec<Option<usize>>,+ layers: Vec<Option<Vec<u8>>>,+ actual_text: Vec<Option<(usize, usize, String)>>,+}++impl MarkedContent {+ fn begin(&mut self, doc: &Document, op: &Op, index: usize, logical_text: Option<&Dict>, shown_count: usize) {+ // 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"));+ self.regions.push(if region { Some(index) } else { self.regions.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());+ self.layers+ .push(layer.then(|| op.operands.get(1).and_then(Object::as_name).map_or_else(|| format!("@{index}").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(name)) => properties.get(name).and_then(|object| doc.dict(object)),+ other => other.and_then(Object::as_dict).cloned(),+ });+ let logical = list.as_ref().and_then(|dict| dict.get(b"ActualText")).and_then(|value| match value {+ Object::String(value) if value.bytes.len() <= 4_000_000 => Some(value.to_text()),+ _ => None,+ });+ self.actual_text.push(logical.map(|text| (shown_count, index, text)));+ }++ fn end(&mut self, index: usize, shown: &mut Vec<Shown>) {+ self.regions.pop();+ self.layers.pop();+ if let Some(Some((start, open, logical))) = self.actual_text.pop() {+ let tail = shown.split_off(start.min(shown.len()));+ let mut items = tail.into_iter();+ if let Some(mut first) = items.next() {+ for item in items {+ first.glyph_count = first.glyph_count.saturating_add(item.glyph_count);+ first.extra_ops.push(item.op);+ first.extra_ops.extend(item.extra_ops);+ first.rect = [+ first.rect[0].min(item.rect[0]),+ first.rect[1].min(item.rect[1]),+ first.rect[2].max(item.rect[2]),+ first.rect[3].max(item.rect[3]),+ ];+ first.frame = union(first.frame, item.frame);+ first.ink.extend(item.ink);+ }+ first.extra_ops.extend([open, index]);+ // Only right-to-left ActualText is already in typing order and must stay out of+ // bidi recovery. Word and Chrome also wrap Latin ligatures mid-word.+ 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);+ shown.push(first);+ }+ }+ }+}++struct TextRunState<'a> {+ ts: &'a mut Ts,+ tm: &'a mut Matrix,+ tlm: &'a mut Matrix,+ at_bt: &'a (usize, Ts),+ bt: usize,+ marked: &'a MarkedContent,+ carry: &'a mut Carry,+ out: &'a mut Vec<Shown>,+}++fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), EditError> {+ let ts = &mut *state.ts;+ let tm = &mut *state.tm;+ let tlm = &mut *state.tlm;+ let at_bt = state.at_bt;+ let bt = state.bt;+ let marked = state.marked;+ let carry = &mut *state.carry;+ let out = &mut *state.out;+ 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 { return Ok(()) };+ // 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())) {+ return Ok(());+ }+ 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: *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.regions.last().copied().flatten(),+ paint: Paint { layers: marked.layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },+ logical_order: false,+ actual_text: false,+ });+ Ok(())+}+pub(super) fn interpret(doc: &Document,ops: &[Op],@@ -490,66 +764,17 @@ pub(super) fn interpret(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();+ let mut marked =+ MarkedContent { regions: std::mem::take(&mut carry.marked), layers: std::mem::take(&mut carry.layers), ..MarkedContent::default() };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)));+ marked.begin(doc, op, i, logical_text, out.len());}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);- }- }+ marked.end(i, &mut out);}b"q" => stack.push(ts.clone()),b"Q" => {@@ -650,207 +875,16 @@ pub(super) fn interpret(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,- });+ let mut state = TextRunState { ts: &mut ts, tm: &mut tm, tlm: &mut tlm, at_bt: &at_bt, bt, marked: &marked, carry, out: &mut out };+ show_text(op, i, &mut state)?;}_ => {}}}carry.ts = ts;carry.stack = stack;- carry.marked = marked;- carry.layers = layers;+ carry.marked = marked.regions;+ carry.layers = marked.layers;positioned_tracking(&mut out);Ok(out)}diff --git a/crates/edit/src/text/lines.rs b/crates/edit/src/text/lines.rsindex 7543adeb3..c48522984 100644--- a/crates/edit/src/text/lines.rs+++ b/crates/edit/src/text/lines.rs@@ -1,6 +1,6 @@use super::fallback::{same_font, same_paint};use super::interp::{Carry, Origin, Pen, Shown, TextState, Ts, direction, interpret, to_frame, union};-use super::*;+use super::{DecodeBudget, Dict, Document, EditError, HashMap, Matrix, Object, Op, Pieces, Stream, TextLine, parse, serialize_ops};impl TextLine {/// The baseline's height in user space.diff --git a/crates/edit/src/text/rewrite.rs b/crates/edit/src/text/rewrite.rsindex dd58c7289..513077a02 100644--- a/crates/edit/src/text/rewrite.rs+++ b/crates/edit/src/text/rewrite.rs@@ -1,11 +1,14 @@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,+ Encoder, MAX_TYPE3_GLYPHS, Type3Fallback, 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::interp::{Carry, Origin, TextState, interpret};use super::lines::{content_streams, page_dict, rewritten_contents, splice, text_lines};-use super::*;+use super::{+ Dict, Document, EditError, HashMap, Matrix, Metrics, Object, Op, PdfString, Pieces, TextLine, TextSession, group_blocks, is_centred, parse,+ rewrite_styled_block,+};/// What replacing a line did.#[derive(Clone, Debug, PartialEq)]@@ -206,6 +209,532 @@ pub(crate) fn rewrite_block_with_limit(TextSession::open(doc, page, block)?.commit_with_limit(doc, text, style, max_glyphs)}+struct RewriteDispatch {+ upright: bool,+ use_styled_path: bool,+}++fn choose_rewrite_path(+ doc: &Document,+ fonts: &Dict,+ block: &TextBlock,+ members: &[&TextLine],+ first: &TextLine,+ text: Option<&str>,+ style: &BlockStyle,+) -> Result<RewriteDispatch, EditError> {+ let registered_face = fonts.iter().any(|(name, _)| name.starts_with(b"PCFull"));+ // Hebrew is written back in drawing order by the single-style path. Styled regions do not+ // reorder right-to-left runs.+ let hebrew = text.unwrap_or(&block.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(),+ ));+ }+ // Turned text is rewritten in its own text space by the single-style path. Styled layout uses+ // page x-coordinates and cannot safely apply those operations to rotated runs.+ 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);+ let has_special_text = text.is_some_and(|draft| {+ draft.contains(['\n', '\r'])+ || pdfcraft_fonts::source_shaping::required(draft)+ || !pdfcraft_fonts::embedding::matching_faces(&block.base_font).is_empty()+ });+ let has_multiple_runs = block.rows.iter().any(|row| row.len() > 1)+ || members.iter().any(|line| line.font != first.font || line.size != first.size || line.color != first.color);+ let source_requires_styled_path =+ has_special_text || registered_face || text.is_some_and(|draft| source_program_completes(doc, fonts, first, draft)) || has_multiple_runs;+ let explicit_styled_text = !style.ranges.is_empty() || style.resource.is_some();+ Ok(RewriteDispatch {+ upright,+ use_styled_path: upright+ && !hebrew+ && !visual_indic+ && (explicit_styled_text || (source_requires_styled_path && style.family.is_none() && style.bold.is_none())),+ })+}++/// The paragraph's text for writing back: 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.+fn paragraph_text(text: &str) -> String {+ text.replace("\r\n", "\n")+ .chars()+ .map(|c| match c {+ '\r' => '\n',+ c if c != '\n' && paragraph_separator(c) => ' ',+ c => c,+ })+ .collect()+}++/// Where a paragraph sits on its page, for choosing the width it is laid out in.+struct ParaGeometry {+ rect: [f64; 4],+ frame: [f64; 4],+ crop: [f64; 4],+ upright: bool,+ /// The text-to-user scale.+ k: f64,+ /// The size in text space.+ size: f64,+ /// The requested horizontal move, in points.+ dx: f64,+ single_line: bool,+ anchored_right: bool,+ centred: bool,+}++impl ParaGeometry {+ /// 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.+ fn width(&self, requested: Option<f64>) -> Result<f64, EditError> {+ let [left, _, right, _] = self.rect;+ let own = (right - left).max(self.size * self.k);+ let width = match requested {+ // 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((self.size * self.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 !self.upright => (self.frame[2] - self.frame[0]).max(self.size * self.k),+ None if self.anchored_right => own.max(right + self.dx - (self.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 self.single_line && !self.centred => own.max(self.crop[2] - 36.0 - (left + self.dx)),+ None => own,+ };+ if width.is_finite() { Ok(width) } else { Err(EditError::Invalid("the paragraph's width must be a number".into())) }+ }+}++/// How far a baseline starting at `origin` and running along `direction` goes before it is 36 pt+/// from the page edge `low` or `high`.+fn margin_reach(origin: f64, direction: f64, low: f64, high: f64) -> f64 {+ if direction > 1e-6 {+ (high - 36.0 - origin) / direction+ } else if direction < -1e-6 {+ (low + 36.0 - origin) / direction+ } else {+ f64::INFINITY+ }+}++/// A turned single line grows to fit, up to where its baseline reaches the page's margin.+fn turned_line_width(first: &TextLine, crop: [f64; 4], offset: [f64; 2], width: f64, text: &str, advance: &Advance<'_>) -> f64 {+ let (x0, y0) = (first.origin.x + offset[0], first.origin.baseline + offset[1]);+ let (ux, uy) = first.direction();+ let tx = margin_reach(x0, ux, crop[0], crop[2]);+ let ty = margin_reach(y0, uy, crop[1], crop[3]);+ let cap = width.max(tx.min(ty)).min(14_400.0);+ text.split('\n').map(|line| advance.of(line)).fold(width, f64::max).min(cap)+}++/// The widths of the paragraph's text in the font it will be written in, in user space.+struct Advance<'a> {+ /// The source font, when its glyphs are reused.+ source: Option<&'a Metrics>,+ type3: Option<&'a Type3Fallback>,+ family: crate::added::Family,+ bold: bool,+ italic: bool,+ size: f64,+ space: f64,+ char_spacing: f64,+ word_spacing: f64,+ scale: f64,+ k: f64,+}++impl Advance<'_> {+ fn of(&self, s: &str) -> f64 {+ let extra = s.chars().count() as f64 * self.char_spacing;+ let t = match (self.source, self.type3) {+ (Some(m), _) => {+ let visual_s = if m.visual_order { crate::indic::to_visual(s) } else { s.to_owned() };+ source_width(m, &visual_s, self.size, self.space, self.char_spacing, self.word_spacing)+ }+ (None, Some(fallback)) => {+ // 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 * self.size).sum::<f64>() + extra+ }+ (None, None) => self.family.std14(self.bold, self.italic).text_width(s, self.size) + extra,+ };+ t * self.scale * self.k+ }+}++/// The font a rewritten paragraph is shown in, and how its text is encoded.+struct FontChoice {+ show_font: String,+ encode: Encoder,+ /// The stand-in face to tell the caller about.+ substituted: Option<String>,+}++/// What [`choose_font`] needs to know about the paragraph.+struct FontInputs<'a> {+ /// The source font, when its glyphs are reused.+ source: Option<&'a Metrics>,+ type3: Option<&'a Type3Fallback>,+ font_name: &'a str,+ flat: &'a str,+ source_base_font: &'a str,+ family: crate::added::Family,+ bold: bool,+ italic: bool,+ family_requested: bool,+}++fn choose_font(inputs: &FontInputs<'_>, fonts_res: &mut Dict) -> Result<FontChoice, EditError> {+ if let Some(m) = inputs.source.cloned() {+ let name = inputs.font_name.to_owned();+ return Ok(FontChoice {+ show_font: name.clone(),+ encode: Box::new(move |s: &str| m.encode(s).map(|bytes| vec![(name.clone(), bytes)])),+ substituted: None,+ });+ }+ if let Some(fallback) = inputs.type3.cloned() {+ let substituted = Some(format!("{} Type3", fallback.family));+ let first = fallback.names.first().cloned().ok_or_else(no_japanese_font)?;+ return Ok(FontChoice { show_font: first, encode: Box::new(move |s: &str| type3_encode(&fallback, s)), substituted });+ }+ let flat = inputs.flat;+ 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 = inputs.family.base_font(inputs.bold, inputs.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", inputs.source_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));+ let substituted = (!inputs.family_requested).then(|| base.to_string());+ let shown = name.clone();+ Ok(FontChoice { show_font: name, encode: Box::new(move |s: &str| Some(vec![(shown.clone(), pdfcraft_fonts::win_ansi(s))])), substituted })+}++/// The paragraph's move in the space it is drawn in: the move is in page space, so it is taken+/// back through the CTM's linear part. Checked before the fallback fonts are written: a refused+/// paragraph leaves the document as it was.+fn drawn_movement(ctm: [f64; 6], dx: f64, dy: f64) -> Result<Option<(f64, f64)>, EditError> {+ if dx == 0.0 && dy == 0.0 {+ return Ok(None);+ }+ let back = Matrix([ctm[0], ctm[1], ctm[2], ctm[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()))?;+ Ok(Some(back.apply(dx, dy)))+}++/// The paragraph's first text matrix, taken from where its text starts to where it is written.+fn emit_text_matrix(first: &Origin, emit: &Origin) -> Result<[f64; 6], EditError> {+ if first.ctm == emit.ctm {+ return Ok(first.tm);+ }+ let emit_inv = Matrix(emit.ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph has a singular transform".into()))?;+ Ok(Matrix(first.tm).then(&Matrix(first.ctm)).then(&emit_inv).0)+}++/// Line spacing in text space: the paragraph's own (scaled with the size), or 1.2 × the size.+struct LeadScale {+ k: f64,+ size: f64,+ old_size: f64,+ leading: f64,+}++fn line_lead(block: &TextBlock, lines: &[TextLine], style: &BlockStyle, scale: &LeadScale) -> f64 {+ if let Some(m) = style.line_spacing {+ return scale.size * m.clamp(0.5, 5.0);+ }+ // From the first two rows (a row may hold several runs).+ let rows = block.rows.first().zip(block.rows.get(1)).and_then(|(upper, lower)| upper.first().zip(lower.first()));+ if let Some((upper, lower)) = rows.and_then(|(upper, lower)| lines.get(*upper).zip(lines.get(*lower))) {+ return (upper.frame_origin().1 - lower.frame_origin().1) / scale.k * scale.size / scale.old_size;+ }+ if scale.leading > 0.0 { scale.leading } else { scale.size * 1.2 }+}++/// The stroking twin of a fill colour operator.+fn stroke_twin(fill: &Op) -> Op {+ let name = match fill.op.as_slice() {+ b"g" => "G",+ b"rg" => "RG",+ b"k" => "K",+ b"cs" => "CS",+ b"sc" => "SC",+ _ => "SCN",+ };+ Op::new(name, fill.operands.clone())+}++/// Underlines in text space (the paragraph's text matrix), in its fill colour.+fn underline_ops(fill: &[Op], tm: &[f64; 6], size: f64, underlines: &[(f64, f64, f64)]) -> Vec<Op> {+ let n = pdfcraft_content::num;+ let mut ops = vec![Op::new("q", vec![]), Op::new("cm", tm.iter().map(|v| n(*v)).collect())];+ ops.extend(fill.iter().map(stroke_twin));+ ops.push(Op::new("w", vec![n(size * 0.06)]));+ for (x0, x1, y) in underlines {+ ops.push(Op::new("m", vec![n(*x0), n(*y)]));+ ops.push(Op::new("l", vec![n(*x1), n(*y)]));+ }+ ops.push(Op::new("S", vec![]));+ ops.push(Op::new("Q", vec![]));+ ops+}++/// Alignment: each line's offset from the left edge.+struct Alignment {+ align: Option<crate::added::Align>,+ width: f64,+ k: f64,+ anchored_right: bool,+ right_edge: f64,+ rtl: bool,+}++impl Alignment {+ /// `visible` is the width the line is aligned on, in user space; the offset is in text space.+ fn offset(&self, visible: f64) -> f64 {+ let free = (self.width - visible).max(0.0) / self.k;+ match self.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 self.anchored_right => (self.right_edge - visible) / self.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 self.rtl => free,+ _ => 0.0,+ }+ }+}++/// Everything the wrapped lines of one paragraph are written with.+struct LineWriter<'a> {+ advance: &'a Advance<'a>,+ alignment: Alignment,+ encode: &'a Encoder,+ source: Option<&'a Metrics>,+ justify: bool,+ /// Whether `Tw` reaches every shown space.+ word_spacing_reaches_spaces: bool,+ width: f64,+ scale: f64,+ k: f64,+ size: f64,+ space: f64,+ char_spacing: f64,+ lead: f64,+}++/// What carries over from one line to the next.+struct LineCursor {+ x: f64,+ tw_set: f64,+ shown_font: String,+}++impl LineWriter<'_> {+ /// Justify: each line but the last fills the width. A stretched 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. Nothing to stretch over, or a paragraph drawn at `0 Tz`, isn't+ /// justified.+ fn stretch(&self, body: &str, last: bool) -> f64 {+ let interior = body.matches(' ').count();+ if self.justify && !last && interior > 0 && self.scale.abs() > 1e-6 {+ Some((self.width - self.advance.of(body)).max(0.0) / self.k / self.scale / interior as f64).filter(|tw| tw.is_finite()).unwrap_or(0.0)+ } else {+ 0.0+ }+ }++ /// The text to show for a line and the width it is aligned on. 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.+ fn shown<'t>(&self, line: &'t str, body: &'t str, tw: f64) -> (&'t str, f64) {+ if tw > 0.0 {+ (body, self.advance.of(body))+ } else if crate::bidi::rtl_base(line) {+ (line, self.advance.of(line))+ } else {+ (line, self.advance.of(line.trim_end_matches(' ')))+ }+ }++ /// Writes one wrapped line, returning its underline (x0, x1, y) in text space.+ fn write_line(&self, index: usize, line: &str, last: bool, cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<(f64, f64, f64), EditError> {+ let n = pdfcraft_content::num;+ let body = line.trim_matches(' ');+ let interior = body.matches(' ').count();+ let tw = self.stretch(body, last);+ let (shown, visible) = self.shown(line, body, tw);+ let dx = if tw > 0.0 { 0.0 } else { self.alignment.offset(visible) };+ if index > 0 || dx != 0.0 {+ ops.push(Op::new("Td", vec![n(dx - cursor.x), n(if index > 0 { -self.lead } else { 0.0 })]));+ }+ cursor.x = dx;+ // 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.+ let stretch = if self.word_spacing_reaches_spaces { 0.0 } else { tw };+ let tw = tw - stretch;+ if tw != cursor.tw_set {+ ops.push(Op::new("Tw", vec![n(tw)]));+ cursor.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: Vec<&str> = if stretch > 0.0 { visual.split_inclusive(' ').collect() } else { vec![visual.as_str()] };+ for piece in pieces {+ self.show_piece(piece, line, tw, cursor, ops)?;+ if stretch > 0.0 && piece.ends_with(' ') {+ ops.push(Op::new("TJ", vec![Object::Array(vec![n(-1000.0 * stretch / self.size)])]));+ }+ }+ let tw = tw + stretch;+ // Underlined to the line's last word, over its stretched gaps.+ let w = (visible + tw * interior as f64 * self.scale * self.k) / self.k;+ Ok((dx, dx + w, -(index as f64) * self.lead - self.size * 0.12))+ }++ fn show_piece(&self, piece: &str, line: &str, tw: f64, cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<(), EditError> {+ let n = pdfcraft_content::num;+ if let Some(metrics) = self.source {+ let indic_piece = if metrics.visual_order { crate::indic::to_visual(piece) } else { piece.to_owned() };+ ops.extend(source_show(metrics, &indic_piece, self.size, self.space, self.char_spacing, tw)?);+ return Ok(());+ }+ for (font, bytes) in (self.encode)(piece).ok_or_else(|| EditError::Invalid(format!("\"{line}\" can't be shown")))? {+ if font != cursor.shown_font {+ ops.push(Op::new("Tf", vec![Object::name(&font), n(self.size)]));+ cursor.shown_font = font;+ }+ ops.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));+ }+ Ok(())+ }++ /// Writes every wrapped line, returning their underlines.+ fn write_all(&self, wrapped: &[String], cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<Vec<(f64, f64, f64)>, EditError> {+ wrapped.iter().enumerate().map(|(i, line)| self.write_line(i, line, i + 1 == wrapped.len(), cursor, ops)).collect()+ }+}++/// The operators that write a paragraph in its own graphics state, so a new colour (or anything+/// else) stops at the paragraph.+struct BlockPlan<'a> {+ block: &'a TextBlock,+ lines: &'a [TextLine],+ style: &'a BlockStyle,+ emit: &'a Origin,+ after: &'a TextState,+ movement: Option<(f64, f64)>,+ state: TextState,+ tm: [f64; 6],+ size: f64,+ underline: bool,+}++fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[String], show_font: String) -> Result<Vec<Op>, EditError> {+ let n = pdfcraft_content::num;+ let mut ops = vec![Op::new("q", vec![])];+ ops.extend(reveal_ops(plan.block, plan.lines, plan.style, plan.emit.ctm)?);+ // Moved: a translation inside that state.+ if let Some((ax, ay)) = plan.movement {+ 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.+ ops.extend(plan.state.paint_ops(plan.after));+ ops.push(Op::new("BT", vec![]));+ let mut state = plan.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 cursor = LineCursor { x: 0.0, tw_set: 0.0, shown_font: show_font.clone() };+ state.font = Some((show_font, plan.size));+ if let Some([r, g, bl]) = plan.style.color {+ state.fill = vec![Op::new("rg", vec![n(r), n(g), n(bl)])];+ }+ ops.extend(state.ops());+ ops.push(Op::new("Tm", plan.tm.iter().map(|v| n(*v)).collect()));+ let underlines = writer.write_all(wrapped, &mut cursor, &mut ops)?;+ ops.push(Op::new("ET", vec![]));+ if plan.underline {+ ops.extend(underline_ops(&state.fill, &plan.tm, plan.size, &underlines));+ }+ ops.push(Op::new("Q", vec![]));+ Ok(ops)+}++/// Whether 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. The paragraph's own operators (and another drawing on the same baseline: a fake-bold+/// second copy, an invisible text layer) go, so the new text is all that may show.+fn shows_before_paragraph(ops: &[Op], from: usize, to: usize, dropped: &std::collections::HashSet<usize>) -> bool {+ ops.get(from..to)+ .unwrap_or_default()+ .iter()+ .enumerate()+ .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !dropped.contains(&(from + i)))+}++/// A paragraph's single style, with the text-space values read from where it starts.+struct ParaStyle {+ state: TextState,+ size: f64,+ old_size: f64,+ k: f64,+}++/// Spacing and scaling (text state), with the chosen values.+fn paragraph_style(o: &Origin, style: &BlockStyle) -> Result<(String, ParaStyle), EditError> {+ 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));+ let mut state = o.state.clone();+ if let Some(c) = style.char_spacing {+ state.char_spacing = c / k;+ }+ if let Some(sc) = style.scale {+ state.scale = (sc / 100.0).clamp(0.1, 10.0);+ }+ Ok((font_name, ParaStyle { state, size, old_size, k }))+}++/// The font the paragraph's existing runs use, for reusing its glyphs.+struct SourceFont {+ metrics: Option<Metrics>,+ reuse: bool,+ space: f64,+}++fn source_font(doc: &Document, fonts_res: &Dict, font_name: &str, first: &TextLine, flat: &str, style: &BlockStyle) -> SourceFont {+ 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.to_owned() };+ 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));+ SourceFont { metrics, reuse, space }+}+/// [`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,@@ -228,86 +757,26 @@ pub(crate) fn rewrite_block_from(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())- {+ let dispatch = choose_rewrite_path(doc, &fonts_res, &b, &members, first, text, style)?;+ if dispatch.use_styled_path {return rewrite_styled_block(doc, page, &b, &lines, text, style, max_glyphs);}+ let upright = dispatch.upright;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();+ let text = paragraph_text(text.unwrap_or(&b.text));// 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));+ let (font_name, ParaStyle { state: o_state, size, old_size, k }) = paragraph_style(o, style)?;+ let source = source_font(doc, &fonts_res, &font_name, first, &flat, style);+ let reuse = source.reuse;// 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()));@@ -327,287 +796,79 @@ pub(crate) fn rewrite_block_from(// 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 geometry = ParaGeometry { rect: b.rect, frame, crop, upright, k, size, dx, single_line: members.len() == 1, anchored_right, centred };+ let width = geometry.width(style.width)?;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 movement = drawn_movement(emit.ctm, dx, dy)?;+ let tm = emit_text_matrix(o, emit)?;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+ let source_metrics = source.metrics.as_ref().filter(|_| reuse);+ let advance = Advance {+ source: source_metrics,+ type3: type3.as_ref(),+ family,+ bold,+ italic,+ size,+ space: source.space,+ char_spacing: o_state.char_spacing,+ word_spacing: o_state.word_spacing,+ scale: 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)+ turned_line_width(first, crop, [dx, dy], width, &text, &advance)} 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 wrapped = wrap(&text, width + 0.5, |s| advance.of(s));+ let font = choose_font(+ &FontInputs {+ source: source_metrics,+ type3: type3.as_ref(),+ font_name: &font_name,+ flat: &flat,+ source_base_font: &b.base_font,+ family,+ bold,+ italic,+ family_requested: style.family.is_some(),+ },+ &mut fonts_res,+ )?;+ let lead = line_lead(&b, &lines, style, &LeadScale { k, size, old_size, leading: o_state.leading });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)));+ let split = shows_before_paragraph(&ops, emit.bt_op, start, &dropped);// 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) {+ // Word spacing reaches only single-byte code 32 (ISO 32000-1 §9.3.3); see `write_line`.+ let word_spacing_reaches_spaces = match source_metrics {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![]));+ let writer = LineWriter {+ advance: &advance,+ alignment: Alignment { align, width, k, anchored_right, right_edge, rtl },+ encode: &font.encode,+ source: source_metrics,+ justify: align == Some(crate::added::Align::Justify),+ word_spacing_reaches_spaces,+ width,+ scale: o_state.scale,+ k,+ size,+ space: source.space,+ char_spacing: o_state.char_spacing,+ lead,+ };+ let plan =+ BlockPlan { block: &b, lines: &lines, style, emit, after, movement, state: o_state, tm, size, underline: style.underline == Some(true) };+ let mut block_ops = block_ops(&plan, &writer, &wrapped, font.show_font.clone())?;+ let n = pdfcraft_content::num;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![]));@@ -617,9 +878,10 @@ pub(crate) fn rewrite_block_from(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))+ (insert, !dropped.contains(&i))});let contents = rewritten_contents(doc, &streams, new_data);+ let new_font = !reuse;if new_font {res.set(b"Font".to_vec(), Object::Dict(fonts_res));}@@ -630,7 +892,7 @@ pub(crate) fn rewrite_block_from(d.set(b"Resources".to_vec(), Object::Dict(res));}})?;- Ok(LineEdit { substituted })+ Ok(LineEdit { substituted: font.substituted })}/// The cover (when [`BlockStyle::cover`] asks for one) and visible rendering that start adiff --git a/crates/edit/src/text_regions.rs b/crates/edit/src/text_regions.rsindex 7516cb793..be5b4dffa 100644--- a/crates/edit/src/text_regions.rs+++ b/crates/edit/src/text_regions.rs@@ -1,6 +1,11 @@//! Geometry-based regions and mixed-style rewriting of existing text.-use super::*;+use super::{+ BlockStyle, CraftFont, Dict, Document, EditError, HashMap, LineEdit, MAX_TYPE3_GLYPHS, Matrix, Metrics, Object, Op, PdfString, Pieces,+ RangeStyle, TextBlock, TextLine, Type3Glyph, coincident_ops, content_streams, fallback_face, japanese_glyph_from, needs_type3, no_fallback_font,+ no_glyph_for, page_dict, paragraph_separator, reveal_ops, rewritten_contents, same_base_font, same_font, source_encodes, source_family,+ source_program, source_show, source_space, source_width, splice, strip_subset_tag, type3_faces, type3_glyph, union, write_type3_glyphs,+};#[path = "text_regions/grouping.rs"]mod grouping;diff --git a/crates/edit/src/text_regions/grouping.rs b/crates/edit/src/text_regions/grouping.rsindex 29004b8e3..b8a5abca1 100644--- a/crates/edit/src/text_regions/grouping.rs+++ b/crates/edit/src/text_regions/grouping.rs@@ -1,4 +1,4 @@-use super::*;+use super::{HashMap, Matrix, TextBlock, TextLine, paragraph_separator, same_base_font, same_font, strip_subset_tag, union};fn same_plane(a: &TextLine, b: &TextLine) -> bool {let at = Matrix(a.origin.tm).then(&Matrix(a.origin.ctm));diff --git a/crates/edit/src/text_regions/styled.rs b/crates/edit/src/text_regions/styled.rsindex 09baf1ac7..e8b3b683d 100644--- a/crates/edit/src/text_regions/styled.rs+++ b/crates/edit/src/text_regions/styled.rs@@ -1,5 +1,10 @@use super::grouping::{across, is_centred, row_rect};-use super::*;+use super::{+ BlockStyle, CraftFont, Dict, Document, EditError, HashMap, LineEdit, MAX_TYPE3_GLYPHS, Matrix, Metrics, Object, Op, PdfString, Pieces,+ RangeStyle, TextBlock, TextLine, Type3Glyph, coincident_ops, content_streams, fallback_face, japanese_glyph_from, needs_type3, no_fallback_font,+ no_glyph_for, page_dict, reveal_ops, rewritten_contents, source_encodes, source_family, source_program, source_show, source_space, source_width,+ splice, type3_faces, type3_glyph, write_type3_glyphs,+};// The draft is capped at 4 MiB; also bound the outline data prepared across all fallback faces.// A glyph budget worth 64 full batches (15,360 glyphs with the production batch size).@@ -13,122 +18,462 @@ struct FallbackGroup {positions: Vec<usize>,}-/// Shape in the source or an explicitly registered matching full face. Never use interface fonts.-fn shape_source(- doc: &Document,- fonts: &Dict,- name: &str,- text: &str,-) -> Result<Option<(Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>, EditError> {- if !pdfcraft_fonts::source_shaping::required(text) {- return Ok(None);- }- let source =- fonts.get(name.as_bytes()).and_then(|f| doc.dict(f)).ok_or_else(|| EditError::Invalid("the shaped text has no font resource".into()))?;- let family = Metrics::from_dict(doc, &source).base_font;- let mut candidates = vec![source];- candidates.extend(- fonts- .iter()- .filter_map(|(_, f)| doc.dict(f))- .filter(|f| pdfcraft_fonts::embedding::face_key(&Metrics::from_dict(doc, f).base_font) == pdfcraft_fonts::embedding::face_key(&family)),- );- for font in candidates {- if let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)- && pdfcraft_fonts::embedding::covers(&bytes, text)- && let Ok(shaped) = pdfcraft_fonts::source_shaping::shape(&bytes, text)+struct FallbackBuilder {+ groups: Vec<FallbackGroup>,+ names: std::collections::BTreeMap<(String, bool, char), usize>,+ glyphs: usize,+ per_font: usize,+ budget: usize,+}++struct FontResolver<'a> {+ doc: &'a mut Document,+ fonts: &'a mut Dict,+ metrics: &'a mut std::collections::BTreeMap<String, Metrics>,+ full_faces: HashMap<String, String>,+ programs: HashMap<String, Option<std::sync::Arc<Vec<u8>>>>,+}++impl FontResolver<'_> {+ fn encodable_font(&mut self, source: &TextLine, text: &str, requested: Option<&str>) -> Result<Option<String>, EditError> {+ if let Some(resource) = requested {+ if !self.metrics.get(resource).is_some_and(|metrics| source_encodes(metrics, text)) {+ return Err(EditError::Invalid(format!(+ "the selected font resource {resource} cannot show U+{:04X}",+ text.chars().next().map_or(0, u32::from)+ )));+ }+ return Ok(Some(resource.to_owned()));+ }+ if self.metrics.get(&source.font).is_some_and(|metrics| source_encodes(metrics, text)) {+ return Ok(Some(source.font.clone()));+ }+ if let Some((name, _)) = self.metrics.iter().find(|(_, metrics)| {+ pdfcraft_fonts::embedding::face_key(&metrics.base_font) == pdfcraft_fonts::embedding::face_key(&source.base_font)+ && source_encodes(metrics, text)+ }) {+ return Ok(Some(name.clone()));+ }+ if let Some(face) =+ pdfcraft_fonts::embedding::matching_faces(&source.base_font).into_iter().find(|face| pdfcraft_fonts::embedding::covers(face.bytes, text)){- return Ok(Some((bytes, shaped, family)));+ return self.embed_face(face.name(), face.bytes, face.family, "the full source font could not be loaded").map(Some);}+ let Some(bytes) = self+ .programs+ .entry(source.font.clone())+ .or_insert_with(|| source_program(self.doc, self.fonts, &source.font).map(std::sync::Arc::new))+ .clone()+ .filter(|bytes| pdfcraft_fonts::embedding::covers(bytes, text))+ else {+ return Ok(None);+ };+ let key = format!("source {}", source.font);+ if let Some(name) = self.full_faces.get(&key) {+ return Ok(Some(name.clone()));+ }+ let family = pdfcraft_fonts::embedding::names(&bytes).map_or_else(|_| source.base_font.clone(), |(family, _)| family);+ self.embed_face(key, &bytes, &family, "the source font could not be loaded").map(Some)+ }++ fn embed_face(&mut self, key: String, bytes: &[u8], family: &str, missing_message: &str) -> Result<String, EditError> {+ if let Some(name) = self.full_faces.get(&key) {+ return Ok(name.clone());+ }+ let name = pdfcraft_fonts::embedding::embed(self.doc, self.fonts, bytes, family).map_err(EditError::Invalid)?;+ let font =+ self.fonts.get(name.as_bytes()).and_then(|resource| self.doc.dict(resource)).ok_or_else(|| EditError::Invalid(missing_message.into()))?;+ self.metrics.insert(name.clone(), Metrics::from_dict(self.doc, &font));+ self.full_faces.insert(key, name.clone());+ Ok(name)+ }++ fn substitute_font(&mut self, source: &TextLine) -> String {+ let family = source_family(&source.base_font);+ let base = family.base_font(source.bold, source.italic);+ let name = format!("PCEd{}", base.replace('-', ""));+ let mut font = Dict::new();+ font.set(b"Type".to_vec(), Object::name("Font"));+ font.set(b"Subtype".to_vec(), Object::name("Type1"));+ font.set(b"BaseFont".to_vec(), Object::name(base));+ font.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));+ self.metrics.entry(name.clone()).or_insert_with(|| Metrics::from_dict(self.doc, &font));+ self.fonts.set(name.clone().into_bytes(), Object::Dict(font));+ name}- Err(EditError::Invalid("complex text needs the complete source TrueType/OpenType face; load that font before editing".into()))}-/// For each output row (a range of the draft's characters), whether it is exactly the source row-/// at the same position: the same characters, none of them inserted or changed by the edit.-fn untouched_rows(block: &TextBlock, draft: &str, rows: &[std::ops::Range<usize>]) -> Vec<bool> {- let old: Vec<char> = block.editor_text.chars().collect();- let new: Vec<char> = draft.chars().collect();- 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();- // The source character a draft character is, if the edit left it alone.- let origin = |i: usize| {- if i < prefix {- Some(i)- } else if i >= new.len().saturating_sub(suffix) {- (old.len() + i).checked_sub(new.len())+struct PreparedCharacters {+ values: Vec<StyledChar>,+ substituted: Option<String>,+}++struct CharacterPreparation<'a> {+ doc: &'a mut Document,+ first: &'a TextLine,+ lines: &'a [TextLine],+ draft: &'a str,+ spans: Vec<(std::ops::Range<usize>, usize)>,+ style: &'a BlockStyle,+ overrides: &'a HashMap<usize, &'a RangeStyle>,+ fonts: &'a mut Dict,+ metrics: &'a mut std::collections::BTreeMap<String, Metrics>,+ max_glyphs: usize,+}++impl CharacterPreparation<'_> {+ fn prepare(self) -> Result<PreparedCharacters, EditError> {+ let Self { doc, first, lines, draft, spans, style, overrides, fonts, metrics, max_glyphs } = self;+ let mut chars = Vec::new();+ let mut substituted = None;+ let mut fallback = FallbackBuilder::new(max_glyphs);+ let mut resolver = FontResolver { doc, fonts, metrics, full_faces: HashMap::new(), programs: HashMap::new() };+ for (range, index) in spans {+ let source = lines.get(index).unwrap_or(first);+ let start = range.start;+ for (offset, ch) in draft.get(range).unwrap_or_default().char_indices() {+ if ch == '\n' {+ chars.push((ch, index, source.font.clone()));+ continue;+ }+ if ch == '\r' {+ let crlf = start.checked_add(offset).and_then(|at| draft.get(at.saturating_add(1)..)).is_some_and(|rest| rest.starts_with('\n'));+ chars.push((if crlf { '\r' } else { '\n' }, index, source.font.clone()));+ continue;+ }+ let text = ch.to_string();+ let requested = overrides.get(&index).and_then(|range| range.resource.as_deref()).or(style.resource.as_deref());+ let name = if let Some(name) = resolver.encodable_font(source, &text, requested)? {+ name+ } else if needs_type3(&text) {+ fallback.prepare(source, ch, &text, chars.len())?+ } else {+ let name = resolver.substitute_font(source);+ substituted = Some(source_family(&source.base_font).base_font(source.bold, source.italic).to_owned());+ name+ };+ chars.push((ch, index, name));+ }+ }+ drop(resolver);+ for group in fallback.groups {+ let written = write_type3_glyphs(doc, fonts, group.face, false, group.glyphs, fallback.per_font);+ for name in &written.names {+ let font = fonts+ .get(name.as_bytes())+ .and_then(|resource| doc.dict(resource))+ .ok_or_else(|| EditError::Invalid("the fallback font could not be loaded".into()))?;+ metrics.insert(name.clone(), Metrics::from_dict(doc, &font));+ }+ for position in group.positions {+ let item = chars.get_mut(position).ok_or_else(|| EditError::Invalid("the fallback character is missing".into()))?;+ let (font, _) = written.codes.get(&item.0).ok_or_else(|| EditError::Invalid("the fallback glyph is missing".into()))?;+ item.2 = written.names.get(*font).cloned().ok_or_else(|| EditError::Invalid("the fallback font is missing".into()))?;+ }+ substituted = Some(written.family.to_owned());+ }+ Ok(PreparedCharacters { values: chars, substituted })+ }+}++impl FallbackBuilder {+ fn new(max_glyphs: usize) -> Self {+ let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);+ Self {+ groups: Vec::new(),+ names: std::collections::BTreeMap::new(),+ glyphs: 0,+ per_font,+ budget: per_font.saturating_mul(MAX_STYLED_FALLBACK_BATCHES),+ }+ }++ fn prepare(&mut self, source: &TextLine, ch: char, text: &str, position: usize) -> Result<String, EditError> {+ let key = (source.base_font.clone(), source.bold, ch);+ let group_index = if let Some(index) = self.names.get(&key) {+ *index} else {- None+ let (faces, _) = type3_faces(text, source_family(&source.base_font), source.bold)?;+ let face = fallback_face(&faces, &[ch], |face, ch| japanese_glyph_from(face, ch).is_ok()).ok_or_else(|| no_fallback_font(text))?;+ let index = self.groups.iter().position(|group| std::ptr::eq(group.face, face)).unwrap_or_else(|| {+ let index = self.groups.len();+ self.groups.push(FallbackGroup { face, seen: Default::default(), glyphs: Vec::new(), positions: Vec::new() });+ index+ });+ self.names.insert(key, index);+ index+ };+ let group = self.groups.get_mut(group_index).ok_or_else(|| EditError::Invalid("the fallback face is missing".into()))?;+ if group.seen.insert(ch) {+ if self.glyphs >= self.budget {+ return Err(EditError::Invalid(format!(+ "the replacement needs more than {} fallback glyphs; edit a smaller paragraph or load a complete font",+ self.budget+ )));+ }+ let (path, width) = type3_glyph(group.face, ch)?.ok_or_else(|| no_glyph_for(group.face, ch))?;+ let code = u8::try_from((group.glyphs.len() % self.per_font).saturating_add(1))+ .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;+ group.glyphs.push(Type3Glyph { code, ch, path, width });+ self.glyphs = self.glyphs.saturating_add(1);}- };- let mut source_rows = Vec::new();- let mut start = 0;- for (i, ch) in old.iter().enumerate() {- if *ch == '\n' {- source_rows.push(start..i);- start = i + 1;+ group.positions.push(position);+ Ok(String::new())+ }+}++struct StyledLines<'a> {+ lines: Vec<TextLine>,+ spans: Vec<(std::ops::Range<usize>, usize)>,+ underlines: HashMap<usize, bool>,+ overrides: HashMap<usize, &'a RangeStyle>,+}++type StyledChar = (char, usize, String);+type StyledRows = Vec<Vec<StyledChar>>;+type RowRanges = Vec<std::ops::Range<usize>>;+type ShapedRunCache = HashMap<(usize, usize), (Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>;++struct ShapedRows {+ runs: ShapedRunCache,+ advances: HashMap<(usize, usize), f64>,+}++fn prepare_shaped_rows(+ doc: &Document,+ fonts: &Dict,+ rows: &[Vec<StyledChar>],+ kept: &[bool],+ advance: impl Fn(&StyledChar) -> f64,+) -> Result<ShapedRows, EditError> {+ let mut runs = HashMap::new();+ let mut advances = HashMap::new();+ for (row_index, row) in rows.iter().enumerate().filter(|(index, _)| !kept.get(*index).copied().unwrap_or(false)) {+ let mut at = 0;+ while let Some(item) = row.get(at) {+ let mut end = at + 1;+ while row.get(end).is_some_and(|next| next.1 == item.1 && next.2 == item.2) {+ end += 1;+ }+ let segment = row.get(at..end).unwrap_or_default();+ advances.insert((row_index, at), segment.iter().map(&advance).sum::<f64>());+ let text: String = segment.iter().map(|character| character.0).collect();+ if let Some((bytes, shaped, family)) = shape_source(doc, fonts, &item.2, &text)? {+ runs.insert((row_index, at), (bytes, shaped, family));+ }+ at = end;}}- source_rows.push(start..old.len());- // A line break inside a source run would pair editor rows with the wrong visual rows.- if source_rows.len() != block.rows.len() {- return vec![false; rows.len()];+ Ok(ShapedRows { runs, advances })+}++fn embed_shaped_resources(doc: &mut Document, fonts: &mut Dict, runs: &ShapedRunCache) -> Result<HashMap<(usize, usize), String>, EditError> {+ let mut resources = HashMap::new();+ for (key, (bytes, shaped, family)) in runs {+ let mappings: Vec<_> = shaped.glyphs.iter().map(|glyph| (glyph.text.clone(), glyph.id)).collect();+ let resource = pdfcraft_fonts::embedding::embed_mapping(doc, fonts, bytes, family, &mappings).map_err(EditError::Invalid)?;+ resources.insert(*key, resource);}- rows.iter()- .enumerate()- .map(|(r, range)| {- source_rows.get(r).is_some_and(|source| {- !range.is_empty() && range.len() == source.len() && range.clone().zip(source.clone()).all(|(i, j)| origin(i) == Some(j))- })- })- .collect()+ Ok(resources)}-/// Rewrite visual rows while keeping the source style on each surviving character. Resource-/// names may differ between Unicode subsets of the same face; encoding searches those subsets.-pub(crate) fn rewrite_styled_block(- doc: &mut Document,- page: usize,- block: &TextBlock,+fn validate_contextual_rows(rows: &[Vec<StyledChar>], kept: &[bool]) -> Result<(), EditError> {+ for (row, _) in rows.iter().zip(kept).filter(|(_, retained)| !**retained) {+ let text: String = row.iter().map(|character| character.0).collect();+ if pdfcraft_fonts::source_shaping::required(&text)+ && row.first().is_some_and(|first| row.iter().any(|character| character.1 != first.1 || character.2 != first.2))+ {+ return Err(EditError::Invalid(+ "contextual/bidi text across font or style boundaries needs a uniform full-face row; mixed contextual runs are not yet supported"+ .into(),+ ));+ }+ }+ Ok(())+}++fn calibration_factors(lines: &[TextLine],- text: Option<&str>,+ metrics: &std::collections::BTreeMap<String, Metrics>,style: &BlockStyle,- max_glyphs: usize,-) -> Result<LineEdit, EditError> {- let first = block.lines.first().and_then(|i| lines.get(*i)).ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;+ overrides: &HashMap<usize, &RangeStyle>,+ space_of: impl Fn(&str, &Metrics) -> f64,+) -> HashMap<usize, f64> {+ let mut calibration = HashMap::new();+ for (index, source) in lines.iter().enumerate() {+ if let Some(metrics) = metrics.get(&source.font) {+ let nominal = source_width(+ metrics,+ &source.text,+ source.origin.state.font.as_ref().map_or(1.0, |(_, size)| *size),+ space_of(&source.font, metrics),+ source.origin.state.char_spacing,+ source.origin.state.word_spacing,+ ) * source.origin.state.scale+ * across(source);+ let changed_face =+ style.resource.is_some() || overrides.get(&index).is_some_and(|range| range.family.is_some() || range.resource.is_some());+ let factor = if nominal > 0.0 && !changed_face { ((source.rect[2] - source.rect[0]) / nominal).clamp(0.5, 2.0) } else { 1.0 };+ calibration.insert(index, factor);+ }+ }+ calibration+}++fn validated_ranges<'a>(draft: &str, style: &'a BlockStyle) -> Result<Vec<&'a RangeStyle>, EditError> {+ let mut ranges: Vec<_> = style.ranges.iter().collect();+ ranges.sort_by_key(|range| range.range.start);+ let invalid_range = ranges.iter().any(|range| {+ range.range.start >= range.range.end+ || draft.get(range.range.clone()).is_none()+ || [range.size, range.char_spacing, range.scale].iter().flatten().any(|value| !value.is_finite())+ || range.size.is_some_and(|value| value <= 0.0 || value > 14_400.0)+ || range.color.is_some_and(|color| color.iter().any(|value| !value.is_finite() || !(0.0..=1.0).contains(value)))+ });+ if ranges.len() > 1024 || invalid_range || ranges.windows(2).any(|pair| pair[0].range.end > pair[1].range.start) {+ return Err(EditError::Invalid("text style ranges must be disjoint UTF-8 boundaries with finite formatting (at most 1024 ranges)".into()));+ }+ Ok(ranges)+}++fn replacement_text<'a>(block: &'a TextBlock, text: Option<&'a str>) -> Result<&'a str, EditError> {let draft = match text {- Some(t) if t != block.text => t,+ Some(text) if text != block.text => text,_ => &block.editor_text,};if draft.len() > 4_000_000 {return Err(EditError::Invalid("the replacement text is too large".into()));}- if draft == block.editor_text && *style == BlockStyle::default() {- return Ok(LineEdit { substituted: None });+ Ok(draft)+}++fn has_no_effective_style_change(block: &TextBlock, draft: &str, style: &BlockStyle) -> bool {+ draft == block.editor_text && *style == BlockStyle::default()+}++fn page_font_metrics(+ doc: &Document,+ resource_dict: &Dict,+ block: &TextBlock,+ lines: &[TextLine],+) -> (Dict, std::collections::BTreeMap<String, Metrics>) {+ let mut fonts = resource_dict.get(b"Font").and_then(|resource| doc.resolve(resource).as_dict().cloned()).unwrap_or_default();+ for line in lines.iter().filter(|line| line.font.starts_with("PCRange")) {+ let mut font = Dict::new();+ font.set(b"Type".to_vec(), Object::name("Font"));+ font.set(b"Subtype".to_vec(), Object::name("Type1"));+ font.set(b"BaseFont".to_vec(), Object::name(&line.base_font));+ font.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));+ fonts.set(line.font.as_bytes().to_vec(), Object::Dict(font));}- let mut ranges: Vec<_> = style.ranges.iter().collect();- ranges.sort_by_key(|r| r.range.start);- if ranges.len() > 1024- || ranges.iter().any(|r| {- r.range.start >= r.range.end- || draft.get(r.range.clone()).is_none()- || [r.size, r.char_spacing, r.scale].iter().flatten().any(|n| !n.is_finite())- || r.size.is_some_and(|n| n <= 0.0 || n > 14400.0)- || r.color.is_some_and(|c| c.iter().any(|n| !n.is_finite() || !(0.0..=1.0).contains(n)))- })- || ranges.windows(2).any(|r| r[0].range.end > r[1].range.start)+ let mut metrics = std::collections::BTreeMap::new();+ for (name, object) in fonts.iter().take(256) {+ if let Some(font) = doc.resolve(object).as_dict() {+ metrics.insert(String::from_utf8_lossy(name).into_owned(), Metrics::from_dict(doc, font));+ }+ }+ for index in &block.lines {+ if let Some(line) = lines.get(*index)+ && !metrics.contains_key(&line.font)+ && let Some(font) = fonts.get(line.font.as_bytes()).and_then(|resource| doc.resolve(resource).as_dict().cloned())+ {+ metrics.insert(line.font.clone(), Metrics::from_dict(doc, &font));+ }+ }+ (fonts, metrics)+}++fn paragraph_geometry(doc: &Document, page: &pdfcraft_model::Page, block: &TextBlock, style: &BlockStyle) -> Result<(f64, f64, f64), EditError> {+ if [style.size, style.line_spacing, style.char_spacing, style.scale, style.width].iter().flatten().any(|value| !value.is_finite())+ || style.color.is_some_and(|color| color.iter().any(|value| !value.is_finite())){- return Err(EditError::Invalid("text style ranges must be disjoint UTF-8 boundaries with finite formatting (at most 1024 ranges)".into()));+ return Err(EditError::Invalid("the paragraph's formatting must use finite numbers".into()));}- let source_count = lines.len();+ let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);+ if !dx.is_finite() || !dy.is_finite() || style.width.is_some_and(|width| !width.is_finite()) {+ return Err(EditError::Invalid("the paragraph's position and width must be finite".into()));+ }+ let natural = if block.invisible || block.rows.len() == 1 {+ (page.crop(doc)[2] - 36.0 - (block.rect[0] + dx)).max(block.rect[2] - block.rect[0])+ } else {+ block.rect[2] - block.rect[0]+ };+ Ok((dx, dy, style.width.unwrap_or(natural).clamp(1.0, 14_400.0)))+}++fn wrap_styled_rows(+ chars: &[StyledChar],+ width: f64,+ measure: impl Fn(&[StyledChar]) -> Result<f64, EditError>,+) -> Result<(StyledRows, RowRanges), EditError> {+ let mut rows: Vec<Vec<StyledChar>> = Vec::new();+ let mut row_ranges = Vec::new();+ let mut row_start = 0;+ let mut row = Vec::new();+ let mut row_width = 0.0;+ let mut at = 0;+ while at < chars.len() {+ let Some(item) = chars.get(at) else { break };+ if item.0 == '\r' {+ at += 1;+ continue;+ }+ if item.0 == '\n' {+ row_ranges.push(row_start..row_start + row.len());+ rows.push(std::mem::take(&mut row));+ row_width = 0.0;+ at += 1;+ row_start = at;+ continue;+ }+ let mut end = at + 1;+ if !item.0.is_whitespace() {+ // A word ends at a space, or where Chinese or Japanese text may break between characters.+ while let (Some(before), Some(current)) = (chars.get(end - 1), chars.get(end))+ && !current.0.is_whitespace()+ && !crate::linebreak::between(before.0, current.0)+ {+ end += 1;+ }+ }+ let word = chars.get(at..end).unwrap_or_default();+ let word_width = measure(word)?;+ if !row.is_empty() && !item.0.is_whitespace() && row_width + word_width > width + 0.5 {+ while row.last().is_some_and(|c: &StyledChar| c.0.is_whitespace()) {+ row.pop();+ }+ row_ranges.push(row_start..row_start + row.len());+ rows.push(std::mem::take(&mut row));+ row_width = 0.0;+ row_start = at;+ }+ row.extend_from_slice(word);+ row_width += word_width;+ at = end;+ }+ if !row.is_empty() {+ row_ranges.push(row_start..row_start + row.len());+ rows.push(row);+ }+ Ok((rows, row_ranges))+}++fn apply_range_styles<'a>(+ first: &TextLine,+ block: &TextBlock,+ lines: &[TextLine],+ draft: &str,+ ranges: &[&'a RangeStyle],+ style: &BlockStyle,+) -> StyledLines<'a> {let mut styled_lines = lines.to_vec();let mut styled_spans = Vec::new();let mut underlines = HashMap::new();let mut overrides = HashMap::new();for (span, source) in block.edited_spans(draft) {let mut edges = vec![span.start, span.end];- for r in &ranges {- for edge in [r.range.start, r.range.end] {+ for range in ranges {+ for edge in [range.range.start, range.range.end] {if span.contains(&edge) {edges.push(edge);}@@ -138,8 +483,8 @@ pub(crate) fn rewrite_styled_block(edges.dedup();for bounds in edges.windows(2) {let (Some(start), Some(end)) = (bounds.first().copied(), bounds.get(1).copied()) else { continue };+ let selected = ranges.iter().find(|range| range.range.contains(&start)).copied();let mut index = source;- let selected = ranges.iter().find(|r| r.range.contains(&start)).copied();if selected.is_some() || style.family.is_some() || style.bold.is_some() {let default_range = RangeStyle {range: start..end,@@ -151,10 +496,10 @@ pub(crate) fn rewrite_styled_block(char_spacing: None,scale: None,};- let r = selected.unwrap_or(&default_range);+ let range = selected.unwrap_or(&default_range);let mut line = lines.get(source).unwrap_or(first).clone();if let Some((family, bold, italic)) =- r.family.or(style.family).or_else(|| style.bold.map(|b| (source_family(&line.base_font), b, line.italic)))+ range.family.or(style.family).or_else(|| style.bold.map(|b| (source_family(&line.base_font), b, line.italic))){let base = family.base_font(bold, italic);line.font = format!("PCRange{}", base.replace('-', ""));@@ -162,225 +507,192 @@ pub(crate) fn rewrite_styled_block(line.bold = bold;line.italic = italic;}- if let Some(resource) = &r.resource {+ if let Some(resource) = &range.resource {line.font = resource.clone();}- if let Some(size) = r.size {+ if let Some(size) = range.size {line.size = size;}- if let Some(color) = r.color {+ if let Some(color) = range.color {line.color = color;line.origin.state.fill = vec![Op::new("rg", color.map(Object::Real).to_vec())];}- if let Some(spacing) = r.char_spacing {+ if let Some(spacing) = range.char_spacing {line.origin.state.char_spacing = spacing / line.origin.k.max(1e-6);}- if let Some(scale) = r.scale {+ if let Some(scale) = range.scale {line.origin.state.scale = (scale / 100.0).clamp(0.1, 10.0);}index = styled_lines.len();styled_lines.push(line);- if let Some(r) = selected {- overrides.insert(index, r);+ if let Some(range) = selected {+ overrides.insert(index, range);}- if let Some(underline) = r.underline {+ if let Some(underline) = range.underline {underlines.insert(index, underline);}}styled_spans.push((start..end, index));}}- let lines = styled_lines.as_slice();- let p = page_dict(doc, page)?;- let mut res = p.dict.get(b"Resources").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();- let mut fonts = res.get(b"Font").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();- for line in lines.iter().filter(|line| line.font.starts_with("PCRange")) {- 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(&line.base_font));- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));- fonts.set(line.font.as_bytes().to_vec(), Object::Dict(f));- }- let mut metrics = std::collections::BTreeMap::new();- for (name, object) in fonts.iter().take(256) {- if let Some(font) = doc.resolve(object).as_dict() {- metrics.insert(String::from_utf8_lossy(name).into_owned(), Metrics::from_dict(doc, font));- }+ StyledLines { lines: styled_lines, spans: styled_spans, underlines, overrides }+}++/// Shape in the source or an explicitly registered matching full face. Never use interface fonts.+fn shape_source(+ doc: &Document,+ fonts: &Dict,+ name: &str,+ text: &str,+) -> Result<Option<(Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>, EditError> {+ if !pdfcraft_fonts::source_shaping::required(text) {+ return Ok(None);}- for index in &block.lines {- if let Some(line) = lines.get(*index)- && !metrics.contains_key(&line.font)- && let Some(font) = fonts.get(line.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned())+ let source =+ fonts.get(name.as_bytes()).and_then(|f| doc.dict(f)).ok_or_else(|| EditError::Invalid("the shaped text has no font resource".into()))?;+ let family = Metrics::from_dict(doc, &source).base_font;+ let mut candidates = vec![source];+ candidates.extend(+ fonts+ .iter()+ .filter_map(|(_, f)| doc.dict(f))+ .filter(|f| pdfcraft_fonts::embedding::face_key(&Metrics::from_dict(doc, f).base_font) == pdfcraft_fonts::embedding::face_key(&family)),+ );+ for font in candidates {+ if let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)+ && pdfcraft_fonts::embedding::covers(&bytes, text)+ && let Ok(shaped) = pdfcraft_fonts::source_shaping::shape(&bytes, text){- metrics.insert(line.font.clone(), Metrics::from_dict(doc, &font));+ return Ok(Some((bytes, shaped, family)));}}- if [style.size, style.line_spacing, style.char_spacing, style.scale, style.width].iter().flatten().any(|v| !v.is_finite())- || style.color.is_some_and(|c| c.iter().any(|v| !v.is_finite()))- {- return Err(EditError::Invalid("the paragraph's formatting must use finite numbers".into()));- }- let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);- if !dx.is_finite() || !dy.is_finite() || style.width.is_some_and(|w| !w.is_finite()) {- return Err(EditError::Invalid("the paragraph's position and width must be finite".into()));- }- // A visual row grows even when it contains several source/font runs. Multi-row- // paragraphs retain their container width; an explicit width always wins.- let natural = if block.invisible || block.rows.len() == 1 {- (p.crop(doc)[2] - 36.0 - (block.rect[0] + dx)).max(block.rect[2] - block.rect[0])- } else {- block.rect[2] - block.rect[0]+ Err(EditError::Invalid("complex text needs the complete source TrueType/OpenType face; load that font before editing".into()))+}++/// For each output row (a range of the draft's characters), whether it is exactly the source row+/// at the same position: the same characters, none of them inserted or changed by the edit.+fn untouched_rows(block: &TextBlock, draft: &str, rows: &[std::ops::Range<usize>]) -> Vec<bool> {+ let old: Vec<char> = block.editor_text.chars().collect();+ let new: Vec<char> = draft.chars().collect();+ 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();+ // The source character a draft character is, if the edit left it alone.+ let origin = |i: usize| {+ if i < prefix {+ Some(i)+ } else if i >= new.len().saturating_sub(suffix) {+ (old.len() + i).checked_sub(new.len())+ } else {+ None+ }};- let width = style.width.unwrap_or(natural).clamp(1.0, 14_400.0);- // Each tuple is a character, its source style and an encodable resource name.- let mut chars = Vec::new();- let mut substituted = None;- let mut fallback_groups: Vec<FallbackGroup> = Vec::new();- let mut fallback_names: std::collections::BTreeMap<(String, bool, char), usize> = std::collections::BTreeMap::new();- let mut fallback_glyphs = 0_usize;- let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);- let fallback_budget = per_font.saturating_mul(MAX_STYLED_FALLBACK_BATCHES);- let mut full_faces: HashMap<String, String> = HashMap::new();- let mut programs: HashMap<String, Option<std::sync::Arc<Vec<u8>>>> = HashMap::new();- for (range, index) in styled_spans {- let source = lines.get(index).unwrap_or(first);- let start = range.start;- for (offset, ch) in draft.get(range).unwrap_or_default().char_indices() {- if ch == '\n' {- chars.push((ch, index, source.font.clone()));- continue;- }- // A carriage return breaks the row too. Before `\n` the pair is one break, so the- // CR stays a `\r` the rows skip. Either way it keeps its place among the draft's- // characters, which rows are counted in.- if ch == '\r' {- let crlf = start.checked_add(offset).and_then(|at| draft.get(at.saturating_add(1)..)).is_some_and(|rest| rest.starts_with('\n'));- chars.push((if crlf { '\r' } else { '\n' }, index, source.font.clone()));- continue;- }- let s = ch.to_string();- let name = if let Some(resource) = overrides.get(&index).and_then(|r| r.resource.as_ref()).or(style.resource.as_ref()) {- if !metrics.get(resource).is_some_and(|m| source_encodes(m, &s)) {- return Err(EditError::Invalid(format!("the selected font resource {resource} cannot show U+{:04X}", u32::from(ch))));- }- resource.clone()- } else if metrics.get(&source.font).is_some_and(|m| source_encodes(m, &s)) {- source.font.clone()- } else if let Some((name, _)) = metrics.iter().find(|(_, m)| {- pdfcraft_fonts::embedding::face_key(&m.base_font) == pdfcraft_fonts::embedding::face_key(&source.base_font) && source_encodes(m, &s)- }) {- name.clone()- } else if let Some(face) =- pdfcraft_fonts::embedding::matching_faces(&source.base_font).into_iter().find(|f| pdfcraft_fonts::embedding::covers(f.bytes, &s))- {- let key = face.name();- if let Some(name) = full_faces.get(&key) {- name.clone()- } else {- let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, face.bytes, face.family).map_err(EditError::Invalid)?;- let font = fonts- .get(name.as_bytes())- .and_then(|f| doc.dict(f))- .ok_or_else(|| EditError::Invalid("the full source font could not be loaded".into()))?;- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));- full_faces.insert(key, name.clone());- name- }- } else if let Some(bytes) = programs- .entry(source.font.clone())- .or_insert_with(|| source_program(doc, &fonts, &source.font).map(std::sync::Arc::new))- .clone()- .filter(|bytes| pdfcraft_fonts::embedding::covers(bytes, &s))- {- // The document's own complete program of this font has the glyph: draw it with- // that face rather than another family's fallback.- let key = format!("source {}", source.font);- if let Some(name) = full_faces.get(&key) {- name.clone()- } else {- let family = pdfcraft_fonts::embedding::names(&bytes).map_or_else(|_| source.base_font.clone(), |(family, _)| family);- let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, &bytes, &family).map_err(EditError::Invalid)?;- let font = fonts- .get(name.as_bytes())- .and_then(|f| doc.dict(f))- .ok_or_else(|| EditError::Invalid("the source font could not be loaded".into()))?;- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));- full_faces.insert(key, name.clone());- name- }- } else {- let family = source_family(&source.base_font);- if needs_type3(&s) {- let key = (source.base_font.clone(), source.bold, ch);- let group_index = if let Some(index) = fallback_names.get(&key) {- *index- } else {- // Keep the old per-character face choice: a serif Japanese character- // and a Cyrillic character may need different faces even in one style.- // Hebrew uses the separate RTL path before reaching this writer.- let (faces, _) = type3_faces(&s, family, source.bold)?;- let face =- fallback_face(&faces, &[ch], |face, ch| japanese_glyph_from(face, ch).is_ok()).ok_or_else(|| no_fallback_font(&s))?;- let index = fallback_groups.iter().position(|group| std::ptr::eq(group.face, face)).unwrap_or_else(|| {- let index = fallback_groups.len();- fallback_groups.push(FallbackGroup { face, seen: Default::default(), glyphs: Vec::new(), positions: Vec::new() });- index- });- fallback_names.insert(key, index);- index- };- let group = fallback_groups.get_mut(group_index).ok_or_else(|| EditError::Invalid("the fallback face is missing".into()))?;- if group.seen.insert(ch) {- if fallback_glyphs >= fallback_budget {- return Err(EditError::Invalid(format!(- "the replacement needs more than {fallback_budget} fallback glyphs; edit a smaller paragraph or load a complete font"- )));- }- let (path, width) = type3_glyph(group.face, ch)?.ok_or_else(|| no_glyph_for(group.face, ch))?;- let code = u8::try_from((group.glyphs.len() % per_font).saturating_add(1))- .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;- group.glyphs.push(Type3Glyph { code, ch, path, width });- fallback_glyphs = fallback_glyphs.saturating_add(1);- }- group.positions.push(chars.len());- // Filled from the prepared font/code map before measuring or drawing.- String::new()- } else {- let base = family.base_font(source.bold, source.italic);- let name = format!("PCEd{}", base.replace('-', ""));- 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"));- metrics.entry(name.clone()).or_insert_with(|| Metrics::from_dict(doc, &f));- fonts.set(name.clone().into_bytes(), Object::Dict(f));- substituted = Some(base.to_string());- name- }- };- chars.push((ch, index, name));+ let mut source_rows = Vec::new();+ let mut start = 0;+ for (i, ch) in old.iter().enumerate() {+ if *ch == '\n' {+ source_rows.push(start..i);+ start = i + 1;}}- // All fallback outlines have now succeeded. Batch by actual face, preserving source- // style indices; the existing writer then coalesces adjacent equal-font/style characters.- for group in fallback_groups {- let fallback = write_type3_glyphs(doc, &mut fonts, group.face, false, group.glyphs, per_font);- for name in &fallback.names {- let font = fonts- .get(name.as_bytes())- .and_then(|f| doc.dict(f))- .ok_or_else(|| EditError::Invalid("the fallback font could not be loaded".into()))?;- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));- }- for position in group.positions {- let item = chars.get_mut(position).ok_or_else(|| EditError::Invalid("the fallback character is missing".into()))?;- let (font, _) = fallback.codes.get(&item.0).ok_or_else(|| EditError::Invalid("the fallback glyph is missing".into()))?;- item.2 = fallback.names.get(*font).cloned().ok_or_else(|| EditError::Invalid("the fallback font is missing".into()))?;+ source_rows.push(start..old.len());+ // A line break inside a source run would pair editor rows with the wrong visual rows.+ if source_rows.len() != block.rows.len() {+ return vec![false; rows.len()];+ }+ rows.iter()+ .enumerate()+ .map(|(r, range)| {+ source_rows.get(r).is_some_and(|source| {+ !range.is_empty() && range.len() == source.len() && range.clone().zip(source.clone()).all(|(i, j)| origin(i) == Some(j))+ })+ })+ .collect()+}++struct RewriteAnchor<'a> {+ lead: &'a TextLine,+ drop: std::collections::HashSet<usize>,+ start: usize,+ split: bool,+}++fn rewrite_anchor<'a>(+ block: &TextBlock,+ lines: &'a [TextLine],+ first: &'a TextLine,+ ops: &[Op],+ kept_lines: &std::collections::HashSet<usize>,+ kept: &mut [bool],+) -> RewriteAnchor<'a> {+ let rewritten: Vec<&TextLine> = block.lines.iter().filter(|index| !kept_lines.contains(index)).filter_map(|index| lines.get(*index)).collect();+ let lead = rewritten+ .last()+ .copied()+ .filter(|_| !rewritten.iter().flat_map(|line| &line.ops).any(|index| ops.get(*index).is_some_and(|op| op.is("'") || op.is("\""))));+ let (members, lead) = match lead {+ Some(lead) if !kept_lines.is_empty() => (rewritten, lead),+ _ => {+ kept.iter_mut().for_each(|value| *value = false);+ let all: Vec<&TextLine> = block.lines.iter().filter_map(|index| lines.get(*index)).collect();+ let last = all.last().copied().unwrap_or(first);+ (all, last)}- substituted = Some(fallback.family.to_owned());+ };+ let origin = &lead.origin;+ let mut drop = coincident_ops(lines, &members);+ drop.extend(members.iter().flat_map(|line| line.ops.iter().copied()));+ let start = lead.ops.first().copied().unwrap_or(origin.bt_op);+ let split = ops+ .get(origin.bt_op..start)+ .unwrap_or_default()+ .iter()+ .enumerate()+ .any(|(index, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(origin.bt_op + index)));+ RewriteAnchor { lead, drop, start, split }+}++/// Rewrite visual rows while keeping the source style on each surviving character. Resource+/// names may differ between Unicode subsets of the same face; encoding searches those subsets.+pub(crate) fn rewrite_styled_block(+ doc: &mut Document,+ page: usize,+ block: &TextBlock,+ lines: &[TextLine],+ text: Option<&str>,+ style: &BlockStyle,+ max_glyphs: usize,+) -> Result<LineEdit, EditError> {+ let first = block.lines.first().and_then(|i| lines.get(*i)).ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;+ let draft = replacement_text(block, text)?;+ if has_no_effective_style_change(block, draft, style) {+ return Ok(LineEdit { substituted: None });+ }+ let ranges = validated_ranges(draft, style)?;+ let source_count = lines.len();+ let styled = apply_range_styles(first, block, lines, draft, &ranges, style);+ let lines = styled.lines.as_slice();+ let styled_spans = styled.spans;+ let underlines = styled.underlines;+ let overrides = styled.overrides;+ let p = page_dict(doc, page)?;+ let mut res = p.dict.get(b"Resources").and_then(|resource| doc.resolve(resource).as_dict().cloned()).unwrap_or_default();+ let (mut fonts, mut metrics) = page_font_metrics(doc, &res, block, lines);+ let (dx, dy, width) = paragraph_geometry(doc, &p, block, style)?;+ let prepared = CharacterPreparation {+ doc,+ first,+ lines,+ draft,+ spans: styled_spans,+ style,+ overrides: &overrides,+ fonts: &mut fonts,+ metrics: &mut metrics,+ max_glyphs,}+ .prepare()?;+ let chars = prepared.values;+ let substituted = prepared.substituted;let size_of = |source: &TextLine, index: usize| {overrides.get(&index).and_then(|r| r.size).or(style.size).unwrap_or(source.size).max(0.1) / source.origin.k.max(1e-6)};@@ -400,23 +712,7 @@ pub(crate) fn rewrite_styled_block(spaces.borrow_mut().insert(name.to_owned(), w);w};- let mut calibration = HashMap::new();- for (index, source) in lines.iter().enumerate() {- if let Some(m) = metrics.get(&source.font) {- let nominal = source_width(- m,- &source.text,- source.origin.state.font.as_ref().map_or(1.0, |(_, s)| *s),- space_of(&source.font, m),- source.origin.state.char_spacing,- source.origin.state.word_spacing,- ) * source.origin.state.scale- * across(source);- let changed_face = style.resource.is_some() || overrides.get(&index).is_some_and(|r| r.family.is_some() || r.resource.is_some());- let factor = if nominal > 0.0 && !changed_face { ((source.rect[2] - source.rect[0]) / nominal).clamp(0.5, 2.0) } else { 1.0 };- calibration.insert(index, factor);- }- }+ let calibration = calibration_factors(lines, &metrics, style, &overrides, space_of);let advance = |item: &(char, usize, String)| -> f64 {let source = lines.get(item.1).unwrap_or(first);let Some(m) = metrics.get(&item.2) else { return 0.0 };@@ -466,58 +762,7 @@ pub(crate) fn rewrite_styled_block(}Ok(width)};- let mut rows: Vec<Vec<(char, usize, String)>> = Vec::new();- // Each row's characters, as indexes into the draft's characters (`chars` holds all of them).- let mut row_ranges = Vec::new();- let mut row_start = 0;- let mut row = Vec::new();- let mut row_width = 0.0;- // Wrap at word boundaries, retaining explicit source row breaks and whitespace.- let mut at = 0;- while at < chars.len() {- let Some(item) = chars.get(at) else { break };- // The CR of a CRLF: the `\n` after it breaks the row.- if item.0 == '\r' {- at += 1;- continue;- }- if item.0 == '\n' {- row_ranges.push(row_start..row_start + row.len());- rows.push(std::mem::take(&mut row));- row_width = 0.0;- at += 1;- row_start = at;- continue;- }- let mut end = at + 1;- if !item.0.is_whitespace() {- // A word ends at a space, or where Chinese or Japanese text may break between characters.- while let (Some(before), Some(c)) = (chars.get(end - 1), chars.get(end))- && !c.0.is_whitespace()- && !crate::linebreak::between(before.0, c.0)- {- end += 1;- }- }- let word = chars.get(at..end).unwrap_or_default();- let w = measure(word)?;- if !row.is_empty() && !item.0.is_whitespace() && row_width + w > width + 0.5 {- while row.last().is_some_and(|c: &(char, usize, String)| c.0.is_whitespace()) {- row.pop();- }- row_ranges.push(row_start..row_start + row.len());- rows.push(std::mem::take(&mut row));- row_width = 0.0;- row_start = at;- }- row.extend_from_slice(word);- row_width += w;- at = end;- }- if !row.is_empty() {- row_ranges.push(row_start..row_start + row.len());- rows.push(row);- }+ let (rows, row_ranges) = wrap_styled_rows(&chars, width, measure)?;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;@@ -531,65 +776,18 @@ pub(crate) fn rewrite_styled_block(};let kept_lines: std::collections::HashSet<usize> =kept.iter().enumerate().filter(|(_, k)| **k).filter_map(|(r, _)| block.rows.get(r)).flatten().copied().collect();- let rewritten: Vec<&TextLine> = block.lines.iter().filter(|i| !kept_lines.contains(i)).filter_map(|i| lines.get(*i)).collect();- // The rewrite goes where the last rewritten row was drawn, after any backgrounds painted- // between the rows. A dropped `'` or `"` also moved to the next line, which a kept row relies on.- let lead =- rewritten.last().copied().filter(|_| !rewritten.iter().flat_map(|l| &l.ops).any(|i| ops.get(*i).is_some_and(|op| op.is("'") || op.is("\""))));- let (members, lead) = match lead {- Some(lead) if !kept_lines.is_empty() => (rewritten, lead),- _ => {- kept.iter_mut().for_each(|k| *k = false);- let all: Vec<&TextLine> = block.lines.iter().filter_map(|i| lines.get(*i)).collect();- let last = all.last().copied().unwrap_or(first);- (all, last)- }- };+ // The rewrite is placed after the last rewritten row unless a text-show operator there+ // would make a kept following row depend on that position.+ let anchor = rewrite_anchor(block, lines, first, &ops, &kept_lines, &mut kept);+ let RewriteAnchor { lead, drop, start, split } = anchor;let o = &lead.origin;- let mut drop = coincident_ops(lines, &members);- drop.extend(members.iter().flat_map(|l| l.ops.iter().copied()));- let start = lead.ops.first().copied().unwrap_or(o.bt_op);- let split = ops- .get(o.bt_op..start)- .unwrap_or_default()- .iter()- .enumerate()- .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(o.bt_op + i)));// What is in force where the rewrite is drawn, and what the text after it expects.let after = if split { &o.state } else { &o.bt_state };- for (row, _) in rows.iter().zip(&kept).filter(|(_, k)| !**k) {- let text: String = row.iter().map(|v| v.0).collect();- if pdfcraft_fonts::source_shaping::required(&text) && row.first().is_some_and(|first| row.iter().any(|v| v.1 != first.1 || v.2 != first.2)) {- return Err(EditError::Invalid(- "contextual/bidi text across font or style boundaries needs a uniform full-face row; mixed contextual runs are not yet supported"- .into(),- ));- }- }- let measured: Vec<_> = rows.iter().map(|r| measure(r)).collect::<Result<_, _>>()?;- let mut shaped_runs = HashMap::new();- let mut segment_advances = HashMap::new();- for (row_index, row) in rows.iter().enumerate().filter(|(r, _)| !kept.get(*r).copied().unwrap_or(false)) {- let mut at = 0;- while let Some(item) = row.get(at) {- let mut end = at + 1;- while row.get(end).is_some_and(|v| v.1 == item.1 && v.2 == item.2) {- end += 1;- }- segment_advances.insert((row_index, at), row.get(at..end).unwrap_or_default().iter().map(&advance).sum::<f64>());- let string: String = row.get(at..end).unwrap_or_default().iter().map(|v| v.0).collect();- if let Some((bytes, shaped, family)) = shape_source(doc, &fonts, &item.2, &string)? {- shaped_runs.insert((row_index, at), (bytes, shaped, family));- }- at = end;- }- }- let mut glyph_resources = HashMap::new();- for (key, (bytes, shaped, family)) in &shaped_runs {- let mappings: Vec<_> = shaped.glyphs.iter().map(|g| (g.text.clone(), g.id)).collect();- let resource = pdfcraft_fonts::embedding::embed_mapping(doc, &mut fonts, bytes, family, &mappings).map_err(EditError::Invalid)?;- glyph_resources.insert(*key, resource);- }+ validate_contextual_rows(&rows, &kept)?;+ let measured: Vec<_> = rows.iter().map(|row| measure(row)).collect::<Result<_, _>>()?;+ let shaped = prepare_shaped_rows(doc, &fonts, &rows, &kept, advance)?;+ let ShapedRows { runs: shaped_runs, advances: segment_advances } = shaped;+ let glyph_resources = embed_shaped_resources(doc, &mut fonts, &shaped_runs)?;let n = pdfcraft_content::num;let mut block_ops = vec![Op::new("q", vec![])];block_ops.extend(reveal_ops(block, lines, style, o.ctm)?);diff --git a/crates/edit/src/text_session.rs b/crates/edit/src/text_session.rsindex 893a0e4d2..fe1aa7868 100644--- a/crates/edit/src/text_session.rs+++ b/crates/edit/src/text_session.rs@@ -3,7 +3,10 @@//! another one's output; the commit writes into the document it was opened on, and refuses if//! that document has changed since.-use super::*;+use super::{+ BlockStyle, Document, EditError, LineEdit, MAX_TYPE3_GLYPHS, TextBlock, TextEditLayout, TextLine, group_blocks, layout_draft, rewrite_block_from,+ text_lines,+};/// One paragraph being edited: the document as it was opened, and the page's lines then.pub struct TextSession {