CssData: index nested and layered rules; resolve colours through the engine

Three consumer-side changes the refreshed engine needs to actually take effect.

CssData.IndexRules now recurses into IStyleRule.NestedRules and ILayerRule.Rules.
A CSS-Nesting child rule lives in its parent's NestedRules, deliberately outside
Children, so it is invisible to Stylesheet.Rules - without the recursion every
nested rule would parse and then silently never apply. Likewise, once `@layer
name { ... }` parses into a LayerRule, its contents would fall through the
if/else chain and stop applying; they are now indexed as ordinary unlayered
rules. Layer *precedence* is still not implemented.

CssData.FlattenStyleRules replaces the top-level-only Stylesheet.StyleRules scan
in DomUtils.WriteStylesheet/CollectSimpleSelectorStyles and
DomParser.SetTextSelectionStyle, so a ::selection rule nested inside @layer or
another rule is still found.

CssParser.ParseStyle no longer lets a bare `@layer a, b;` statement close the
@import prologue - that is legal before @import per CSS Cascade 5, and treating
it as a non-import rule silently skipped every @import after it.

CssValueParser.GetColorByName falls back to the engine's ToResolvedColor when
the adapter's palette does not recognize a value, so lab()/oklab()/lch()/
oklch()/color-mix() resolve to real colours everywhere a colour is parsed
instead of coming out black. It also fixes `transparent`, which the palette
reports with a zero alpha and which was previously rejected as invalid.

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

Author: 2 people

Source/HtmlRenderer/Core/CssData.cs

@@ -129,6 +129,38 @@ public IndexedRule(IStyleRule rule, bool isUserAgent, int documentOrder, MediaLi
         private Dictionary<string, List<IndexedRule>> _idIndex;
         private List<IndexedRule> _universalRules;
 
+        /// <summary>
+        /// Every style rule in a rule list, in document order, descending into <c>@media</c> and
+        /// <c>@layer</c> blocks and into CSS-Nesting child rules. <see cref="Stylesheet.StyleRules"/>
+        /// only sees the top level, so callers that scan for a rule by selector (rather than matching
+        /// against a box) need this or they miss anything nested. <c>@supports</c>/<c>@container</c> are
+        /// deliberately not descended into: their conditions are not evaluated, so their contents do not
+        /// apply.
+        /// </summary>
+        internal static IEnumerable<IStyleRule> FlattenStyleRules(IEnumerable<IRule> rules)
+        {
+            foreach (var rule in rules)
+            {
+                if (rule is IStyleRule styleRule)
+                {
+                    yield return styleRule;
+
+                    foreach (var nested in FlattenStyleRules(styleRule.NestedRules))
+                        yield return nested;
+                }
+                else if (rule is IMediaRule mediaRule)
+                {
+                    foreach (var nested in FlattenStyleRules(mediaRule.Rules))
+                        yield return nested;
+                }
+                else if (rule is ILayerRule layerRule)
+                {
+                    foreach (var nested in FlattenStyleRules(layerRule.Rules))
+                        yield return nested;
+                }
+            }
+        }
+
         private void EnsureIndex()
         {
             if (_universalRules != null) return;
@@ -152,10 +184,10 @@ private void EnsureIndex()
         }
 
         /// <summary>
-        /// Walks a rule list in true document order, recursing into <c>@media</c> blocks (any
-        /// nesting depth) in place, and buckets every style rule found - assigning each an
-        /// ever-increasing <see cref="IndexedRule.DocumentOrder"/> and recording the chain of
-        /// enclosing media conditions it's nested under, if any.
+        /// Walks a rule list in true document order, recursing into <c>@media</c> blocks, <c>@layer</c>
+        /// blocks and CSS-Nesting child rules (any nesting depth) in place, and buckets every style rule
+        /// found - assigning each an ever-increasing <see cref="IndexedRule.DocumentOrder"/> and recording
+        /// the chain of enclosing media conditions it's nested under, if any.
         /// </summary>
         private static void IndexRules(
             IEnumerable<IRule> rules,
@@ -200,6 +232,16 @@ private static void IndexRules(
                             list.Add(indexedRule);
                         }
                     }
+
+                    // CSS Nesting: a nested rule lives in its parent's NestedRules, deliberately not in
+                    // Children, so it is invisible to Stylesheet.Rules and would otherwise never be
+                    // indexed. Its selector was already resolved against the parent at parse time, so it
+                    // indexes like any other rule - under the same media context, and with a document
+                    // order that continues from the parent so it tie-breaks after it.
+                    if (styleRule.NestedRules.Count > 0)
+                    {
+                        IndexRules(styleRule.NestedRules, isUserAgent, enclosingMedia, tagIndex, classIndex, idIndex, universal, keys, ref order);
+                    }
                 }
                 else if (rule is IMediaRule mediaRule)
                 {
@@ -208,6 +250,18 @@ private static void IndexRules(
                         : enclosingMedia.Concat(new[] { mediaRule.Media }).ToArray();
                     IndexRules(mediaRule.Rules, isUserAgent, nestedMedia, tagIndex, classIndex, idIndex, universal, keys, ref order);
                 }
+                else if (rule is ILayerRule layerRule)
+                {
+                    // @layer's contents are indexed as ordinary, unlayered rules: they apply, ordered by
+                    // source position and specificity. Layer precedence, !important layer reversal and
+                    // revert-layer are deliberately not implemented - that needs a layer-banded cascade,
+                    // which is separate work. Without this branch the block would fall through and every
+                    // rule inside a layer would silently stop applying.
+                    IndexRules(layerRule.Rules, isUserAgent, enclosingMedia, tagIndex, classIndex, idIndex, universal, keys, ref order);
+                }
+                // Everything else (@layer statements, @property, @font-palette-values, @supports,
+                // @container, ...) contributes no style rules to the cascade, so falling through is the
+                // correct handling rather than an oversight.
             }
         }
 

Source/HtmlRenderer/Core/Parse/CssParser.cs

@@ -243,8 +243,10 @@ private void ParseStyle(CssData data, string stylesheetText, Uri baseUri, HashSe
                         data.Combine(importedCssData);
                     }
                 }
-                else
+                else if (!(rule is LayerStatementRule))
                 {
+                    // A bare `@layer a, b;` statement is allowed before @import (CSS Cascade 5 §6.4.1), so
+                    // it must not close the @import prologue - otherwise every following @import is skipped.
                     hasReachedNonImportRules = true;
                 }
             }

Source/HtmlRenderer/Core/Parse/CssValueParser.cs

@@ -682,13 +682,35 @@ private static bool TryParseAngleDegrees(string value, out double degrees)
         }
 
         /// <summary>
-        /// Get color by given name, including .NET name.
+        /// Get color by given name (including .NET names), or by any color function the CSS engine
+        /// understands.
         /// </summary>
+        /// <remarks>
+        /// The adapter's palette is tried first because a bare name is by far the common case and a
+        /// dictionary lookup is cheaper than tokenizing. Anything it doesn't recognize - a CSS Color 4/5
+        /// function such as <c>lab()</c>/<c>oklch()</c>/<c>color-mix()</c>, or a fully transparent color,
+        /// which the palette reports with a zero alpha and is indistinguishable from "unknown" here - is
+        /// then resolved through the engine, which is the same code path the cascade validated the value
+        /// with. Hex/rgb()/rgba()/hsl()/hsla() never reach this method; they keep their own fast paths in
+        /// <see cref="TryGetColor"/>.
+        /// </remarks>
         /// <returns>true - valid color, false - otherwise</returns>
         private bool GetColorByName(string str, int idx, int length, out RColor color)
         {
-            color = _adapter.GetColor(str.Substring(idx, length));
-            return color.A > 0;
+            var text = str.Substring(idx, length);
+
+            color = _adapter.GetColor(text);
+            if (color.A > 0) return true;
+
+            var resolved = GetCssTokens(text).ToResolvedColor();
+            if (resolved != null)
+            {
+                var value = resolved.Value;
+                color = RColor.FromArgb(value.A, value.R, value.G, value.B);
+                return true;
+            }
+
+            return false;
         }
 
         /// <summary>

Source/HtmlRenderer/Core/Parse/DomParser.cs

@@ -778,7 +778,7 @@ private void SetTextSelectionStyle(HtmlContainerInt htmlContainer, CssData cssDa
 
             foreach (var stylesheet in cssData.Stylesheets)
             {
-                foreach (var rule in stylesheet.StyleRules)
+                foreach (var rule in CssData.FlattenStyleRules(stylesheet.Rules))
                 {
                     if (!SelectorIsSelectionPseudoElement(rule.Selector)) continue;
 

Source/HtmlRenderer/Core/Utils/DomUtils.cs

@@ -901,7 +901,7 @@ private static void CollectSimpleSelectorStyles(CssData cssData, Func<ISelector,
         {
             foreach (var stylesheet in cssData.Stylesheets)
             {
-                foreach (var rule in stylesheet.StyleRules)
+                foreach (var rule in CssData.FlattenStyleRules(stylesheet.Rules))
                 {
                     if (!selectorMatches(rule.Selector)) continue;
                     foreach (var prop in rule.Style)
@@ -940,7 +940,7 @@ private static void WriteStylesheet(StringBuilder sb, CssData cssData)
             sb.AppendLine("<style type=\"text/css\">");
             foreach (var stylesheet in cssData.Stylesheets)
             {
-                foreach (var rule in stylesheet.StyleRules)
+                foreach (var rule in CssData.FlattenStyleRules(stylesheet.Rules))
                 {
                     sb.Append(rule.SelectorText);
                     sb.Append(" { ");