Attempt to stabilize whitespaces (#2211)

reakaleek · web-flow · commit 7dee0065ec70 · 2025-11-17T08:06:59.000Z
* Attempt to stabilize whitespaces

* Fix test
diff --git a/src/Elastic.Markdown/Helpers/DocumentationObjectPoolProvider.cs b/src/Elastic.Markdown/Helpers/DocumentationObjectPoolProvider.cs
@@ -28,7 +28,8 @@ public static string UseLlmMarkdownRenderer<TContext>(BuildContext buildContext,
 		try
 		{
 			action(subscription.LlmMarkdownRenderer, context);
-			return subscription.RentedStringBuilder!.ToString();
+			var result = subscription.RentedStringBuilder!.ToString();
+			return result.EnsureTrimmed();
 		}
 		finally
 		{
diff --git a/src/Elastic.Markdown/Helpers/StringExtensions.cs b/src/Elastic.Markdown/Helpers/StringExtensions.cs
@@ -0,0 +1,21 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Markdown.Helpers;
+
+internal static class StringExtensions
+{
+	/// <summary>
+	/// Ensures the string is trimmed of leading and trailing whitespace.
+	/// Only allocates a new string if trimming actually changes the content.
+	/// </summary>
+	/// <param name="value">The string to trim</param>
+	/// <returns>The trimmed string, reusing the original if no changes needed</returns>
+	public static string EnsureTrimmed(this string value)
+	{
+		var span = value.AsSpan();
+		var trimmed = span.Trim();
+		return trimmed.Length != value.Length ? trimmed.ToString() : value;
+	}
+}
diff --git a/src/Elastic.Markdown/Myst/CodeBlocks/CodeViewModel.cs b/src/Elastic.Markdown/Myst/CodeBlocks/CodeViewModel.cs
@@ -28,7 +28,9 @@ public HtmlString RenderBlock()
 		EnhancedCodeBlockHtmlRenderer.RenderCodeBlockLines(subscription.HtmlRenderer, EnhancedCodeBlock);
 		var result = subscription.RentedStringBuilder?.ToString();
 		DocumentationObjectPoolProvider.HtmlRendererPool.Return(subscription);
-		return new HtmlString(result);
+		return result == null
+			? HtmlString.Empty
+			: new HtmlString(result.EnsureTrimmed());
 	}
 
 	public HtmlString RenderLineWithCallouts(string content, int lineNumber)
diff --git a/src/Elastic.Markdown/Myst/CodeBlocks/EnhancedCodeBlockHtmlRenderer.cs b/src/Elastic.Markdown/Myst/CodeBlocks/EnhancedCodeBlockHtmlRenderer.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Elastic.Documentation.AppliesTo;
 using Elastic.Markdown.Diagnostics;
+using Elastic.Markdown.Helpers;
 using Elastic.Markdown.Myst.Comments;
 using Elastic.Markdown.Myst.Directives.AppliesTo;
 using Markdig.Helpers;
@@ -20,8 +21,11 @@ public class EnhancedCodeBlockHtmlRenderer : HtmlObjectRenderer<EnhancedCodeBloc
 	private const int TabWidth = 4;
 
 	[SuppressMessage("Reliability", "CA2012:Use ValueTasks correctly")]
-	private static void RenderRazorSlice<T>(RazorSlice<T> slice, HtmlRenderer renderer) =>
-		slice.RenderAsync(renderer.Writer).GetAwaiter().GetResult();
+	private static void RenderRazorSlice<T>(RazorSlice<T> slice, HtmlRenderer renderer)
+	{
+		var html = slice.RenderAsync().GetAwaiter().GetResult();
+		_ = renderer.Write(html.EnsureTrimmed());
+	}
 
 	/// <summary>
 	/// Renders the code block lines while also removing the common indentation level.
diff --git a/src/Elastic.Markdown/Myst/Directives/DirectiveHtmlRenderer.cs b/src/Elastic.Markdown/Myst/Directives/DirectiveHtmlRenderer.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Elastic.Documentation.AppliesTo;
 using Elastic.Markdown.Diagnostics;
+using Elastic.Markdown.Helpers;
 using Elastic.Markdown.Myst.CodeBlocks;
 using Elastic.Markdown.Myst.Directives.Admonition;
 using Elastic.Markdown.Myst.Directives.AppliesSwitch;
@@ -398,15 +399,21 @@ private static void WriteSettingsBlock(HtmlRenderer renderer, SettingsBlock bloc
 			{
 				var document = MarkdownParser.ParseMarkdownStringAsync(block.Build, block.Context, s, block.IncludeFrom, block.Context.YamlFrontMatter, MarkdownParser.Pipeline);
 				var html = document.ToHtml(MarkdownParser.Pipeline);
-				return html;
+
+				// Trim to ensure consistent whitespace
+				return html.EnsureTrimmed();
 			}
 		});
 		var html = slice.RenderAsync().GetAwaiter().GetResult();
 		_ = renderer.Write(html);
 	}
 
 	[SuppressMessage("Reliability", "CA2012:Use ValueTasks correctly")]
-	private static void RenderRazorSlice<T>(RazorSlice<T> slice, HtmlRenderer renderer) => slice.RenderAsync(renderer.Writer).GetAwaiter().GetResult();
+	private static void RenderRazorSlice<T>(RazorSlice<T> slice, HtmlRenderer renderer)
+	{
+		var html = slice.RenderAsync().GetAwaiter().GetResult();
+		_ = renderer.Write(html.EnsureTrimmed());
+	}
 
 	[SuppressMessage("Reliability", "CA2012:Use ValueTasks correctly")]
 	private static void RenderRazorSliceRawContent<T>(RazorSlice<T> slice, HtmlRenderer renderer, DirectiveBlock obj)
diff --git a/src/Elastic.Markdown/Myst/Directives/DirectiveViewModel.cs b/src/Elastic.Markdown/Myst/Directives/DirectiveViewModel.cs
@@ -18,6 +18,6 @@ public HtmlString RenderBlock()
 
 		var result = subscription.RentedStringBuilder?.ToString();
 		DocumentationObjectPoolProvider.HtmlRendererPool.Return(subscription);
-		return new HtmlString(result);
+		return result == null ? HtmlString.Empty : new HtmlString(result.EnsureTrimmed());
 	}
 }
diff --git a/src/Elastic.Markdown/Myst/Directives/Stepper/StepViewModel.cs b/src/Elastic.Markdown/Myst/Directives/Stepper/StepViewModel.cs
@@ -81,6 +81,6 @@ public HtmlString RenderTitle()
 
 		var result = subscription.RentedStringBuilder?.ToString() ?? Title;
 		DocumentationObjectPoolProvider.HtmlRendererPool.Return(subscription);
-		return new(result);
+		return new HtmlString(result.EnsureTrimmed());
 	}
 }
diff --git a/src/Elastic.Markdown/Myst/Renderers/LlmMarkdown/LlmBlockRenderers.cs b/src/Elastic.Markdown/Myst/Renderers/LlmMarkdown/LlmBlockRenderers.cs
@@ -86,9 +86,6 @@ public static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Mark
 			return url;
 		}
 	}
-
-
-
 }
 
 /// <summary>
@@ -140,6 +137,7 @@ protected override void Write(LlmMarkdownRenderer renderer, EnhancedCodeBlock ob
 			renderer.Write(obj.Caption);
 			renderer.WriteLine(" -->");
 		}
+
 		renderer.Write("```");
 		if (!string.IsNullOrEmpty(obj.Language))
 			renderer.Write(obj.Language);
@@ -151,6 +149,7 @@ protected override void Write(LlmMarkdownRenderer renderer, EnhancedCodeBlock ob
 			renderer.Write(line.ToString());
 			renderer.WriteLine();
 		}
+
 		renderer.WriteLine("```");
 	}
 
@@ -170,32 +169,35 @@ public class LlmListRenderer : MarkdownObjectRenderer<LlmMarkdownRenderer, ListB
 {
 	protected override void Write(LlmMarkdownRenderer renderer, ListBlock listBlock)
 	{
-		var baseIndent = CalculateNestedIndentation(listBlock);
-		if (listBlock.Parent is not ListItemBlock)
+		var isNestedList = listBlock.Parent is ListItemBlock;
+
+		// Nested lists don't need base indent - parent's continuation indent positions them correctly
+		var baseIndent = isNestedList ? "" : CalculateNestedIndentation(listBlock);
+
+		// Top-level lists need block spacing before them
+		if (!isNestedList)
 			renderer.EnsureBlockSpacing();
 
 		var isOrdered = listBlock.IsOrdered;
-		var itemIndex = 1;
-		if (isOrdered && int.TryParse(listBlock.DefaultOrderedStart, out var startIndex))
-			itemIndex = startIndex;
+		var itemIndex = listBlock.IsOrdered && int.TryParse(listBlock.DefaultOrderedStart, out var startIndex)
+			? startIndex
+			: 1;
 
-		foreach (var item in listBlock.Cast<ListItemBlock>())
+		var items = listBlock.Cast<ListItemBlock>().ToArray();
+		foreach (var item in items)
 		{
 			renderer.Write(baseIndent);
 			renderer.Write(isOrdered ? $"{itemIndex}. " : "- ");
-			foreach (var block in item)
+			for (var blockIndex = 0; blockIndex < item.Count; blockIndex++)
 			{
-				if (block != item.First())
+				var block = item[blockIndex];
+				if (blockIndex > 0)
 				{
-					var continuationIndent = GetContinuationIndent(baseIndent, isOrdered);
-					renderer.Write(continuationIndent);
+					renderer.EnsureLine();
+					renderer.Write(GetContinuationIndent(baseIndent, isOrdered));
 				}
-
-				if (block != item.First() && block is ListBlock)
-					renderer.WriteLine();
 				RenderBlockWithIndentation(renderer, block, baseIndent, isOrdered);
 			}
-
 			renderer.EnsureLine();
 			if (isOrdered)
 				itemIndex++;
@@ -207,12 +209,22 @@ private static string GetContinuationIndent(string baseIndent, bool isOrdered) =
 
 	private static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Block block, string baseIndent, bool isOrdered)
 	{
+		// Nested lists render in same context to preserve indentation
+		if (block is ListBlock)
+		{
+			_ = renderer.Render(block);
+			return;
+		}
+
+		// Render other blocks in separate context and re-indent each line
 		var blockOutput = DocumentationObjectPoolProvider.UseLlmMarkdownRenderer(renderer.BuildContext, block, static (tmpRenderer, obj) =>
 		{
 			_ = tmpRenderer.Render(obj);
 		});
+
 		var continuationIndent = GetContinuationIndent(baseIndent, isOrdered);
 		var lines = blockOutput.Split('\n');
+
 		for (var i = 0; i < lines.Length; i++)
 		{
 			var line = lines[i];
@@ -222,6 +234,7 @@ private static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Blo
 			{
 				renderer.WriteLine();
 				renderer.Write(continuationIndent);
+				// Preserve exact code block formatting, trim other content
 				renderer.Write(block is CodeBlock ? line : line.TrimStart());
 			}
 			else if (i < lines.Length - 1)
@@ -329,6 +342,7 @@ private static void RenderTableRowCells(LlmMarkdownRenderer renderer, TableRow r
 			renderer.Writer.Write(" |");
 			cellIndex++;
 		}
+
 		renderer.WriteLine();
 	}
 
@@ -665,7 +679,6 @@ public class LlmDefinitionItemRenderer : MarkdownObjectRenderer<LlmMarkdownRende
 {
 	protected override void Write(LlmMarkdownRenderer renderer, DefinitionItem obj)
 	{
-
 		var first = obj.Cast<LeafBlock>().First();
 		renderer.EnsureBlockSpacing();
 		renderer.Write("<definition");
@@ -679,6 +692,7 @@ protected override void Write(LlmMarkdownRenderer renderer, DefinitionItem obj)
 			var block = obj[index];
 			LlmRenderingHelpers.RenderBlockWithIndentation(renderer, block);
 		}
+
 		renderer.WriteLine("</definition>");
 	}
 
diff --git a/tests-integration/Elastic.Assembler.IntegrationTests/DocsSyncTests.cs b/tests-integration/Elastic.Assembler.IntegrationTests/DocsSyncTests.cs
@@ -306,6 +306,7 @@ public async Task TestApply()
 		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.added" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 3);
 		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.updated" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);
 		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.deleted" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);
-		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.total" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 5);
+		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.skipped" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);
+		tagObjects.Should().Contain(t => t.Key == "docs.sync.files.total" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 6);
 	}
 }
diff --git a/tests/authoring/LlmMarkdown/LlmMarkdownOutput.fs b/tests/authoring/LlmMarkdown/LlmMarkdownOutput.fs
@@ -327,10 +327,9 @@ type ``directive in list should be indented correctly`` () =
   ```python
   def hello():
       print("Hello, world!")
-```
+  ```
 - List item 2  
   <tip>
-
   - Nested list item 1
   - Nested list item 2
   </tip>
@@ -355,7 +354,6 @@ This is where the content for tab #2 goes.
     let ``rendered correctly`` () =
         markdown |> convertsToNewLLM """
 <tab-set>
-
   <tab-item title="Tab #1 title">
     This is where the content for tab #1 goes.
   </tab-item>

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,8 @@ public static string UseLlmMarkdownRenderer<TContext>(BuildContext buildContext,`
`28`	`28`	`try`
`29`	`29`	`{`
`30`	`30`	`action(subscription.LlmMarkdownRenderer, context);`
`31`		`- return subscription.RentedStringBuilder!.ToString();`
	`31`	`+ var result = subscription.RentedStringBuilder!.ToString();`
	`32`	`+ return result.EnsureTrimmed();`
`32`	`33`	`}`
`33`	`34`	`finally`
`34`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,6 @@ public HtmlString RenderBlock()`
`18`	`18`
`19`	`19`	`var result = subscription.RentedStringBuilder?.ToString();`
`20`	`20`	`DocumentationObjectPoolProvider.HtmlRendererPool.Return(subscription);`
`21`		`- return new HtmlString(result);`
	`21`	`+ return result == null ? HtmlString.Empty : new HtmlString(result.EnsureTrimmed());`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,6 @@ public HtmlString RenderTitle()`
`81`	`81`
`82`	`82`	`var result = subscription.RentedStringBuilder?.ToString() ?? Title;`
`83`	`83`	`DocumentationObjectPoolProvider.HtmlRendererPool.Return(subscription);`
`84`		`- return new(result);`
	`84`	`+ return new HtmlString(result.EnsureTrimmed());`
`85`	`85`	`}`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,9 +86,6 @@ public static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Mark`
`86`	`86`	`return url;`
`87`	`87`	`}`
`88`	`88`	`}`
`89`		`-`
`90`		`-`
`91`		`-`
`92`	`89`	`}`
`93`	`90`
`94`	`91`	`/// <summary>`
`@@ -140,6 +137,7 @@ protected override void Write(LlmMarkdownRenderer renderer, EnhancedCodeBlock ob`
`140`	`137`	`renderer.Write(obj.Caption);`
`141`	`138`	`renderer.WriteLine(" -->");`
`142`	`139`	`}`
	`140`	`+`
`143`	`141`	renderer.Write("```");
`144`	`142`	`if (!string.IsNullOrEmpty(obj.Language))`
`145`	`143`	`renderer.Write(obj.Language);`
`@@ -151,6 +149,7 @@ protected override void Write(LlmMarkdownRenderer renderer, EnhancedCodeBlock ob`
`151`	`149`	`renderer.Write(line.ToString());`
`152`	`150`	`renderer.WriteLine();`
`153`	`151`	`}`
	`152`	`+`
`154`	`153`	renderer.WriteLine("```");
`155`	`154`	`}`
`156`	`155`
`@@ -170,32 +169,35 @@ public class LlmListRenderer : MarkdownObjectRenderer<LlmMarkdownRenderer, ListB`
`170`	`169`	`{`
`171`	`170`	`protected override void Write(LlmMarkdownRenderer renderer, ListBlock listBlock)`
`172`	`171`	`{`
`173`		`- var baseIndent = CalculateNestedIndentation(listBlock);`
`174`		`- if (listBlock.Parent is not ListItemBlock)`
	`172`	`+ var isNestedList = listBlock.Parent is ListItemBlock;`
	`173`	`+`
	`174`	`+ // Nested lists don't need base indent - parent's continuation indent positions them correctly`
	`175`	`+ var baseIndent = isNestedList ? "" : CalculateNestedIndentation(listBlock);`
	`176`	`+`
	`177`	`+ // Top-level lists need block spacing before them`
	`178`	`+ if (!isNestedList)`
`175`	`179`	`renderer.EnsureBlockSpacing();`
`176`	`180`
`177`	`181`	`var isOrdered = listBlock.IsOrdered;`
`178`		`- var itemIndex = 1;`
`179`		`- if (isOrdered && int.TryParse(listBlock.DefaultOrderedStart, out var startIndex))`
`180`		`- itemIndex = startIndex;`
	`182`	`+ var itemIndex = listBlock.IsOrdered && int.TryParse(listBlock.DefaultOrderedStart, out var startIndex)`
	`183`	`+ ? startIndex`
	`184`	`+ : 1;`
`181`	`185`
`182`		`- foreach (var item in listBlock.Cast<ListItemBlock>())`
	`186`	`+ var items = listBlock.Cast<ListItemBlock>().ToArray();`
	`187`	`+ foreach (var item in items)`
`183`	`188`	`{`
`184`	`189`	`renderer.Write(baseIndent);`
`185`	`190`	`renderer.Write(isOrdered ? $"{itemIndex}. " : "- ");`
`186`		`- foreach (var block in item)`
	`191`	`+ for (var blockIndex = 0; blockIndex < item.Count; blockIndex++)`
`187`	`192`	`{`
`188`		`- if (block != item.First())`
	`193`	`+ var block = item[blockIndex];`
	`194`	`+ if (blockIndex > 0)`
`189`	`195`	`{`
`190`		`- var continuationIndent = GetContinuationIndent(baseIndent, isOrdered);`
`191`		`- renderer.Write(continuationIndent);`
	`196`	`+ renderer.EnsureLine();`
	`197`	`+ renderer.Write(GetContinuationIndent(baseIndent, isOrdered));`
`192`	`198`	`}`
`193`		`-`
`194`		`- if (block != item.First() && block is ListBlock)`
`195`		`- renderer.WriteLine();`
`196`	`199`	`RenderBlockWithIndentation(renderer, block, baseIndent, isOrdered);`
`197`	`200`	`}`
`198`		`-`
`199`	`201`	`renderer.EnsureLine();`
`200`	`202`	`if (isOrdered)`
`201`	`203`	`itemIndex++;`
`@@ -207,12 +209,22 @@ private static string GetContinuationIndent(string baseIndent, bool isOrdered) =`
`207`	`209`
`208`	`210`	`private static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Block block, string baseIndent, bool isOrdered)`
`209`	`211`	`{`
	`212`	`+ // Nested lists render in same context to preserve indentation`
	`213`	`+ if (block is ListBlock)`
	`214`	`+ {`
	`215`	`+ _ = renderer.Render(block);`
	`216`	`+ return;`
	`217`	`+ }`
	`218`	`+`
	`219`	`+ // Render other blocks in separate context and re-indent each line`
`210`	`220`	`var blockOutput = DocumentationObjectPoolProvider.UseLlmMarkdownRenderer(renderer.BuildContext, block, static (tmpRenderer, obj) =>`
`211`	`221`	`{`
`212`	`222`	`_ = tmpRenderer.Render(obj);`
`213`	`223`	`});`
	`224`	`+`
`214`	`225`	`var continuationIndent = GetContinuationIndent(baseIndent, isOrdered);`
`215`	`226`	`var lines = blockOutput.Split('\n');`
	`227`	`+`
`216`	`228`	`for (var i = 0; i < lines.Length; i++)`
`217`	`229`	`{`
`218`	`230`	`var line = lines[i];`
`@@ -222,6 +234,7 @@ private static void RenderBlockWithIndentation(LlmMarkdownRenderer renderer, Blo`
`222`	`234`	`{`
`223`	`235`	`renderer.WriteLine();`
`224`	`236`	`renderer.Write(continuationIndent);`
	`237`	`+ // Preserve exact code block formatting, trim other content`
`225`	`238`	`renderer.Write(block is CodeBlock ? line : line.TrimStart());`
`226`	`239`	`}`
`227`	`240`	`else if (i < lines.Length - 1)`
`@@ -329,6 +342,7 @@ private static void RenderTableRowCells(LlmMarkdownRenderer renderer, TableRow r`
`329`	`342`	`renderer.Writer.Write(" \|");`
`330`	`343`	`cellIndex++;`
`331`	`344`	`}`
	`345`	`+`
`332`	`346`	`renderer.WriteLine();`
`333`	`347`	`}`
`334`	`348`
`@@ -665,7 +679,6 @@ public class LlmDefinitionItemRenderer : MarkdownObjectRenderer<LlmMarkdownRende`
`665`	`679`	`{`
`666`	`680`	`protected override void Write(LlmMarkdownRenderer renderer, DefinitionItem obj)`
`667`	`681`	`{`
`668`		`-`
`669`	`682`	`var first = obj.Cast<LeafBlock>().First();`
`670`	`683`	`renderer.EnsureBlockSpacing();`
`671`	`684`	`renderer.Write("<definition");`
`@@ -679,6 +692,7 @@ protected override void Write(LlmMarkdownRenderer renderer, DefinitionItem obj)`
`679`	`692`	`var block = obj[index];`
`680`	`693`	`LlmRenderingHelpers.RenderBlockWithIndentation(renderer, block);`
`681`	`694`	`}`
	`695`	`+`
`682`	`696`	`renderer.WriteLine("</definition>");`
`683`	`697`	`}`
`684`	`698`
Original file line number	Diff line number	Diff line change
`@@ -306,6 +306,7 @@ public async Task TestApply()`
`306`	`306`	`tagObjects.Should().Contain(t => t.Key == "docs.sync.files.added" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 3);`
`307`	`307`	`tagObjects.Should().Contain(t => t.Key == "docs.sync.files.updated" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);`
`308`	`308`	`tagObjects.Should().Contain(t => t.Key == "docs.sync.files.deleted" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);`
`309`		`- tagObjects.Should().Contain(t => t.Key == "docs.sync.files.total" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 5);`
	`309`	`+ tagObjects.Should().Contain(t => t.Key == "docs.sync.files.skipped" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 1);`
	`310`	`+ tagObjects.Should().Contain(t => t.Key == "docs.sync.files.total" && Convert.ToInt64(t.Value, System.Globalization.CultureInfo.InvariantCulture) == 6);`
`310`	`311`	`}`
`311`	`312`	`}`