DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
PDF: right-to-left text extracts in reading order
aiongg2b96dffda145
diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rsindex c4aad577c..c9c7bae82 100644--- a/crates/pdf/src/lib.rs+++ b/crates/pdf/src/lib.rs@@ -200,6 +200,8 @@ pub fn parse_page_range(s: &str, count: usize) -> Result<Vec<usize>> {Ok(out)}+#[cfg(test)]+mod rtl_tests;#[cfg(test)]mod tests;diff --git a/crates/pdf/src/rtl_tests.rs b/crates/pdf/src/rtl_tests.rsnew file mode 100644index 000000000..fc38747a7--- /dev/null+++ b/crates/pdf/src/rtl_tests.rs@@ -0,0 +1,190 @@+//! Right-to-left text in exported PDFs: content streams list it in reading order with marks after+//! their letters, lines with right-to-left text carry their reading-order text as ActualText, and+//! glyphs stay where composition put them.++use designcraft_compose::{Cache, ComposeOptions, compose_story};+use designcraft_doc::build::NewDocument;+use designcraft_doc::{Align, Document, ParaAttrs, ParaFormat, SpreadRef, TextDirection};+use designcraft_geom::Rect;++use crate::tests::extract_text;+use crate::*;++const HEBREW: &str = "DC Test PDF Hebrew";+const ARABIC: &str = "DC Test PDF Arabic";++/// A stand-in Hebrew font: each letter and point has a glyph of its own (Latin capitals and+/// combining accents of the bundled face), so the ToUnicode map is unambiguous.+fn hebrew_font() {+ let letters = ['ד', 'ו', 'ש', 'ר', 'ה', 'י', 'א', 'ל', 'ב', 'ם', 'צ', 'ח', 'ק', 'ע'];+ let points = ['\u{5B7}', '\u{5B0}', '\u{5B8}', '\u{5B4}', '\u{5B2}', '\u{5B9}'];+ let accents = ['\u{300}', '\u{301}', '\u{302}', '\u{303}', '\u{304}', '\u{308}'];+ let mut map: Vec<(char, char)> = letters.iter().zip('A'..).map(|(h, l)| (*h, l)).collect();+ map.extend(points.iter().copied().zip(accents));+ map.extend(" &abcdef".chars().map(|c| (c, c)));+ designcraft_fonts::FontDb::global().add_font(designcraft_fonts::testing::font_mapping(HEBREW, &map).expect("font"));+}++/// A stand-in Arabic font with a tatweel, so justification inserts kashidas.+fn arabic_font() {+ let map = [('ب', 'b'), ('س', 's'), ('م', 'm'), ('ا', 'a'), ('ل', 'l'), ('ه', 'h'), ('\u{640}', '_'), (' ', ' ')];+ designcraft_fonts::FontDb::global().add_font(designcraft_fonts::testing::font_mapping(ARABIC, &map).expect("font"));+}++/// One frame of `text` in `family` with paragraph attributes `para`.+fn doc(text: &str, family: &str, r: Rect, para: ParaAttrs) -> Document {+ let mut d = Document::new(&NewDocument::default());+ let lid = d.default_layer();+ d.add_text_frame(SpreadRef::Doc(0), r, lid, text, ParaFormat { para, ..ParaFormat::default() }).unwrap();+ let sid = *d.stories.keys().next().unwrap();+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| f.over.font_family = Some(family.into()));+ d+}++fn rtl() -> ParaAttrs {+ ParaAttrs { direction: Some(TextDirection::RightToLeft), ..ParaAttrs::default() }+}++/// The ActualText of every line span (marked content with an MCID) on the first page.+fn line_actual_texts(bytes: &[u8]) -> Vec<String> {+ use hayro_syntax::content::ops::TypedInstruction;+ use hayro_syntax::object::{Dict, Object};+ let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("parse");+ let page = &pdf.pages()[0];+ let mut out = Vec::new();+ let mut ops = page.typed_operations();+ while let Some(op) = ops.next() {+ let TypedInstruction::BeginMarkedContentWithProperties(op) = op else { continue };+ let Object::Dict(props) = op.1 else { continue };+ let props: &Dict<'_> = props;+ if !props.contains_key(b"MCID") {+ continue;+ }+ let Some(s) = props.get::<hayro_syntax::object::String>(b"ActualText") else { continue };+ let units: Vec<u16> = s.as_bytes().chunks_exact(2).map(|b| u16::from_be_bytes([b[0], b[1]])).collect();+ let text = String::from_utf16(&units).expect("UTF-16");+ out.push(text.trim_start_matches('\u{FEFF}').to_string());+ }+ out+}++#[test]+fn hebrew_extracts_in_reading_order_with_points_on_their_letters() {+ hebrew_font();+ let lines = ["דוד & שרה", "ישראל אַבְרָהָם יִצְחָק וְיַעֲקֹב", "דוד abc שרה"];+ let d = doc(&lines.join("\n"), HEBREW, Rect::new(36.0, 36.0, 576.0, 300.0), rtl());+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();+ // Glyph by glyph (ToUnicode, content order): each point right after its letter, once.+ assert_eq!(extract_text(&bytes)[0], lines.concat());+ // Viewers that order text by position read each line's ActualText.+ assert_eq!(line_actual_texts(&bytes), lines);+ // Tagged, the span is the line's tag under its paragraph.+ let tagged = export_pdf(&d, &Cache::new(), &PdfOptions { tagged: true, ..PdfOptions::default() }).unwrap();+ assert_eq!(line_actual_texts(&tagged), lines);+ assert_eq!(extract_text(&tagged)[0], lines.concat());+}++#[test]+fn hebrew_words_in_left_to_right_lines_extract_in_reading_order() {+ hebrew_font();+ let text = "abc דוד & שרה def";+ let d = doc(text, HEBREW, Rect::new(36.0, 36.0, 576.0, 300.0), ParaAttrs::default());+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();+ assert_eq!(extract_text(&bytes)[0], text);+ assert_eq!(line_actual_texts(&bytes), [text]);+ // A line without right-to-left text has no line span.+ let d = doc("abc def", HEBREW, Rect::new(36.0, 36.0, 576.0, 300.0), ParaAttrs::default());+ assert!(line_actual_texts(&export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap()).is_empty());+}++/// Device origin of every glyph drawn on the first page.+fn glyph_origins(bytes: &[u8]) -> Vec<kurbo::Point> {+ use hayro_interpret::font::Glyph;+ use hayro_interpret::{+ BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,+ interpret_page,+ };+ struct Rec(Vec<kurbo::Point>);+ impl Device<'_> for Rec {+ fn set_soft_mask(&mut self, _: Option<SoftMask<'_>>) {}+ fn set_blend_mode(&mut self, _: BlendMode) {}+ fn draw_path(&mut self, _: &kurbo::BezPath, _: kurbo::Affine, _: &Paint<'_>, _: &PathDrawMode) {}+ fn push_clip_path(&mut self, _: &ClipPath) {}+ fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'_>>, _: BlendMode) {}+ fn draw_glyph(&mut self, g: &Glyph<'_>, xf: kurbo::Affine, gxf: kurbo::Affine, _: &Paint<'_>, _: &GlyphDrawMode) {+ if let Glyph::Outline(_) = g {+ self.0.push((xf * gxf) * kurbo::Point::ZERO);+ }+ }+ fn draw_image(&mut self, _: Image<'_, '_>, _: kurbo::Affine) {}+ fn pop_clip_path(&mut self) {}+ fn pop_transparency_group(&mut self) {}+ }+ let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("parse");+ let cache = InterpreterCache::new();+ let mut ctx = Context::new(kurbo::Affine::IDENTITY, kurbo::Rect::new(0.0, 0.0, 1.0, 1.0), &cache, pdf.xref(), InterpreterSettings::default());+ let mut rec = Rec(Vec::new());+ interpret_page(&pdf.pages()[0], &mut ctx, &mut rec);+ rec.0+}++#[test]+fn pointed_letters_are_drawn_where_composed() {+ hebrew_font();+ let text = "יִצְחָק אַבְרָהָם\nיִצְחָק אַבְרָהָם";+ let mut d = doc(text, HEBREW, Rect::new(36.0, 36.0, 576.0, 300.0), rtl());+ let sid = *d.stories.keys().next().unwrap();+ // The second paragraph is skewed: points keep their place relative to their letters.+ let second = text.find('\n').unwrap() + 1;+ d.story_mut(sid).unwrap().format_chars(second..text.len(), |f| f.over.skew = Some(12.0));+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let composed: Vec<kurbo::Point> =+ cs.frames[0].lines.iter().flat_map(|l| l.glyphs.iter().filter(|g| g.visible).map(|g| kurbo::Point::new(g.x, l.baseline + g.y))).collect();+ assert!(composed.iter().any(|p| (p.y - composed[0].y).abs() > 1.0 && (p.y - composed[0].y).abs() < 20.0), "the points sit off the baseline");+ let drawn = glyph_origins(&export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap());+ assert_eq!(drawn.len(), composed.len());+ // The page places the frame (y grows upwards on the page): match the two through their means.+ let mean = |ps: &[kurbo::Point]| ps.iter().fold(kurbo::Vec2::ZERO, |a, p| a + p.to_vec2()) / ps.len() as f64;+ let (c, k) = (mean(&composed), mean(&drawn));+ let key = |x: f64, y: f64| ((x * 100.0).round() as i64, (y * 100.0).round() as i64);+ let mut want: Vec<(i64, i64)> = composed.iter().map(|p| key(p.x - c.x, c.y - p.y)).collect();+ let mut got: Vec<(i64, i64)> = drawn.iter().map(|p| key(p.x - k.x, p.y - k.y)).collect();+ want.sort_unstable();+ got.sort_unstable();+ let off: Vec<_> = want.iter().zip(&got).filter(|(w, g)| (w.0 - g.0).abs() > 1 || (w.1 - g.1).abs() > 1).collect();+ assert!(off.is_empty(), "{off:?}");+}++#[test]+fn kashidas_extract_as_no_text() {+ arabic_font();+ let text = "بسم الله بسم الله بسم الله بسم الله بسم الله بسم الله بسم الله";+ let para = ParaAttrs { align: Some(Align::FullyJustified), ..rtl() };+ let d = doc(text, ARABIC, Rect::new(36.0, 36.0, 186.0, 300.0), para);+ let sid = *d.stories.keys().next().unwrap();+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let kashida = |g: &designcraft_compose::PlacedGlyph| g.len == 0 && g.gid == g.face.glyph_for('\u{640}');+ assert!(cs.frames[0].lines.iter().any(|l| l.glyphs.iter().any(kashida)), "justification inserts kashidas");+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();+ let words: Vec<String> = extract_text(&bytes)[0].split([' ', '\u{FFFD}']).filter(|w| !w.is_empty()).map(str::to_string).collect();+ assert!(words.iter().all(|w| w == "بسم" || w == "الله"), "{words:?}");+ let spans = line_actual_texts(&bytes);+ assert!(spans.len() > 1 && spans.iter().all(|t| !t.contains('\u{640}') && text.contains(t.trim())), "{spans:?}");+}++#[test]+fn arabic_ligatures_extract_their_letters() {+ // Lam-alef in a system font with Arabic (skipped without one).+ let text = "لا سلام";+ let mut d = doc(text, designcraft_fonts::DEFAULT_FAMILY, Rect::new(36.0, 36.0, 576.0, 300.0), rtl());+ d.settings.glyph_fallback = true;+ let sid = *d.stories.keys().next().unwrap();+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let glyphs = &cs.frames[0].lines[0].glyphs;+ if glyphs.iter().any(|g| g.gid == 0) || !glyphs.iter().any(|g| g.byte == 0 && g.len == "لا".len()) {+ return;+ }+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();+ assert_eq!(extract_text(&bytes)[0], text);+ assert_eq!(line_actual_texts(&bytes), [text]);+}diff --git a/crates/pdf/src/text.rs b/crates/pdf/src/text.rsindex bf59efded..e500f8bce 100644--- a/crates/pdf/src/text.rs+++ b/crates/pdf/src/text.rs@@ -1,10 +1,14 @@//! Composed text → PDF text objects with embedded (subsetted) fonts.//!-//! Each line is split into runs of glyphs sharing face, style, scale and baseline offset. A run is-//! drawn with one `draw_glyphs` call: the run origin, horizontal scale and skew go into the-//! transform, glyph advances are taken from the composed x positions (so justification, tracking-//! and kerning are exact), and every glyph carries the story text it came from so viewers can-//! select, search and copy it.+//! Each line is split into runs of glyphs sharing face, style and scale. A run is drawn with one+//! `draw_glyphs` call: the run origin, horizontal scale and skew go into the transform, glyph+//! advances and offsets are taken from the composed positions (so justification, tracking, kerning+//! and mark positioning are exact), and every glyph carries the story text it came from so viewers+//! can select, search and copy it.+//!+//! Composed lines hold their glyphs in text order, so content streams list text in reading order+//! even where right-to-left text is drawn leftwards. Viewers that order text by position instead+//! read the ActualText that a line with right-to-left text carries.use std::collections::HashMap;use std::ops::Range;@@ -36,7 +40,83 @@ fn same_run(a: &PlacedGlyph, b: &PlacedGlyph) -> bool {&& a.style == b.style&& (a.sx - b.sx).abs() < 1e-9&& (a.sy - b.sy).abs() < 1e-9- && (a.y - b.y).abs() < 1e-6+}++/// End of the run of `gs` that starts at `i`.+fn run_end(ft: &FrameText, gs: &[PlacedGlyph], i: usize) -> usize {+ let mut j = i + 1;+ while j < gs.len() && same_run(&gs[i], &gs[j]) && !(ft.vertical && (gs[j].upright || gs[j].tcy.is_some())) {+ j += 1;+ }+ j+}++/// Clusters of several glyphs (a base and its marks, as in pointed Hebrew) map glyph by glyph+/// when every glyph stands for one of the cluster's characters, and are drawn in text order:+/// viewers that only read ToUnicode then get each character once, marks after their base. A+/// glyph stands for a character when it is the font's glyph for it, or when both are marks (a+/// mark's glyph may be a positional variant). Other clusters (ligatures, contextual forms) keep+/// one shared range, which krilla writes as ActualText. Returns the order to draw the glyphs in.+fn split_clusters(glyphs: &[PlacedGlyph], text: &str, ranges: &mut [Range<usize>]) -> Vec<usize> {+ let mut order: Vec<usize> = (0..glyphs.len()).collect();+ let mut i = 0;+ while i < ranges.len() {+ let r = ranges[i].clone();+ let mut j = i + 1;+ while ranges.get(j).is_some_and(|n| *n == r) {+ j += 1;+ }+ if let (Some(cluster), Some(members)) = (text.get(r.clone()).filter(|_| j - i > 1), glyphs.get(i..j))+ && let Some(own) = cluster_chars(members, cluster)+ {+ for (m, (at, c)) in own.into_iter().enumerate() {+ if let Some(range) = ranges.get_mut(i + m) {+ *range = r.start + at..r.start + at + c.len_utf8();+ }+ }+ if let Some(o) = order.get_mut(i..j) {+ o.sort_by_key(|&m| ranges.get(m).map_or(0, |r| r.start));+ }+ }+ i = j;+ }+ order+}++/// The character (byte offset in `cluster`, char) each glyph of a cluster stands for, if each+/// stands for a different one and all are covered.+fn cluster_chars(members: &[PlacedGlyph], cluster: &str) -> Option<Vec<(usize, char)>> {+ let chars: Vec<(usize, char)> = cluster.char_indices().collect();+ if chars.len() != members.len() {+ return None;+ }+ let mut own: Vec<Option<usize>> = vec![None; members.len()];+ let mut used = vec![false; chars.len()];+ for (m, g) in members.iter().enumerate() {+ if let Some(k) = (0..chars.len()).find(|&k| !used[k] && g.face.glyph_for(chars[k].1) == g.gid) {+ used[k] = true;+ own[m] = Some(k);+ }+ }+ // The remaining glyphs and characters must all be marks; they pair up in text order (a+ // right-to-left cluster lists its glyphs right to left).+ let mut rest: Vec<usize> = (0..members.len()).filter(|&m| own[m].is_none()).collect();+ if members.first().is_some_and(|g| g.rtl) {+ rest.reverse();+ }+ let marks: Vec<usize> = (0..chars.len()).filter(|&k| !used[k]).collect();+ if rest.len() != marks.len() {+ return None;+ }+ for (&m, &k) in rest.iter().zip(&marks) {+ let g = members.get(m)?;+ let c = chars.get(k)?.1;+ if !g.face.glyph_is_mark(g.gid) || !g.face.glyph_is_mark(g.face.glyph_for(c)) {+ return None;+ }+ own[m] = Some(k);+ }+ own.into_iter().map(|k| chars.get(k?).copied()).collect()}/// Merge bars of one paint layer; underlines and strikes must never be merged together.@@ -143,6 +223,7 @@ impl Exporter<'_> {}for l in &ft.lines {let gs = &l.glyphs;+ let line_span = self.start_rtl_line(s, cs, ft, gs, story);let mut i = 0;while i < gs.len() {let g = &gs[i];@@ -160,13 +241,17 @@ impl Exporter<'_> {i += 1;continue;}- let mut j = i + 1;- while j < gs.len() && same_run(g, &gs[j]) && !(ft.vertical && (gs[j].upright || gs[j].tcy.is_some())) {- j += 1;+ let j = run_end(ft, gs, i);+ if line_span {+ self.run(s, cs, &gs[i..j], l.baseline, story);+ } else {+ self.tagged_run(s, cs, &gs[i..j], l.baseline, story);}- self.tagged_run(s, cs, &gs[i..j], l.baseline, story);i = j;}+ if line_span {+ s.end_tagged();+ }}self.as_artifact(s, |me, s| {for (rule, r) in text_rules(cs, ft, false) {@@ -184,6 +269,47 @@ impl Exporter<'_> {});}+ /// Open a span over a line with right-to-left text whose ActualText is the line's text in+ /// reading order (tagged under its paragraph while a story is being tagged). Viewers that order+ /// text by position would otherwise read it in visual order. Marked content can't nest, so only+ /// in untagged exports and in tagged stories (not inside artifacts or figures).+ fn start_rtl_line(&mut self, s: &mut Surface, cs: &ComposedStory, ft: &FrameText, gs: &[PlacedGlyph], story: &str) -> bool {+ if ft.vertical || !gs.iter().any(|g| g.rtl && g.visible) || (self.opts.tagged && self.tag_story.is_none()) {+ return false;+ }+ let mut text = String::new();+ let mut i = 0;+ while i < gs.len() {+ let g = &gs[i];+ if !g.visible || g.sx <= 0.0 || g.sy <= 0.0 {+ i += 1;+ continue;+ }+ let j = run_end(ft, gs, i);+ // Only runs `run` draws.+ let painted = cs.styles.get(g.style as usize).is_some_and(|st| {+ self.swatch_color(&st.fill, st.fill_tint).is_some()+ || (st.stroke != designcraft_color::swatch::NONE+ && st.stroke_weight > 0.0+ && self.swatch_color(&st.stroke, st.stroke_tint).is_some())+ });+ if painted && let Some(run) = gs.get(i..j) {+ text.push_str(&self.run_text(run, story).0);+ }+ i = j;+ }+ if text.is_empty() {+ return false;+ }+ let id = s.start_tagged(ContentTag::Span(SpanTag::empty().with_actual_text(Some(&text))));+ if let Some(sid) = self.tag_story {+ let byte = gs.first().map_or(0, |g| g.byte);+ let pi = self.doc.story(sid).map_or(0, |st| st.para_at(byte.min(st.len())));+ self.para_tags.entry((sid, pi)).or_default().push(id);+ }+ true+ }+/// Table fragments: cell fills, cell text (real text), edges and the border.fn tables(&mut self, s: &mut Surface, ft: &FrameText) {for t in &ft.tables {@@ -263,6 +389,10 @@ impl Exporter<'_> {} else if g.len == 0 && prev_src == Some(g.byte) && !ranges.is_empty() {// Second glyph of a multi-glyph cluster: share the cluster's text.ranges[ranges.len() - 1].clone()+ } else if g.len == 0 && cmap.get(&g.gid) == Some(&'\u{0640}') {+ // A kashida that justification inserted: drawn, but no text of its own.+ prev_src = None;+ text.len()..text.len()} else {// Inserted glyphs (page numbers, list labels, hyphens): map back through the font.prev_src = None;@@ -298,33 +428,40 @@ impl Exporter<'_> {let face = g0.face;let size = g0.sy * face.upem;let hs = g0.sx / g0.sy;- let skew = if st.skew != 0.0 { Affine::new([1.0, 0.0, -st.skew.to_radians().tan(), 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };+ let tan = if st.skew != 0.0 { st.skew.to_radians().tan() } else { 0.0 };+ let skew = if st.skew != 0.0 { Affine::new([1.0, 0.0, -tan, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };let origin = Affine::translate((g0.x, baseline + g0.y)) * skew * Affine::scale_non_uniform(hs, 1.0);// A missing glyph is drawn as its box: PDF/A and PDF/UA forbid showing .notdef as text.if g0.gid == 0 {- self.outline_run(s, glyphs, origin, size, fill, stroke, st.stroke_weight);+ self.outline_run(s, glyphs, origin, tan, size, fill, stroke, st.stroke_weight);return;}let Some(font) = self.font(&face) else {self.warn(format!("font `{} {}` could not be embedded; its text was drawn as outlines", face.family, face.style));- self.outline_run(s, glyphs, origin, size, fill, stroke, st.stroke_weight);+ self.outline_run(s, glyphs, origin, tan, size, fill, stroke, st.stroke_weight);return;};- let (text, ranges) = self.run_text(glyphs, story);+ let (text, mut ranges) = self.run_text(glyphs, story);+ let order = split_clusters(glyphs, &text, &mut ranges);let k = 1.0 / (hs * size);- let kg: Vec<KrillaGlyph> = glyphs+ // Glyphs are placed absolutely: each advance reaches the next glyph drawn, a vertical offset+ // (a mark above or below its base) is undone by the skew so it lands where it was composed.+ let kg: Vec<KrillaGlyph> = order.iter()- .zip(ranges).enumerate()- .map(|(i, (g, r))| {- let next = glyphs.get(i + 1).map_or(g.x + g.adv, |n| n.x);- KrillaGlyph::new(GlyphId::new(g.gid), ((next - g.x) * k) as f32, 0.0, 0.0, 0.0, r, None)+ .filter_map(|(n, &i)| {+ let g = glyphs.get(i)?;+ let next = order.get(n + 1).and_then(|&m| glyphs.get(m)).map_or(g.x + g.adv, |m| m.x);+ let dy = g.y - g0.y;+ let r = ranges.get(i)?.clone();+ Some(KrillaGlyph::new(GlyphId::new(g.gid), ((next - g.x) * k) as f32, (tan * dy * k) as f32, (-dy / size) as f32, 0.0, r, None))}).collect();+ let start = order.first().and_then(|&i| glyphs.get(i)).map_or(0.0, |g| (g.x - g0.x) / hs);s.push_transform(&tf(origin));s.set_fill(fill.map(|c| solid_fill(c, 1.0)));s.set_stroke(stroke.map(|c| Stroke { paint: c.into(), width: st.stroke_weight as f32, ..Default::default() }));- s.draw_glyphs(Point::from_xy(0.0, 0.0), &kg, font, &text, size as f32, false);+ s.draw_glyphs(Point::from_xy(start as f32, 0.0), &kg, font, &text, size as f32, false);s.set_fill(None);s.set_stroke(None);s.pop();@@ -337,6 +474,7 @@ impl Exporter<'_> {s: &mut Surface,glyphs: &[PlacedGlyph],origin: Affine,+ tan: f64,size: f64,fill: Option<krilla::color::Color>,stroke: Option<krilla::color::Color>,@@ -347,7 +485,8 @@ impl Exporter<'_> {let k = size / g0.face.upem;let mut bp = BezPath::new();for g in glyphs {- let a = Affine::translate(((g.x - g0.x) / (g0.sx / g0.sy), 0.0)) * Affine::scale(k);+ let dy = g.y - g0.y;+ let a = Affine::translate(((g.x - g0.x + tan * dy) / (g0.sx / g0.sy), dy)) * Affine::scale(k);let mut o = (*db.outline(&g.face, g.gid)).clone();o.apply_affine(a);bp.extend(o.iter());