PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
M7: restore the exact gap a wrap consumed, not a guessed space (#2517)
ihsan mokhlissebb7186d87c71
diff --git a/crates/edit/src/tests.rs b/crates/edit/src/tests.rsindex 7ba088722..5491dfca4 100644--- a/crates/edit/src/tests.rs+++ b/crates/edit/src/tests.rs@@ -3283,6 +3283,59 @@ fn a_wrapped_line_rejoins_when_widened_and_a_typed_break_stays() {assert_eq!(text::text_blocks(&typed, 0).unwrap()[0].editor_text, "One\nTwo\nThree\nfour");}+/// #2529 (reviewer): a run of typed spaces that happens to fall at a wrap point is not the same+/// as the single space an ordinary word gap leaves. Narrowing drops the whole gap, as any wrap+/// does (#4199's own test: `wrapped("aa bb cc", 6.0) == ["aa bb", "cc"]`); widening it back+/// must not quietly turn two typed spaces into one.+#[test]+fn narrowing_then_widening_keeps_a_typed_double_space() {+ let mut doc = text_page("BT /F1 24 Tf 20 150 Td (One Two) Tj ET");+ let wide = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap().rect;+ let wide_width = wide[2] - wide[0];+ text::rewrite_block(&mut doc, 0, 0, None, &text::BlockStyle { width: Some(45.0), ..Default::default() }).unwrap();+ let block = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap();+ assert_eq!(block.editor_text, "One\nTwo", "the narrow box did not wrap between the two typed spaces: {}", block.editor_text);+ text::rewrite_block(&mut doc, 0, 0, Some(&block.reflow_text), &text::BlockStyle { width: Some(wide_width), ..Default::default() }).unwrap();+ let rewidened = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap();+ assert_eq!(rewidened.editor_text, "One Two", "the second typed space was lost: {:?}", rewidened.editor_text);+}++/// #2529: a Chinese/Japanese word split has no space of its own (`wrap`'s own doc comment: "those+/// pieces join without a space"). Narrowing a paragraph until it wraps inside such a word, then+/// widening it back, must restore the two pieces exactly as they were, not insert a space between+/// them. Checked on both the single-style rewrite path and the row-editor (mixed-style) path.+#[test]+fn narrowing_then_widening_a_japanese_word_adds_no_space() {+ if pdfcraft_fonts::document_japanese_font().is_none() {+ eprintln!("skipping narrowing_then_widening_a_japanese_word_adds_no_space: built without craft-fonts (set CRAFT_FONTS_DIR)");+ return;+ }+ let text = "日本語の文章です";+ for draft in [text.to_string(), format!("見出し\n{text}")] {+ let mut doc = text_page("BT /F1 12 Tf 72 700 Td (Placeholder text) Tj ET");+ text::rewrite_block(&mut doc, 0, 0, Some(&draft), &text::BlockStyle { width: Some(400.0), ..Default::default() }).unwrap();+ let wide = text::text_blocks(&reopen(&doc), 0).unwrap().into_iter().next().unwrap();+ let wide_width = wide.rect[2] - wide.rect[0];++ // Narrow enough to force a wrap inside the Japanese word, not just between the two rows.+ // A width-only change must pass `reflow_text` explicitly, as the editor UI does: `None`+ // falls back to the paragraph's space-joined display text and would not keep a typed break.+ text::rewrite_block(&mut doc, 0, 0, Some(&wide.reflow_text), &text::BlockStyle { width: Some(60.0), ..Default::default() }).unwrap();+ let narrow = text::text_blocks(&reopen(&doc), 0).unwrap().into_iter().next().unwrap();+ assert!(narrow.rows.len() > draft.matches('\n').count() + 1, "the narrow box did not wrap: {:?}", narrow.editor_text);+ assert_eq!(+ narrow.editor_text.replace('\n', ""),+ draft.replace('\n', ""),+ "wrapping must not add or drop characters: {:?}",+ narrow.editor_text+ );++ text::rewrite_block(&mut doc, 0, 0, Some(&narrow.reflow_text), &text::BlockStyle { width: Some(wide_width), ..Default::default() }).unwrap();+ let rewidened = text::text_blocks(&reopen(&doc), 0).unwrap().into_iter().next().unwrap();+ assert_eq!(rewidened.editor_text, draft, "a Japanese word split gained a space it never had: {:?}", rewidened.editor_text);+ }+}+/// A file that did not mark its breaks still rejoins a line that fills the measure, and keeps a/// short line that had room.#[test]diff --git a/crates/edit/src/text.rs b/crates/edit/src/text.rsindex d815ee428..b366e36f4 100644--- a/crates/edit/src/text.rs+++ b/crates/edit/src/text.rs@@ -122,6 +122,10 @@ pub struct TextLine {soft_break: bool,/// This line starts after a break a rewrite kept on purpose (`/PCHard`).hard_break: bool,+ /// When `soft_break`: the exact number of separator characters the wrap consumed (0 for a+ /// Chinese/Japanese word split), from `/PCSoft`'s `/N`; 1 when the marker carried none+ /// (#2529). Meaningless otherwise.+ soft_gap: usize,}impl TextLine {@@ -210,7 +214,7 @@ mod tests {}fn wrapped(text: &str, width: f64) -> Vec<String> {- wrap(text, width, |s| s.chars().count() as f64).into_iter().map(|(line, _)| line).collect()+ wrap(text, width, |s| s.chars().count() as f64).into_iter().map(|(line, _, _)| line).collect()}#[test]@@ -226,8 +230,19 @@ mod tests {#[test]fn a_wrap_is_marked_soft_and_a_newline_is_not() {let width = |s: &str| s.chars().count() as f64;- assert_eq!(wrap("Page 1", 5.0, width), [("Page".into(), false), ("1".into(), true)]);- assert_eq!(wrap("One\nTwo", 10.0, width), [("One".into(), false), ("Two".into(), false)]);+ assert_eq!(wrap("Page 1", 5.0, width), [("Page".into(), false, 0), ("1".into(), true, 1)]);+ assert_eq!(wrap("One\nTwo", 10.0, width), [("One".into(), false, 0), ("Two".into(), false, 0)]);+ }++ /// #2529: a run of spaces that happens to fall at a wrap point is recorded exactly, not+ /// assumed to be one space; a Chinese/Japanese word split, which has no space of its own,+ /// is recorded as none.+ #[test]+ fn a_wrap_records_how_many_spaces_it_consumed() {+ let width = |s: &str| s.chars().count() as f64;+ assert_eq!(wrap("One Two", 5.0, width), [("One".into(), false, 0), ("Two".into(), true, 2)]);+ assert_eq!(wrap("One Two", 5.0, width), [("One".into(), false, 0), ("Two".into(), true, 3)]);+ assert_eq!(wrap("日本語の文章です", 3.0, width), [("日本語".into(), false, 0), ("の文章".into(), true, 0), ("です".into(), true, 0)]);}/// #4199: a run of spaces stays a run, before, between and after words; the spaces where adiff --git a/crates/edit/src/text/blocks.rs b/crates/edit/src/text/blocks.rsindex 2785f8767..d6dcc585f 100644--- a/crates/edit/src/text/blocks.rs+++ b/crates/edit/src/text/blocks.rs@@ -340,13 +340,18 @@ pub(crate) fn paragraph_separator(c: char) -> bool {/// new line. A row may also end inside a word of Chinese or Japanese text ([`crate::linebreak`]);/// those pieces join without a space. Every white-space character is written as one space, so/// a run of spaces typed between, before or after words stays (#4199); only the spaces where a-/// row wraps are dropped. The bool is true when the line continues the previous one because the-/// next word did not fit, rather than because of a newline.-pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<(String, bool)> {+/// row wraps are dropped (recorded as the third value, so a later rejoin can restore the exact+/// count instead of guessing one, #2529). The bool is true when the line continues the previous+/// one because the next word did not fit, rather than because of a newline; the number is how+/// many separator characters stood where that wrap fell (0 for a Chinese/Japanese word split,+/// which has no space of its own; meaningless when the bool is false).+pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<(String, bool, usize)> {let mut out = Vec::new();for row in text.split('\n') {let mut line = String::new();let mut soft = false;+ // The gap consumed right before `line` started: 0 until a wrap sets it.+ let mut wrap_gap = 0usize;let start = out.len();// The separators read since the last word: each one boundary between `split` pieces.let mut gap = 0usize;@@ -357,13 +362,17 @@ pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vecif word.is_empty() {continue;}- let spaces = " ".repeat(std::mem::take(&mut gap));+ let gap_here = std::mem::take(&mut gap);+ let spaces = " ".repeat(gap_here);for (i, piece) in crate::linebreak::pieces(word).into_iter().enumerate() {let candidate = if i == 0 { format!("{line}{spaces}{piece}") } else { format!("{line}{piece}") };// A row holding only the spaces that indent it doesn't wrap before its first word.if line.chars().any(|c| c != ' ') && advance(&candidate) > width {- out.push((std::mem::take(&mut line), soft));+ out.push((std::mem::take(&mut line), soft, wrap_gap));soft = true;+ // A mid-word piece (i > 0) had no separator of its own; the first piece of a+ // word had exactly the separators just taken.+ wrap_gap = if i == 0 { gap_here } else { 0 };line = piece.to_string();} else {line = candidate;@@ -372,7 +381,7 @@ pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec}line.push_str(&" ".repeat(gap));if !line.is_empty() || out.len() == start {- out.push((line, soft));+ out.push((line, soft, wrap_gap));}}outdiff --git a/crates/edit/src/text/interp.rs b/crates/edit/src/text/interp.rsindex e3e4bf26b..73ca1b142 100644--- a/crates/edit/src/text/interp.rs+++ b/crates/edit/src/text/interp.rs@@ -304,6 +304,11 @@ pub(super) struct Shown {/// Set when a `/PCSoft` or `/PCHard` marker was seen since the previous text line.pub(super) soft_break: bool,pub(super) hard_break: bool,+ /// The `/N` a `/PCSoft` marker carried: how many separator characters the wrap consumed (0+ /// for a Chinese/Japanese word split). Meaningless unless `soft_break` is set; 1 for a+ /// `/PCSoft` with no `/N` (a file saved before this was tracked, or by another writer),+ /// matching the single space a rejoin always used before #2529.+ pub(super) soft_gap: usize,}impl Shown {@@ -554,6 +559,7 @@ struct TextRunState<'a> {out: &'a mut Vec<Shown>,soft_break: bool,hard_break: bool,+ soft_gap: usize,}fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), EditError> {@@ -752,6 +758,7 @@ fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), Editactual_text: false,soft_break: state.soft_break,hard_break: state.hard_break,+ soft_gap: state.soft_gap,});Ok(())}@@ -780,6 +787,10 @@ pub(super) fn interpret(// before the next line. Neither name is a paragraph region, so it does not change scope.let mut soft_break = false;let mut hard_break = false;+ // `/PCSoft`'s `/N` property: how many separator characters the wrap consumed. A `/PCSoft`+ // with no properties dict (a file saved before this was tracked, or by another writer) reads+ // as 1, the single space a rejoin always used before #2529.+ let mut soft_gap = 1usize;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@@ -788,6 +799,14 @@ pub(super) fn interpret(if op.name(0) == Some(b"PCSoft") {soft_break = true;hard_break = false;+ soft_gap = op+ .operands+ .get(1)+ .and_then(Object::as_dict)+ .and_then(|d| d.get(b"N"))+ .and_then(Object::as_int)+ .and_then(|n| usize::try_from(n).ok())+ .unwrap_or(1);} else if op.name(0) == Some(b"PCHard") {hard_break = true;soft_break = false;@@ -908,6 +927,7 @@ pub(super) fn interpret(out: &mut out,soft_break,hard_break,+ soft_gap,};show_text(op, i, &mut state)?;// A numeric-only TJ adjustment shows no glyphs and pushes nothing: the break@@ -915,6 +935,7 @@ pub(super) fn interpret(if out.len() > before {soft_break = false;hard_break = false;+ soft_gap = 1;}}_ => {}diff --git a/crates/edit/src/text/lines.rs b/crates/edit/src/text/lines.rsindex 78aec5090..f811f34ea 100644--- a/crates/edit/src/text/lines.rs+++ b/crates/edit/src/text/lines.rs@@ -282,6 +282,7 @@ fn text_lines_in(doc: &Document, p: &pdfcraft_model::Page, actual_text: bool) ->runs: vec![(s.text.clone(), s.ink.len(), false)],soft_break: s.soft_break,hard_break: s.hard_break,+ soft_gap: s.soft_gap,ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),origin: Origin {tm: s.tm.0,@@ -398,6 +399,7 @@ fn add_shown(lines: &mut Vec<TextLine>, last: &mut Option<Pen>, s: Shown, streamruns: vec![(s.text.clone(), s.ink.len(), false)],soft_break: s.soft_break,hard_break: s.hard_break,+ soft_gap: s.soft_gap,ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),origin: Origin {tm: s.tm.0,diff --git a/crates/edit/src/text/rewrite.rs b/crates/edit/src/text/rewrite.rsindex 9589fad22..4b6944dee 100644--- a/crates/edit/src/text/rewrite.rs+++ b/crates/edit/src/text/rewrite.rs@@ -578,27 +578,38 @@ impl LineWriter<'_> {}}- /// Writes one wrapped line, returning its underline (x0, x1, y) in text space.+ /// Writes one wrapped line, returning its underline (x0, x1, y) in text space. `wrap`: whether+ /// this line continues the previous one because a word did not fit, and, when it does, how+ /// many separator characters the wrap consumed (0 for a Chinese/Japanese word split).fn write_line(&self,index: usize,line: &str,- soft: bool,+ wrap: (bool, usize),last: bool,cursor: &mut LineCursor,ops: &mut Vec<Op>,) -> Result<(f64, f64, f64), EditError> {let n = pdfcraft_content::num;+ let (soft, gap) = wrap;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 {- // Inside this text object, so the marker starts and ends here. `/PCSoft` rejoins- // when the box widens. `/PCHard` is a newline that was already in the text.- let name = if soft { "PCSoft" } else { "PCHard" };- ops.push(Op::new("BMC", vec![Object::name(name)]));+ // Inside this text object, so the marker starts and ends here. `/PCHard` is a newline+ // that was already in the text. `/PCSoft` rejoins when the box widens, with `/N` the+ // exact number of separator characters the wrap consumed (0 for a Chinese/Japanese+ // word split), so a rejoin restores what was actually there instead of guessing a+ // single space and silently dropping the rest of a typed run (#2529).+ if soft {+ let mut properties = Dict::new();+ properties.set(b"N".to_vec(), Object::Int(i64::try_from(gap).unwrap_or(i64::MAX)));+ ops.push(Op::new("BDC", vec![Object::name("PCSoft"), Object::Dict(properties)]));+ } else {+ ops.push(Op::new("BMC", vec![Object::name("PCHard")]));+ }ops.push(Op::new("EMC", vec![]));}if index > 0 || dx != 0.0 {@@ -648,11 +659,11 @@ impl LineWriter<'_> {}/// Writes every wrapped line, returning their underlines.- fn write_all(&self, wrapped: &[(String, bool)], cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<Vec<(f64, f64, f64)>, EditError> {+ fn write_all(&self, wrapped: &[(String, bool, usize)], cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<Vec<(f64, f64, f64)>, EditError> {wrapped.iter().enumerate()- .map(|(i, (line, soft))| self.write_line(i, line, *soft, i + 1 == wrapped.len(), cursor, ops))+ .map(|(i, (line, soft, gap))| self.write_line(i, line, (*soft, *gap), i + 1 == wrapped.len(), cursor, ops)).collect()}}@@ -672,7 +683,7 @@ struct BlockPlan<'a> {underline: bool,}-fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[(String, bool)], show_font: String) -> Result<Vec<Op>, EditError> {+fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[(String, bool, usize)], 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)?);diff --git a/crates/edit/src/text_regions/grouping.rs b/crates/edit/src/text_regions/grouping.rsindex df281eb92..26f934339 100644--- a/crates/edit/src/text_regions/grouping.rs+++ b/crates/edit/src/text_regions/grouping.rs@@ -365,14 +365,17 @@ fn reflow_text(block: &TextBlock, lines: &[TextLine]) -> String {let mut out = String::new();for (index, part) in parts.iter().enumerate() {if index > 0 {- if break_is_soft(block, lines, index) {- if out.ends_with('-') {+ match break_gap(block, lines, index) {+ Some(_) if out.ends_with('-') => {out.pop();- } else if !out.ends_with(char::is_whitespace) {- out.push(' ');}- } else {- out.push('\n');+ // `gap` is the exact number of separator characters the wrap consumed (0 for a+ // Chinese/Japanese word split, which has no space of its own) when the marker or+ // the source recorded it; a line already ending in whitespace is left alone so a+ // row whose own text kept a trailing space isn't doubled.+ Some(gap) if !out.ends_with(char::is_whitespace) => out.push_str(&" ".repeat(gap)),+ Some(_) => {}+ None => out.push('\n'),}}out.push_str(part);@@ -380,20 +383,24 @@ fn reflow_text(block: &TextBlock, lines: &[TextLine]) -> String {out}-fn break_is_soft(block: &TextBlock, lines: &[TextLine], row_index: usize) -> bool {- let Some(line) = block.rows.get(row_index).and_then(|row| row.first()).and_then(|i| lines.get(*i)) else { return false };+/// `None`: a hard break, kept as a newline. `Some(gap)`: a soft wrap, rejoined with exactly `gap`+/// spaces — the count a `/PCSoft` marker recorded ([`TextLine::soft_gap`]), or, for a line this+/// app did not mark (a file written elsewhere, or an older save), a single space when the+/// geometry looks like an ordinary wrapped body line (`#2529`).+fn break_gap(block: &TextBlock, lines: &[TextLine], row_index: usize) -> Option<usize> {+ let line = block.rows.get(row_index).and_then(|row| row.first()).and_then(|i| lines.get(*i))?;if line.hard_break {- return false;+ return None;}if line.soft_break {- return true;+ return Some(line.soft_gap);}- let Some(prev) = block.rows.get(row_index.wrapping_sub(1)).and_then(|row| row_rect(row, lines)) else { return false };- let Some(next) = block.rows.get(row_index).and_then(|row| row_rect(row, lines)) else { return false };+ let prev = block.rows.get(row_index.wrapping_sub(1)).and_then(|row| row_rect(row, lines))?;+ let next = block.rows.get(row_index).and_then(|row| row_rect(row, lines))?;let size = line.size.max(1.0);let slack = block.rect[2] - prev[2];let width = prev[2] - prev[0];// Short rows define the right edge by their own letters. A body line that fills the// measure leaves almost no room for the next word.- slack <= size * 0.75 && width >= size * 8.0 && (next[2] - next[0]) + size * 0.25 > slack+ (slack <= size * 0.75 && width >= size * 8.0 && (next[2] - next[0]) + size * 0.25 > slack).then_some(1)}diff --git a/crates/edit/src/text_regions/styled.rs b/crates/edit/src/text_regions/styled.rsindex be7e627ba..ea18a2a21 100644--- a/crates/edit/src/text_regions/styled.rs+++ b/crates/edit/src/text_regions/styled.rs@@ -405,12 +405,17 @@ fn wrap_styled_rows(chars: &[StyledChar],width: f64,measure: impl Fn(&[StyledChar]) -> Result<f64, EditError>,-) -> Result<(StyledRows, RowRanges, Vec<bool>), EditError> {+) -> Result<(StyledRows, RowRanges, Vec<bool>, Vec<usize>), EditError> {let mut rows: Vec<Vec<StyledChar>> = Vec::new();let mut row_ranges = Vec::new();// True when this row starts because the previous word did not fit, not because of a newline.let mut row_soft = Vec::new();let mut next_soft = false;+ // How many separator characters a wrap trimmed off the row that just ended, for the row+ // about to start (0 for a Chinese/Japanese word split, which trims none; meaningless unless+ // the row it belongs to is soft). Mirrors `next_soft`.+ let mut row_gap = Vec::new();+ let mut next_gap = 0usize;let mut row_start = 0;let mut row = Vec::new();let mut row_width = 0.0;@@ -424,6 +429,8 @@ fn wrap_styled_rows(if item.0 == '\n' {row_soft.push(next_soft);next_soft = false;+ row_gap.push(next_gap);+ next_gap = 0;row_ranges.push(row_start..row_start + row.len());rows.push(std::mem::take(&mut row));row_width = 0.0;@@ -444,11 +451,15 @@ fn wrap_styled_rows(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 {+ let mut trimmed = 0usize;while row.last().is_some_and(|c: &StyledChar| c.0.is_whitespace()) {row.pop();+ trimmed += 1;}row_soft.push(next_soft);next_soft = true;+ row_gap.push(next_gap);+ next_gap = trimmed;row_ranges.push(row_start..row_start + row.len());rows.push(std::mem::take(&mut row));row_width = 0.0;@@ -460,10 +471,11 @@ fn wrap_styled_rows(}if !row.is_empty() {row_soft.push(next_soft);+ row_gap.push(next_gap);row_ranges.push(row_start..row_start + row.len());rows.push(row);}- Ok((rows, row_ranges, row_soft))+ Ok((rows, row_ranges, row_soft, row_gap))}fn apply_range_styles<'a>(@@ -745,6 +757,78 @@ fn rewrite_anchor<'a>(RewriteAnchor { lead, drop, start, split }}+/// Open (`op` is `"BMC"`) or close (`"EMC"`) the `/P` marker that wraps the whole rewrite when+/// `marked` (every row is in this rewrite, see [`rewrite_styled_block`]), so the paragraph+/// cannot be mistaken for a neighbour by geometry alone (#2517).+fn push_whole_paragraph_marker(block_ops: &mut Vec<Op>, marked: bool, op: &str) {+ if !marked {+ return;+ }+ let operands = if op == "BMC" { vec![Object::name("P")] } else { Vec::new() };+ block_ops.push(Op::new(op, operands));+}++/// An empty marker between two rows of one rewrite. `/PCHard` is a newline that was already in+/// the text. `/PCSoft` is a wrap and rejoins when the box widens, with `/N` the exact number of+/// separator characters it consumed (0 for a Chinese/Japanese word split), so a rejoin restores+/// what was actually there instead of guessing a single space (#2529). Neither is a paragraph+/// region, so the lines stay in one scope.+fn push_row_break_marker(block_ops: &mut Vec<Op>, row_soft: &[bool], row_gap: &[usize], row_index: usize) {+ if row_soft.get(row_index).copied().unwrap_or(false) {+ let mut properties = Dict::new();+ let gap = row_gap.get(row_index).copied().unwrap_or(1);+ properties.set(b"N".to_vec(), Object::Int(i64::try_from(gap).unwrap_or(i64::MAX)));+ block_ops.push(Op::new("BDC", vec![Object::name("PCSoft"), Object::Dict(properties)]));+ } else {+ block_ops.push(Op::new("BMC", vec![Object::name("PCHard")]));+ }+ block_ops.push(Op::new("EMC", vec![]));+}++/// [`splice`] with the rewritten rows spliced in at `at`, and (when `marker` names one) a `/P`+/// marker opened at its start and closed at its `next` line or, when nothing follows, after the+/// paragraph's own last `ET` (appended past the stream's last operator when that close is at or+/// beyond `ops.len()`, since `splice`'s callback never visits that index).+fn splice_with_marker(+ pieces: &Pieces,+ ops: &[Op],+ marker: Option<(usize, Option<usize>, usize)>,+ at: usize,+ mut block_ops: Vec<Op>,+ drop: &std::collections::HashSet<usize>,+) -> Vec<Vec<u8>> {+ let data = splice(pieces, ops, |i| {+ let mut insert = Vec::new();+ if let Some((start_at, next, close)) = marker {+ if i == start_at {+ insert.push(Op::new("BMC", vec![Object::name("P")]));+ }+ if next.is_none() && i == close {+ insert.push(Op::new("EMC", vec![]));+ }+ if next == Some(i) {+ insert.push(Op::new("EMC", vec![]));+ }+ }+ if i == at {+ insert.append(&mut block_ops);+ }+ (insert, !drop.contains(&i))+ });+ if !marker.is_some_and(|(_, next, close)| next.is_none() && close >= ops.len()) {+ return data;+ }+ let mut data = data;+ if let Some(last) = data.last_mut() {+ if last.last().is_some_and(|byte| !byte.is_ascii_whitespace()) {+ last.push(b'\n');+ }+ // `splice` never visits `ops.len()`, so a close after the final operator is appended.+ last.extend_from_slice(&pdfcraft_content::serialize_ops(&[Op::new("EMC", vec![])]));+ }+ data+}+/// 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(@@ -856,7 +940,7 @@ pub(crate) fn rewrite_styled_block(}Ok(width)};- let (rows, row_ranges, row_soft) = wrap_styled_rows(&chars, width, measure)?;+ let (rows, row_ranges, row_soft, row_gap) = 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;@@ -895,9 +979,7 @@ pub(crate) fn rewrite_styled_block(// scope so the neighbour stays out (#2517). A row left in the source stream cannot share// that marker, so it is omitted and geometry groups those rows as before.let marked = kept.iter().all(|row| !*row);- if marked {- block_ops.push(Op::new("BMC", vec![Object::name("P")]));- }+ push_whole_paragraph_marker(&mut block_ops, marked, "BMC");let crop = p.crop(doc);let centered = is_centred(block, lines, (crop[0] + crop[2]) / 2.0, first.size);let source_leading = block@@ -926,12 +1008,7 @@ pub(crate) fn rewrite_styled_block(continue;}if !row.is_empty() && row_index > 0 {- // An empty marker between lines. `/PCSoft` is a wrap and rejoins when the box- // widens. `/PCHard` is a newline that was already in the text. Neither is a- // paragraph region, so the lines stay in one scope.- let name = if row_soft.get(row_index).copied().unwrap_or(false) { "PCSoft" } else { "PCHard" };- block_ops.push(Op::new("BMC", vec![Object::name(name)]));- block_ops.push(Op::new("EMC", vec![]));+ push_row_break_marker(&mut block_ops, &row_soft, &row_gap, row_index);}let w = measured.get(row_index).copied().unwrap_or(0.0);let align = style.align.unwrap_or(if centered { crate::added::Align::Center } else { crate::added::Align::Left });@@ -1076,9 +1153,7 @@ pub(crate) fn rewrite_styled_block(style.line_spacing.unwrap_or(1.5).clamp(0.5, 5.0) * style.size.unwrap_or(anchor.size)};}- if marked {- block_ops.push(Op::new("EMC", vec![]));- }+ push_whole_paragraph_marker(&mut block_ops, marked, "EMC");block_ops.push(Op::new("Q", vec![]));block_ops.extend(after.ops());if split {@@ -1091,37 +1166,7 @@ pub(crate) fn rewrite_styled_block(// safe. The close is not part of `block_ops`: that vector can end inside a text object// when the rewrite splits one, and a kept row's operators come later in the stream.let marker = if marked { None } else { paragraph_marker(block, lines, &ops) };- let data = splice(&pieces, &ops, |i| {- let mut insert = Vec::new();- if let Some((start_at, next, close)) = marker {- if i == start_at {- insert.push(Op::new("BMC", vec![Object::name("P")]));- }- if next.is_none() && i == close {- insert.push(Op::new("EMC", vec![]));- }- if next == Some(i) {- insert.push(Op::new("EMC", vec![]));- }- }- if i == at {- insert.append(&mut block_ops);- }- (insert, !drop.contains(&i))- });- let data = if marker.is_some_and(|(_, next, close)| next.is_none() && close >= ops.len()) {- let mut data = data;- if let Some(last) = data.last_mut() {- if last.last().is_some_and(|byte| !byte.is_ascii_whitespace()) {- last.push(b'\n');- }- // `splice` never visits `ops.len()`, so a close after the final operator is appended.- last.extend_from_slice(&pdfcraft_content::serialize_ops(&[Op::new("EMC", vec![])]));- }- data- } else {- data- };+ let data = splice_with_marker(&pieces, &ops, marker, at, block_ops, &drop);let contents = rewritten_contents(doc, &streams, data);res.set(b"Font".to_vec(), Object::Dict(fonts));doc.update_dict(p.obj, |d| {