From 399ecc74de1852634bf94e680d0a373bbbd37d56 Mon Sep 17 00:00:00 2001 From: Altynzhan Karybai Date: Mon, 16 Nov 2026 23:21:07 -0500 Subject: [PATCH 1/2] svg: share bounded compatibility transform parsing Preserve EffectCraft source from 4035d181329e847d7a57bf3d059502ea2c91b560, based on Brandon Thomas original 94e1c86d89a866771f80ad1610afda9aa12e85d8. Algorithm unchanged; module imports only adapted. Co-authored-by: Brandon Thomas --- crates/svg/src/lib.rs | 3 +++ crates/svg/src/transform_compat.rs | 37 ++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 crates/svg/src/transform_compat.rs diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs index 0c3c362a4..ccb2b6837 100644 --- a/crates/svg/src/lib.rs +++ b/crates/svg/src/lib.rs @@ -35,3 +35,6 @@ pub mod write; pub mod prefix_path; /// Compatibility CSS subset for simple SVG importers. pub mod simple_css; + +/// Prefix-preserving SVG transform-list compatibility. +pub mod transform_compat; diff --git a/crates/svg/src/transform_compat.rs b/crates/svg/src/transform_compat.rs new file mode 100644 index 000000000..b6ed506bf --- /dev/null +++ b/crates/svg/src/transform_compat.rs @@ -0,0 +1,37 @@ +//! Prefix-preserving transform-list compatibility for existing SVG importers. +//! At most six numbers are retained per operation; input scanning is not byte-capped. +//! Unknown/invalid-arity operations are ignored, unterminated suffixes stop parsing. +//! Matrix overflow behavior is unchanged; callers retain their geometry validation. + +use crate::prefix_path as pathdata; +use kurbo::Affine; + +/// Parse transforms using the established EffectCraft recovery and composition order. +pub fn parse_transform(s: &str) -> Affine { + let mut m = Affine::IDENTITY; + let mut rest = s; + while let Some(open) = rest.find('(') { + let name = rest[..open].trim().trim_start_matches(',').trim(); + let Some(close) = rest[open..].find(')') else { break }; + let (a, too_many) = pathdata::numbers_bounded(&rest[open + 1..open + close], 6); + rest = &rest[open + close + 1..]; + let t = if too_many { + Affine::IDENTITY + } else { + match (name, a.as_slice()) { + ("matrix", [a0, a1, a2, a3, a4, a5]) => Affine::new([*a0, *a1, *a2, *a3, *a4, *a5]), + ("translate", [x]) => Affine::translate((*x, 0.0)), + ("translate", [x, y]) => Affine::translate((*x, *y)), + ("scale", [scale]) => Affine::scale(*scale), + ("scale", [x, y]) => Affine::scale_non_uniform(*x, *y), + ("rotate", [angle]) => Affine::rotate(angle.to_radians()), + ("rotate", [angle, x, y]) => Affine::translate((*x, *y)) * Affine::rotate(angle.to_radians()) * Affine::translate((-*x, -*y)), + ("skewX", [angle]) => Affine::new([1.0, 0.0, angle.to_radians().tan(), 1.0, 0.0, 0.0]), + ("skewY", [angle]) => Affine::new([1.0, angle.to_radians().tan(), 0.0, 1.0, 0.0, 0.0]), + _ => Affine::IDENTITY, + } + }; + m *= t; + } + m +} From a6d5f86ee486eae446cb834559085f8ae1463021 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Mon, 16 Nov 2026 23:22:03 -0500 Subject: [PATCH 2/2] svg: pin transform composition and malformed-list parity --- crates/svg/README.md | 3 +++ crates/svg/src/transform_compat.rs | 38 ++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/crates/svg/README.md b/crates/svg/README.md index a387e58c2..508081367 100644 --- a/crates/svg/README.md +++ b/crates/svg/README.md @@ -13,3 +13,6 @@ and its regression test preserve NetterSilver's `10e173c0e49696ad335e3da8a069889c089b09a6`; both contributors retain primary Git authorship for their respective port commits. Source and destination use MIT OR Apache-2.0. The shared adapter adds an aggregate 64 MiB stylesheet-text limit and idempotent indexing. + +### Transform compatibility +`transform_compat::parse_transform` preserves EffectCraft transform-list recovery and exact composition. It retains six numeric arguments per operation; scanning is not time/byte capped and matrix overflow behavior is unchanged. The strict geometry reader is unchanged. Source: Brandon Thomas, EffectCraft94e1c86d89a866771f80ad1610afda9aa12e85d8; bounded safe argument matching by Altynzhan Karybai,4035d181329e847d7a57bf3d059502ea2c91b560. diff --git a/crates/svg/src/transform_compat.rs b/crates/svg/src/transform_compat.rs index b6ed506bf..446cc8c0c 100644 --- a/crates/svg/src/transform_compat.rs +++ b/crates/svg/src/transform_compat.rs @@ -35,3 +35,41 @@ pub fn parse_transform(s: &str) -> Affine { } m } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn operations_keep_composition_order() { + let cases = [ + ("matrix(1 2 3 4 5 6)", Affine::new([1., 2., 3., 4., 5., 6.])), + ("translate(2)", Affine::translate((2., 0.))), + ("translate(2,3)", Affine::translate((2., 3.))), + ("scale(2)", Affine::scale(2.)), + ("scale(2 3)", Affine::scale_non_uniform(2., 3.)), + ("rotate(30)", Affine::rotate(30f64.to_radians())), + ("rotate(30 2 3)", Affine::translate((2., 3.)) * Affine::rotate(30f64.to_radians()) * Affine::translate((-2., -3.))), + ("skewX(30)", Affine::new([1., 0., 30f64.to_radians().tan(), 1., 0., 0.])), + ("skewY(30)", Affine::new([1., 30f64.to_radians().tan(), 0., 1., 0., 0.])), + ]; + for (text, expected) in cases { + assert_eq!(parse_transform(text).as_coeffs(), expected.as_coeffs()); + assert_eq!(parse_transform(&format!("translate(7,9), {text}")).as_coeffs(), (Affine::translate((7., 9.)) * expected).as_coeffs()); + } + } + + #[test] + fn malformed_and_oversized_operations_keep_accepted_prefix() { + for text in ["", "unknown(1)", "translate()", "scale(1 2 3)", "matrix(1 2 3 4 5 6 7)", "rotate(2 3)"] { + assert_eq!(parse_transform(text), Affine::IDENTITY); + } + for suffix in ["translate(", "unknown(1)", "matrix(1 2 3 4 5 6 7)"] { + assert_eq!(parse_transform(&format!("translate(3,4){suffix}")), Affine::translate((3., 4.))); + } + assert_eq!(parse_transform("unknown(1) scale(2)"), Affine::scale(2.)); + assert_eq!(parse_transform("translate(3 4oops)"), Affine::translate((3., 4.))); + let huge = format!("scale({}) translate(2)", "1 ".repeat(10_000)); + assert_eq!(parse_transform(&huge), Affine::translate((2., 0.))); + } +}