Merge pull request #212 from jafin/perf/css-parser-optimizations-clean

FlorianRappl · web-flow · commit 9c9803e97069 · 2026-03-30T11:22:20.000+02:00
Optimize CSS parser performance
diff --git a/src/AngleSharp.Css/Converters/DictionaryValueConverter.cs b/src/AngleSharp.Css/Converters/DictionaryValueConverter.cs
@@ -25,7 +25,7 @@ public ICssValue Convert(StringSource source)
 
             if (ident != null && _values.TryGetValue(ident, out mode))
             {
-                return new CssConstantValue<T>(ident.ToLowerInvariant(), mode);
+                return new CssConstantValue<T>(ident.ToLowerFast(), mode);
             }
 
             source.BackTo(pos);
diff --git a/src/AngleSharp.Css/Converters/PeriodicValueConverter.cs b/src/AngleSharp.Css/Converters/PeriodicValueConverter.cs
@@ -34,6 +34,11 @@ public ICssValue Convert(StringSource source)
 
             if (length > 0)
             {
+                if (length == 4)
+                {
+                    return new CssPeriodicValue(options);
+                }
+
                 var values = new ICssValue[length];
                 Array.Copy(options, values, length);
                 return new CssPeriodicValue(values);
diff --git a/src/AngleSharp.Css/Dom/Internal/CssProperty.cs b/src/AngleSharp.Css/Dom/Internal/CssProperty.cs
@@ -29,7 +29,7 @@ internal class CssProperty : ICssProperty
 
         internal CssProperty(String name, IValueConverter converter, PropertyFlags flags = PropertyFlags.None, ICssValue value = null, Boolean important = false)
         {
-            _name = name.StartsWith("--") ? name : name.ToLowerInvariant();
+            _name = name.StartsWith("--") ? name : name.ToLowerFast();
             _converter = converter;
             _flags = flags;
             _value = value;
diff --git a/src/AngleSharp.Css/Dom/Internal/CssStyleDeclaration.cs b/src/AngleSharp.Css/Dom/Internal/CssStyleDeclaration.cs
@@ -19,6 +19,7 @@ sealed class CssStyleDeclaration : ICssStyleDeclaration
         #region Fields
 
         private readonly List<ICssProperty> _declarations;
+        private readonly Dictionary<String, Int32> _declarationIndex;
         private readonly IBrowsingContext _context;
         private ICssRule _parent;
         private Boolean _updating;
@@ -36,6 +37,7 @@ sealed class CssStyleDeclaration : ICssStyleDeclaration
         public CssStyleDeclaration(IBrowsingContext context)
         {
             _declarations = new List<ICssProperty>();
+            _declarationIndex = new Dictionary<String, Int32>(StringComparer.OrdinalIgnoreCase);
             _context = context;
         }
 
@@ -77,9 +79,9 @@ public String CssText
 
         public ICssProperty GetProperty(String name)
         {
-            for (var i = 0; i < _declarations.Count; i++)
+            if (_declarationIndex.TryGetValue(name, out var index) && index < _declarations.Count)
             {
-                var declaration = _declarations[i];
+                var declaration = _declarations[index];
 
                 if (declaration.Name.Isi(name))
                 {
@@ -100,6 +102,7 @@ public void Update(String value)
             if (!_updating)
             {
                 _declarations.Clear();
+                _declarationIndex.Clear();
 
                 if (!String.IsNullOrEmpty(value))
                 {
@@ -109,6 +112,7 @@ public void Update(String value)
                     if (decl != null)
                     {
                         _declarations.AddRange(decl);
+                        RebuildIndex();
                     }
                 }
             }
@@ -304,12 +308,14 @@ public void SetProperty(String propertyName, String propertyValue, String priori
 
         public void AddProperty(ICssProperty declaration)
         {
+            _declarationIndex[declaration.Name] = _declarations.Count;
             _declarations.Add(declaration);
         }
 
         public void RemoveProperty(ICssProperty declaration)
         {
             _declarations.Remove(declaration);
+            RebuildIndex();
         }
 
         #endregion
@@ -359,14 +365,24 @@ private void RemovePropertyByName(String propertyName)
             var info = _context.GetDeclarationInfo(propertyName);
             var longhands = info.Longhands;
 
-            for (var i = 0; i < _declarations.Count; i++)
+            if (_declarationIndex.TryGetValue(propertyName, out var index) && index < _declarations.Count &&
+                _declarations[index].Name.Is(propertyName))
             {
-                var declaration = _declarations[i];
-
-                if (declaration.Name.Is(propertyName))
+                _declarations.RemoveAt(index);
+                RebuildIndex();
+            }
+            else
+            {
+                for (var i = 0; i < _declarations.Count; i++)
                 {
-                    _declarations.RemoveAt(i);
-                    break;
+                    var declaration = _declarations[i];
+
+                    if (declaration.Name.Is(propertyName))
+                    {
+                        _declarations.RemoveAt(i);
+                        RebuildIndex();
+                        break;
+                    }
                 }
             }
 
@@ -389,23 +405,39 @@ private void ChangeDeclarations(IEnumerable<ICssProperty> decls, Predicate<ICssP
             {
                 var skip = defaultSkip(newdecl);
 
-                for (var i = 0; i < _declarations.Count; i++)
+                if (_declarationIndex.TryGetValue(newdecl.Name, out var idx) && idx < _declarations.Count &&
+                    _declarations[idx].Name.Is(newdecl.Name))
                 {
-                    var olddecl = _declarations[i];
-
-                    if (olddecl.Name.Is(newdecl.Name))
+                    if (removeExisting.Invoke(_declarations[idx], newdecl))
                     {
-                        if (removeExisting.Invoke(olddecl, newdecl))
-                        {
-                            _declarations.RemoveAt(i);
-                            skip = false;
-                        }
-                        else
+                        _declarations.RemoveAt(idx);
+                        skip = false;
+                    }
+                    else
+                    {
+                        skip = true;
+                    }
+                }
+                else
+                {
+                    for (var i = 0; i < _declarations.Count; i++)
+                    {
+                        var olddecl = _declarations[i];
+
+                        if (olddecl.Name.Is(newdecl.Name))
                         {
-                            skip = true;
-                        }
+                            if (removeExisting.Invoke(olddecl, newdecl))
+                            {
+                                _declarations.RemoveAt(i);
+                                skip = false;
+                            }
+                            else
+                            {
+                                skip = true;
+                            }
 
-                        break;
+                            break;
+                        }
                     }
                 }
 
@@ -416,13 +448,14 @@ private void ChangeDeclarations(IEnumerable<ICssProperty> decls, Predicate<ICssP
             }
 
             _declarations.AddRange(declarations);
+            RebuildIndex();
         }
 
         private void SetLonghand(ICssProperty property)
         {
-            for (var i = 0; i < _declarations.Count; i++)
+            if (_declarationIndex.TryGetValue(property.Name, out var index) && index < _declarations.Count)
             {
-                var declaration = _declarations[i];
+                var declaration = _declarations[index];
 
                 if (declaration.Name.Is(property.Name))
                 {
@@ -431,11 +464,12 @@ private void SetLonghand(ICssProperty property)
                         return;
                     }
 
-                    _declarations[i] = property;
+                    _declarations[index] = property;
                     return;
                 }
             }
 
+            _declarationIndex[property.Name] = _declarations.Count;
             _declarations.Add(property);
         }
 
@@ -452,6 +486,16 @@ private void SetShorthand(ICssProperty shorthand)
             }
         }
 
+        private void RebuildIndex()
+        {
+            _declarationIndex.Clear();
+
+            for (var i = 0; i < _declarations.Count; i++)
+            {
+                _declarationIndex[_declarations[i].Name] = i;
+            }
+        }
+
         private void RaiseChanged()
         {
             if (!_updating)
diff --git a/src/AngleSharp.Css/Extensions/StringExtensions.cs b/src/AngleSharp.Css/Extensions/StringExtensions.cs
@@ -87,5 +87,24 @@ public static String CssUrl(this String value)
             var argument = value.CssString();
             return Keywords.Url.CssFunction(argument);
         }
+
+        /// <summary>
+        /// Converts to lowercase, returning the original string if it is already lowercase.
+        /// Avoids allocation for the common case of already-lowercase CSS identifiers.
+        /// </summary>
+        internal static String ToLowerFast(this String value)
+        {
+            for (var i = 0; i < value.Length; i++)
+            {
+                var c = value[i];
+
+                if (c >= 'A' && c <= 'Z')
+                {
+                    return value.ToLowerInvariant();
+                }
+            }
+
+            return value;
+        }
     }
 }
diff --git a/src/AngleSharp.Css/Parser/CssBuilder.cs b/src/AngleSharp.Css/Parser/CssBuilder.cs
@@ -1,11 +1,13 @@
 #nullable disable
 namespace AngleSharp.Css.Parser
 {
+    using AngleSharp.Common;
     using AngleSharp.Css.Dom;
     using AngleSharp.Css.Parser.Tokens;
     using AngleSharp.Dom;
     using AngleSharp.Text;
     using System;
+    using System.Collections.Generic;
 
     /// <summary>
     /// See http://dev.w3.org/csswg/css-syntax/#parsing for details.
@@ -14,6 +16,22 @@ sealed class CssBuilder
     {
         #region Fields
 
+        private static readonly Dictionary<String, Int32> AtRuleMap = new Dictionary<String, Int32>(StringComparer.OrdinalIgnoreCase)
+        {
+            { RuleNames.Media, 1 },
+            { RuleNames.FontFace, 2 },
+            { RuleNames.Keyframes, 3 },
+            { RuleNames.Import, 4 },
+            { RuleNames.Charset, 5 },
+            { RuleNames.Namespace, 6 },
+            { RuleNames.Page, 7 },
+            { RuleNames.Supports, 8 },
+            { RuleNames.ViewPort, 9 },
+            { RuleNames.Document, 10 },
+            { RuleNames.CounterStyle, 11 },
+            { RuleNames.FontFeatureValues, 12 },
+        };
+
         private readonly CssTokenizer _tokenizer;
         private readonly CssParserOptions _options;
         private readonly IBrowsingContext _context;
@@ -67,67 +85,26 @@ private ICssRule CreateStyleRule(ICssStyleSheet sheet, CssToken token)
 
         private ICssRule CreateAtRule(ICssStyleSheet sheet, CssToken token)
         {
-            if (token.Data.Is(RuleNames.Media))
-            {
-                var rule = new CssMediaRule(sheet);
-                return CreateMedia(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.FontFace))
-            {
-                var rule = new CssFontFaceRule(sheet);
-                return CreateFontFace(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Keyframes))
-            {
-                var rule = new CssKeyframesRule(sheet);
-                return CreateKeyframes(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Import))
-            {
-                var rule = new CssImportRule(sheet);
-                return CreateImport(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Charset))
-            {
-                var rule = new CssCharsetRule(sheet);
-                return CreateCharset(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Namespace))
-            {
-                var rule = new CssNamespaceRule(sheet);
-                return CreateNamespace(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Page))
-            {
-                var rule = new CssPageRule(sheet);
-                return CreatePage(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Supports))
+            if (AtRuleMap.TryGetValue(token.Data, out var ruleId))
             {
-                var rule = new CssSupportsRule(sheet);
-                return CreateSupports(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.ViewPort))
-            {
-                var rule = new CssViewportRule(sheet);
-                return CreateViewport(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.Document))
-            {
-                var rule = new CssDocumentRule(sheet);
-                return CreateDocument(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.CounterStyle))
-            {
-                var rule = new CssCounterStyleRule(sheet);
-                return CreateCounterStyle(rule, token);
-            }
-            else if (token.Data.Is(RuleNames.FontFeatureValues))
-            {
-                var rule = new CssFontFeatureValuesRule(sheet);
-                return CreateFontFeatureValues(rule, token);
+                switch (ruleId)
+                {
+                    case 1: return CreateMedia(new CssMediaRule(sheet), token);
+                    case 2: return CreateFontFace(new CssFontFaceRule(sheet), token);
+                    case 3: return CreateKeyframes(new CssKeyframesRule(sheet), token);
+                    case 4: return CreateImport(new CssImportRule(sheet), token);
+                    case 5: return CreateCharset(new CssCharsetRule(sheet), token);
+                    case 6: return CreateNamespace(new CssNamespaceRule(sheet), token);
+                    case 7: return CreatePage(new CssPageRule(sheet), token);
+                    case 8: return CreateSupports(new CssSupportsRule(sheet), token);
+                    case 9: return CreateViewport(new CssViewportRule(sheet), token);
+                    case 10: return CreateDocument(new CssDocumentRule(sheet), token);
+                    case 11: return CreateCounterStyle(new CssCounterStyleRule(sheet), token);
+                    case 12: return CreateFontFeatureValues(new CssFontFeatureValuesRule(sheet), token);
+                }
             }
-            else if (_options.IsIncludingUnknownRules)
+
+            if (_options.IsIncludingUnknownRules)
             {
                 return CreateUnknownAtRule(sheet, token);
             }
@@ -556,10 +533,18 @@ public void CreateDeclarationWith(ICssProperties properties, ref CssToken token)
             {
                 var name = token.Data;
 
-                while (token.Type == CssTokenType.Delim)
+                if (token.Type == CssTokenType.Delim)
                 {
-                    token = NextToken();
-                    name += token.Data;
+                    var sb = StringBuilderPool.Obtain();
+                    sb.Append(name);
+
+                    while (token.Type == CssTokenType.Delim)
+                    {
+                        token = NextToken();
+                        sb.Append(token.Data);
+                    }
+
+                    name = sb.ToPool();
                 }
 
                 token = NextToken();
diff --git a/src/AngleSharp.Css/Parser/CssTokenizer.cs b/src/AngleSharp.Css/Parser/CssTokenizer.cs
diff --git a/src/AngleSharp.Css/Parser/Micro/IdentParser.cs b/src/AngleSharp.Css/Parser/Micro/IdentParser.cs

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public ICssValue Convert(StringSource source)`
`25`	`25`
`26`	`26`	`if (ident != null && _values.TryGetValue(ident, out mode))`
`27`	`27`	`{`
`28`		`- return new CssConstantValue<T>(ident.ToLowerInvariant(), mode);`
	`28`	`+ return new CssConstantValue<T>(ident.ToLowerFast(), mode);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`source.BackTo(pos);`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ internal class CssProperty : ICssProperty`
`29`	`29`
`30`	`30`	`internal CssProperty(String name, IValueConverter converter, PropertyFlags flags = PropertyFlags.None, ICssValue value = null, Boolean important = false)`
`31`	`31`	`{`
`32`		`- _name = name.StartsWith("--") ? name : name.ToLowerInvariant();`
	`32`	`+ _name = name.StartsWith("--") ? name : name.ToLowerFast();`
`33`	`33`	`_converter = converter;`
`34`	`34`	`_flags = flags;`
`35`	`35`	`_value = value;`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ sealed class CssStyleDeclaration : ICssStyleDeclaration`
`19`	`19`	`#region Fields`
`20`	`20`
`21`	`21`	`private readonly List<ICssProperty> _declarations;`
	`22`	`+ private readonly Dictionary<String, Int32> _declarationIndex;`
`22`	`23`	`private readonly IBrowsingContext _context;`
`23`	`24`	`private ICssRule _parent;`
`24`	`25`	`private Boolean _updating;`
`@@ -36,6 +37,7 @@ sealed class CssStyleDeclaration : ICssStyleDeclaration`
`36`	`37`	`public CssStyleDeclaration(IBrowsingContext context)`
`37`	`38`	`{`
`38`	`39`	`_declarations = new List<ICssProperty>();`
	`40`	`+ _declarationIndex = new Dictionary<String, Int32>(StringComparer.OrdinalIgnoreCase);`
`39`	`41`	`_context = context;`
`40`	`42`	`}`
`41`	`43`
`@@ -77,9 +79,9 @@ public String CssText`
`77`	`79`
`78`	`80`	`public ICssProperty GetProperty(String name)`
`79`	`81`	`{`
`80`		`- for (var i = 0; i < _declarations.Count; i++)`
	`82`	`+ if (_declarationIndex.TryGetValue(name, out var index) && index < _declarations.Count)`
`81`	`83`	`{`
`82`		`- var declaration = _declarations[i];`
	`84`	`+ var declaration = _declarations[index];`
`83`	`85`
`84`	`86`	`if (declaration.Name.Isi(name))`
`85`	`87`	`{`
`@@ -100,6 +102,7 @@ public void Update(String value)`
`100`	`102`	`if (!_updating)`
`101`	`103`	`{`
`102`	`104`	`_declarations.Clear();`
	`105`	`+ _declarationIndex.Clear();`
`103`	`106`
`104`	`107`	`if (!String.IsNullOrEmpty(value))`
`105`	`108`	`{`
`@@ -109,6 +112,7 @@ public void Update(String value)`
`109`	`112`	`if (decl != null)`
`110`	`113`	`{`
`111`	`114`	`_declarations.AddRange(decl);`
	`115`	`+ RebuildIndex();`
`112`	`116`	`}`
`113`	`117`	`}`
`114`	`118`	`}`
`@@ -304,12 +308,14 @@ public void SetProperty(String propertyName, String propertyValue, String priori`
`304`	`308`
`305`	`309`	`public void AddProperty(ICssProperty declaration)`
`306`	`310`	`{`
	`311`	`+ _declarationIndex[declaration.Name] = _declarations.Count;`
`307`	`312`	`_declarations.Add(declaration);`
`308`	`313`	`}`
`309`	`314`
`310`	`315`	`public void RemoveProperty(ICssProperty declaration)`
`311`	`316`	`{`
`312`	`317`	`_declarations.Remove(declaration);`
	`318`	`+ RebuildIndex();`
`313`	`319`	`}`
`314`	`320`
`315`	`321`	`#endregion`
`@@ -359,14 +365,24 @@ private void RemovePropertyByName(String propertyName)`
`359`	`365`	`var info = _context.GetDeclarationInfo(propertyName);`
`360`	`366`	`var longhands = info.Longhands;`
`361`	`367`
`362`		`- for (var i = 0; i < _declarations.Count; i++)`
	`368`	`+ if (_declarationIndex.TryGetValue(propertyName, out var index) && index < _declarations.Count &&`
	`369`	`+ _declarations[index].Name.Is(propertyName))`
`363`	`370`	`{`
`364`		`- var declaration = _declarations[i];`
`365`		`-`
`366`		`- if (declaration.Name.Is(propertyName))`
	`371`	`+ _declarations.RemoveAt(index);`
	`372`	`+ RebuildIndex();`
	`373`	`+ }`
	`374`	`+ else`
	`375`	`+ {`
	`376`	`+ for (var i = 0; i < _declarations.Count; i++)`
`367`	`377`	`{`
`368`		`- _declarations.RemoveAt(i);`
`369`		`- break;`
	`378`	`+ var declaration = _declarations[i];`
	`379`	`+`
	`380`	`+ if (declaration.Name.Is(propertyName))`
	`381`	`+ {`
	`382`	`+ _declarations.RemoveAt(i);`
	`383`	`+ RebuildIndex();`
	`384`	`+ break;`
	`385`	`+ }`
`370`	`386`	`}`
`371`	`387`	`}`
`372`	`388`
`@@ -389,23 +405,39 @@ private void ChangeDeclarations(IEnumerable<ICssProperty> decls, Predicate<ICssP`
`389`	`405`	`{`
`390`	`406`	`var skip = defaultSkip(newdecl);`
`391`	`407`
`392`		`- for (var i = 0; i < _declarations.Count; i++)`
	`408`	`+ if (_declarationIndex.TryGetValue(newdecl.Name, out var idx) && idx < _declarations.Count &&`
	`409`	`+ _declarations[idx].Name.Is(newdecl.Name))`
`393`	`410`	`{`
`394`		`- var olddecl = _declarations[i];`
`395`		`-`
`396`		`- if (olddecl.Name.Is(newdecl.Name))`
	`411`	`+ if (removeExisting.Invoke(_declarations[idx], newdecl))`
`397`	`412`	`{`
`398`		`- if (removeExisting.Invoke(olddecl, newdecl))`
`399`		`- {`
`400`		`- _declarations.RemoveAt(i);`
`401`		`- skip = false;`
`402`		`- }`
`403`		`- else`
	`413`	`+ _declarations.RemoveAt(idx);`
	`414`	`+ skip = false;`
	`415`	`+ }`
	`416`	`+ else`
	`417`	`+ {`
	`418`	`+ skip = true;`
	`419`	`+ }`
	`420`	`+ }`
	`421`	`+ else`
	`422`	`+ {`
	`423`	`+ for (var i = 0; i < _declarations.Count; i++)`
	`424`	`+ {`
	`425`	`+ var olddecl = _declarations[i];`
	`426`	`+`
	`427`	`+ if (olddecl.Name.Is(newdecl.Name))`
`404`	`428`	`{`
`405`		`- skip = true;`
`406`		`- }`
	`429`	`+ if (removeExisting.Invoke(olddecl, newdecl))`
	`430`	`+ {`
	`431`	`+ _declarations.RemoveAt(i);`
	`432`	`+ skip = false;`
	`433`	`+ }`
	`434`	`+ else`
	`435`	`+ {`
	`436`	`+ skip = true;`
	`437`	`+ }`
`407`	`438`
`408`		`- break;`
	`439`	`+ break;`
	`440`	`+ }`
`409`	`441`	`}`
`410`	`442`	`}`
`411`	`443`
`@@ -416,13 +448,14 @@ private void ChangeDeclarations(IEnumerable<ICssProperty> decls, Predicate<ICssP`
`416`	`448`	`}`
`417`	`449`
`418`	`450`	`_declarations.AddRange(declarations);`
	`451`	`+ RebuildIndex();`
`419`	`452`	`}`
`420`	`453`
`421`	`454`	`private void SetLonghand(ICssProperty property)`
`422`	`455`	`{`
`423`		`- for (var i = 0; i < _declarations.Count; i++)`
	`456`	`+ if (_declarationIndex.TryGetValue(property.Name, out var index) && index < _declarations.Count)`
`424`	`457`	`{`
`425`		`- var declaration = _declarations[i];`
	`458`	`+ var declaration = _declarations[index];`
`426`	`459`
`427`	`460`	`if (declaration.Name.Is(property.Name))`
`428`	`461`	`{`
`@@ -431,11 +464,12 @@ private void SetLonghand(ICssProperty property)`
`431`	`464`	`return;`
`432`	`465`	`}`
`433`	`466`
`434`		`- _declarations[i] = property;`
	`467`	`+ _declarations[index] = property;`
`435`	`468`	`return;`
`436`	`469`	`}`
`437`	`470`	`}`
`438`	`471`
	`472`	`+ _declarationIndex[property.Name] = _declarations.Count;`
`439`	`473`	`_declarations.Add(property);`
`440`	`474`	`}`
`441`	`475`
`@@ -452,6 +486,16 @@ private void SetShorthand(ICssProperty shorthand)`
`452`	`486`	`}`
`453`	`487`	`}`
`454`	`488`
	`489`	`+ private void RebuildIndex()`
	`490`	`+ {`
	`491`	`+ _declarationIndex.Clear();`
	`492`	`+`
	`493`	`+ for (var i = 0; i < _declarations.Count; i++)`
	`494`	`+ {`
	`495`	`+ _declarationIndex[_declarations[i].Name] = i;`
	`496`	`+ }`
	`497`	`+ }`
	`498`	`+`
`455`	`499`	`private void RaiseChanged()`
`456`	`500`	`{`
`457`	`501`	`if (!_updating)`