CSS engine: sync trimming/AOT hardening and remaining property updates

The tail of the PeachPDF v0.9.6 delta (upstream d150993, e1c8d21, 71a93e2,
ba7df0c, 4035e66, e0c1fd8, 731490f).

- AttributeSelectorFactory: reflection-free dispatch, so the two-argument
  Attr*Selector constructors are statically reachable and survive trimming
- PortableExtensions: the reflection-based GetProperties helper is gone, which
  also retires the trimming-annotation divergence the port carried
- Map, ValueBuilder, and the SVG fill/stroke property updates
- transform-origin now accepts a single keyword followed by a length

This brings the vendored tree to exactly PeachPDF v0.9.6's 589 files, with no
file missing and none extra.

Map's lookup tables stay plain Dictionary rather than FrozenDictionary, which
is net8-only; the comparer moves into the constructor, as elsewhere in the
vendored tree.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: 2 people

Source/HtmlRenderer/Core/CssEngine/Extensions/PortableExtensions.cs

@@ -1,7 +1,3 @@
-using System;
-using System.Linq;
-using System.Reflection;
-
 #if !NET40 && !SL50
 
 namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
@@ -12,16 +8,7 @@ public static string ConvertFromUtf32(this int utf32)
         {
             return char.ConvertFromUtf32(utf32);
         }
-
-        // The [DynamicallyAccessedMembers] trimming annotation from the source this was ported from is
-        // deliberately dropped here - it's a metadata-only hint for IL trimmers/AOT (no runtime effect),
-        // and HTML-Renderer doesn't use trimming; keeping it would need a netstandard2.0-incompatible
-        // reference to System.Diagnostics.CodeAnalysis's copy of the attribute.
-        public static PropertyInfo[] GetProperties(this Type type)
-        {
-            return type.GetRuntimeProperties().ToArray();
-        }
     }
 }
 
-#endif
+#endif

Source/HtmlRenderer/Core/CssEngine/Factories/AttributeSelectorFactory.cs

@@ -1,23 +1,11 @@
 using System;
-using System.Collections.Generic;
 
 namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class AttributeSelectorFactory
     {
         private static readonly Lazy<AttributeSelectorFactory> Lazy = new Lazy<AttributeSelectorFactory>(() => new AttributeSelectorFactory());
 
-        private readonly Dictionary<string, Type> _types = new Dictionary<string, Type>()
-        {
-            { Combinators.Exactly, typeof(AttrMatchSelector) },
-            { Combinators.InList, typeof(AttrListSelector) },
-            { Combinators.InToken, typeof(AttrHyphenSelector) },
-            { Combinators.Begins, typeof(AttrBeginsSelector) },
-            { Combinators.Ends, typeof(AttrEndsSelector) },
-            { Combinators.InText, typeof(AttrContainsSelector) },
-            { Combinators.Unlike, typeof(AttrNotMatchSelector) },
-        };
-
         private AttributeSelectorFactory()
         {
         }
@@ -34,9 +22,20 @@ public IAttrSelector Create(string combinator, string match, string value, strin
                 _ = AttributeSelectorFactory.FormMatch(prefix, match);
             }
 
-            return _types.TryGetValue(combinator, out var type)
-                ? (IAttrSelector)Activator.CreateInstance(type, name, value)
-                : new AttrAvailableSelector(name, value);
+            // A reflection-free dispatch (no Activator.CreateInstance) so the two-arg Attr*Selector
+            // constructors are statically reachable and survive trimming/AOT (IsTrimmable=true) - see
+            // upstream ExCSS commit c497ca7. Unknown combinators fall back to a presence selector.
+            switch (combinator)
+            {
+                case Combinators.Exactly: return new AttrMatchSelector(name, value);
+                case Combinators.InList: return new AttrListSelector(name, value);
+                case Combinators.InToken: return new AttrHyphenSelector(name, value);
+                case Combinators.Begins: return new AttrBeginsSelector(name, value);
+                case Combinators.Ends: return new AttrEndsSelector(name, value);
+                case Combinators.InText: return new AttrContainsSelector(name, value);
+                case Combinators.Unlike: return new AttrNotMatchSelector(name, value);
+                default: return new AttrAvailableSelector(name, value);
+            }
         }
 
         private static string FormFront(string prefix, string match)

Source/HtmlRenderer/Core/CssEngine/Model/Map.cs

@@ -245,8 +245,8 @@ internal static class Map
                 {Keywords.Large, FontSize.Large},
                 {Keywords.XLarge, FontSize.Big},
                 {Keywords.XxLarge, FontSize.Huge},
-                {Keywords.Larger, FontSize.Smaller},
-                {Keywords.Smaller, FontSize.Larger}
+                {Keywords.Larger, FontSize.Larger},
+                {Keywords.Smaller, FontSize.Smaller}
             };
         public static readonly Dictionary<string, TextDecorationStyle> TextDecorationStyles =
             new Dictionary<string, TextDecorationStyle>(StringComparer.OrdinalIgnoreCase)

Source/HtmlRenderer/Core/CssEngine/Model/ValueBuilder.cs

@@ -50,6 +50,7 @@ public void Apply(Token token)
                 case TokenType.Dimension:
                 case TokenType.Percentage:
                 case TokenType.Color:
+                case TokenType.Hash:
                 case TokenType.Delim:
                 case TokenType.String:
                 case TokenType.Url:
@@ -59,6 +60,17 @@ public void Apply(Token token)
                 case TokenType.GreaterThanOrEqual:
                 case TokenType.LessThan:
                 case TokenType.LessThanOrEqual:
+                case TokenType.Range:
+                    // A U+... unicode-range value (an @font-face descriptor) is a sequence of Range tokens;
+                    // without this they'd hit the default arm and mark the whole value invalid, so the
+                    // descriptor would be dropped under strict (non-tolerant) parsing - the pipeline default.
+                    Add(token);
+                    break;
+                case TokenType.SquareBracketOpen:
+                case TokenType.SquareBracketClose:
+                    // Square brackets are valid in a value: grid line names, e.g.
+                    // `grid-template-columns: [sidebar-start] 200px [sidebar-end]`. Without this they'd hit
+                    // the default arm and the whole declaration would be dropped under strict parsing.
                     Add(token);
                     break;
                 case TokenType.Comment:

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Fill/FillProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class FillProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.PaintConverter;
+        private static readonly IValueConverter StyleConverter = Converters.PaintConverter.OrGlobalValue();
 
         internal FillProperty()
             : base(PropertyNames.Fill, PropertyFlags.Animatable)

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Stroke/StrokeDasharrayProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class StrokeDasharrayProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.StrokeDasharrayConverter;
+        private static readonly IValueConverter StyleConverter = Converters.StrokeDasharrayConverter.OrGlobalValue();
 
         public StrokeDasharrayProperty()
             : base(PropertyNames.StrokeDasharray, PropertyFlags.Animatable | PropertyFlags.Unitless)

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Stroke/StrokeDashoffsetProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class StrokeDashoffsetProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.LengthOrPercentConverter;
+        private static readonly IValueConverter StyleConverter = Converters.LengthOrPercentConverter.OrGlobalValue();
 
         public StrokeDashoffsetProperty()
             : base(PropertyNames.StrokeDashoffset, PropertyFlags.Animatable)

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Stroke/StrokeLinejoinProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class StrokeLinejoinProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.StrokeLinejoinConverter;
+        private static readonly IValueConverter StyleConverter = Converters.StrokeLinejoinConverter.OrGlobalValue();
 
         public StrokeLinejoinProperty()
             : base(PropertyNames.StrokeLinejoin, PropertyFlags.Animatable)

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Stroke/StrokeMiterlimitProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class StrokeMiterlimitProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.StrokeMiterlimitConverter;
+        private static readonly IValueConverter StyleConverter = Converters.StrokeMiterlimitConverter.OrGlobalValue();
 
         public StrokeMiterlimitProperty()
             : base(PropertyNames.StrokeMiterlimit, PropertyFlags.Animatable)

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Stroke/StrokeProperty.cs

@@ -2,7 +2,7 @@ namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
 {
     internal sealed class StrokeProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.PaintConverter;
+        private static readonly IValueConverter StyleConverter = Converters.PaintConverter.OrGlobalValue();
 
         internal StrokeProperty()
             : base(PropertyNames.Stroke, PropertyFlags.Animatable)