Fix CSS minifier dropping rules after quotes-in-comments

The CSS minifier protected string literals before stripping comments,
so a quote or apostrophe inside a comment (e.g. `It's` or a "quoted"
word) was mistaken for a string delimiter. That could swallow the rule
immediately following the comment and drop it from the output.

Strip CSS comments up front with a small string-aware scanner that
skips over string literals (so `content: "/*"` is preserved) before the
existing string-protection / whitespace passes run. Add regression tests
for comments containing apostrophes/quotes and for comment-like tokens
inside CSS strings.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Netdocs

src/Netdocs.Core/Optimization/CssJsMinifier.cs

@@ -15,15 +15,63 @@ public static string MinifyCss(string css)
     {
         if (string.IsNullOrEmpty(css)) return css;
 
+        // Strip comments with a string-aware scanner FIRST. A regex that protects string literals
+        // before removing comments mis-reads quotes/apostrophes that live inside a comment (e.g.
+        // "it's" or a quoted word), which can swallow the following rule. Removing comments up
+        // front means the later string-protection pass only ever sees real CSS strings.
+        css = StripCssComments(css);
+
         var (withPlaceholders, strings) = ProtectStrings(css);
-        withPlaceholders = CssComments().Replace(withPlaceholders, "");
         withPlaceholders = Whitespace().Replace(withPlaceholders, " ");
         // Tidy spaces around structural punctuation.
         withPlaceholders = CssAroundPunctuation().Replace(withPlaceholders, "$1");
         withPlaceholders = withPlaceholders.Replace(";}", "}").Trim();
         return RestoreStrings(withPlaceholders, strings);
     }
 
+    /// <summary>
+    /// Removes <c>/* … */</c> comments while skipping over string literals so a <c>/*</c> that
+    /// appears inside a CSS string (e.g. <c>content: "/*"</c>) is preserved, and quotes inside a
+    /// comment are discarded with the comment rather than treated as string delimiters.
+    /// </summary>
+    private static string StripCssComments(string css)
+    {
+        var sb = new System.Text.StringBuilder(css.Length);
+        int i = 0, n = css.Length;
+        while (i < n)
+        {
+            var c = css[i];
+
+            if (c is '"' or '\'')
+            {
+                var quote = c;
+                sb.Append(c);
+                i++;
+                while (i < n)
+                {
+                    var d = css[i];
+                    sb.Append(d);
+                    if (d == '\\' && i + 1 < n) { sb.Append(css[i + 1]); i += 2; continue; }
+                    i++;
+                    if (d == quote) break;
+                }
+                continue;
+            }
+
+            if (c == '/' && i + 1 < n && css[i + 1] == '*')
+            {
+                i += 2;
+                while (i + 1 < n && !(css[i] == '*' && css[i + 1] == '/')) i++;
+                i = Math.Min(i + 2, n); // skip closing */ (tolerate unterminated)
+                continue;
+            }
+
+            sb.Append(c);
+            i++;
+        }
+        return sb.ToString();
+    }
+
     /// <summary>
     /// Minifies JavaScript conservatively: drops block and line comments and collapses runs of
     /// whitespace to a single space. Line breaks are preserved as spaces so automatic
@@ -59,9 +107,6 @@ private static string RestoreStrings(string text, List<string> strings) =>
     [GeneratedRegex(@"""(?:\\.|[^""\\])*""|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`")]
     private static partial Regex StringLiterals();
 
-    [GeneratedRegex(@"/\*[\s\S]*?\*/")]
-    private static partial Regex CssComments();
-
     [GeneratedRegex(@"/\*[\s\S]*?\*/")]
     private static partial Regex JsBlockComments();
 

tests/Netdocs.Core.Tests/CssJsMinifierTests.cs

@@ -31,6 +31,31 @@ public void MinifyCss_PreservesStringContents()
         Assert.Contains("\"  spaced  value  \"", min);
     }
 
+    [Fact]
+    public void MinifyCss_CommentWithApostropheAndQuotes_DoesNotDropFollowingRule()
+    {
+        // Regression: a comment containing an apostrophe or quoted word used to make the
+        // string-protection pass swallow the rule that followed it, dropping it from the output.
+        var css = """
+            /* It's a subtle "highlight" instead of an underline. */
+            .md-tabs__item--active .md-tabs__link {
+                font-weight: 700;
+            }
+            """;
+        var min = CssJsMinifier.MinifyCss(css);
+
+        Assert.DoesNotContain("/*", min);
+        Assert.Contains(".md-tabs__item--active .md-tabs__link{font-weight:700}", min);
+    }
+
+    [Fact]
+    public void MinifyCss_DoesNotTreatCommentTokenInsideString_AsComment()
+    {
+        var css = "a::before { content: \"/* not a comment */\"; }";
+        var min = CssJsMinifier.MinifyCss(css);
+        Assert.Contains("\"/* not a comment */\"", min);
+    }
+
     [Fact]
     public void MinifyJs_StripsCommentsAndCollapsesWhitespace()
     {