Keep comments in `CssStyleSheet`

[mganss]

It seems that CSS comments are not kept in the CSSOM and thus are not preserved when you call ToCss() on a previously parsed CssStyleSheet object.

var html = @"<style>  /* Set text color to red */ h1{color:red}</style>";
var parser = new HtmlParser(new HtmlParserOptions(), BrowsingContext.New(Configuration.Default.WithCss(new CssParserOptions())));
var dom = parser.ParseDocument(html);
var styleSheet = dom.StyleSheets[0] as ICssStyleSheet;
var css = styleSheet.ToCss(); // -> "h1 { color: rgba(255, 0, 0, 1) }"

[FlorianRappl]

Well, there is no such thing in the CSSOM; we collect all that into "trivia" (a technique popularized by Roslyn). The ToCss serialization only works on the CSSOM -> so in order to serialize with the comments something else would need to be serialized (or the CSSOM would need to be extended / changed).

Potentially, a flag could be introduced, but even then I am not sure how these comments would be attached. Maybe they would be attached to the stylesheet itself with a reference "where" they should be placed (this "where" is a big problem; in this OM things may be added, removed, changed, ... - I guess any change would then need to reset / remove / alter the comments?).

[mganss]

I realize this is a non-trivial endeavour, in particular the "where" part you mentioned. Unlike in HTML, comments in CSS can be arbitrarily interleaved with other tokens (e.g. background-color: /* black */ #000;) so this would need to be reflected in the OM as well. Feel free to close this.

[FlorianRappl]

I really tried to have this feature, but I don't think we will...

Benchmark setup:

• Size: 6000 rules, 8 declarations per rule
• Runs: 5 warmup + 15 measured iterations
• Measured: parse time, serialize time, total parse+serialize time

Covered scenarios:

1. Old code, large stylesheet with many comments, parse + serialize
2. New code, parse + serialize with no comment saved or output
3. New code, parse + serialize with comment persistence and comment-preserving output

Results (mean in ms):

Scenario	Input bytes	Parse ms	Serialize ms	Total ms	Output bytes
1) Old code, commented input, normal output	2,122,401	247.581	217.084	464.668	1,097,900
2) New code, no comments in input/output	1,161,501	265.128	292.900	558.031	1,097,900
3) New code, commented input, preserve comments	2,122,401	350.551	3568.417	3918.970	2,152,580

Results:

• Scenario 2 vs Scenario 1: +20.1% total, but input is much smaller in Scenario 2 (no comments), so this is not apples-to-apples for comment overhead.
• Better apples-to-apples comparison is old vs new with commented input and preserve disabled:
  • Old commented total: 464.668 ms
  • New commented total (preserve disabled): 583.314 ms
  • Overhead: +25.5% total
  • Parse overhead: +29.7%
  • Serialize overhead: +20.8%
• Enabling comment-preserving output is very expensive in current implementation:
  • New commented preserve enabled: 3918.970 ms total
  • vs new commented preserve disabled: +571.8% total
  • serialize step dominates (3568 ms vs 262 ms), so the bottleneck is serialization path when preserving comments.

So unless I come up with a better strategy / implementation I would not take it in. I leave it open for now.

[FlorianRappl]

Update: Will mostly ship a version of this that preserves comments, but does not preserve comment positions (depending on the position). Comments are essentially rules, but without any meaning. As such when activated they are within the CSSOM - deviating from the standard (as such this will be an opt-in).

Scenario	Parse ms (mean)	Serialize ms (mean)	Total ms (mean)	Output bytes
Old code, commented input, normal output	304.998	274.674	579.675	1,097,900
New redesign, no comments in input/output	262.926	245.785	508.714	1,097,900
New redesign, commented input, preserve output	320.598	279.478	600.080	1,896,801

With this we have:

1. Scenario 2 (new, no comments) is 12.2% faster total than old baseline.
2. Scenario 3 (new, commented + preserve) is only 3.5% slower total than old baseline.
3. Preserve overhead within the new design is small compared to previous behavior:
   • Total: +6.1% vs new commented/no-preserve.
   • Serialize only: +14.2% vs new commented/no-preserve.

I know that some scenarios are not covered by this (e.g., previous example background-color: /* black */ #000), but assuming that most comments are really where a rule or declaration is formed this might be a good compromise.