fix(snippets): preserve indentation of block includes

Snippet block includes discarded the marker's leading indentation, inserting
file content at column 0. When the include sat inside an indented context - a
fenced code block within an admonition, or a nested list item - the un-indented
content broke out of that context: the code fence closed empty and the included
file was parsed as top-level markdown (script comments became h1 headers,
breaking the whole page).

Capture the marker's leading whitespace and prepend it to every non-blank line
of the included (and recursively expanded) content, matching pymdownx.snippets.

Add regression tests: indented include keeps indentation, blank lines are not
indented, and unindented includes are unchanged.

Author: Netdocs

src/Netdocs.Plugins/SnippetsPlugin.cs

@@ -83,6 +83,7 @@ private string Expand(string markdown, int depth)
         return IncludeRegex().Replace(markdown, match =>
         {
             var spec = match.Groups["spec"].Value.Trim();
+            var indent = match.Groups["indent"].Value;
             string? section = null;
             var path = spec;
             var colon = spec.LastIndexOf(':');
@@ -94,15 +95,41 @@ private string Expand(string markdown, int depth)
 
             var resolved = Resolve(path);
             if (resolved is null || !File.Exists(resolved))
-                return $"<!-- snippet not found: {path} -->";
+                return $"{indent}<!-- snippet not found: {path} -->";
 
             var content = File.ReadAllText(resolved);
             if (section is not null)
                 content = ExtractSection(content, section);
-            return Expand(content, depth + 1);
+            var expanded = Expand(content, depth + 1);
+            return Reindent(expanded, indent);
         });
     }
 
+    /// <summary>Prepends the snippet marker's leading indentation to every line of the
+    /// included content. pymdownx.snippets does this so that an include placed inside an
+    /// indented context (a code fence within an admonition, a nested list item, etc.)
+    /// keeps that context instead of breaking out of it. Without this, an indented
+    /// <c>--8&lt;--</c> inside a fenced code block yields an empty fence and dumps the file
+    /// as top-level markdown.</summary>
+    private static string Reindent(string content, string indent)
+    {
+        if (indent.Length == 0) return content;
+
+        var normalized = content.Replace("\r\n", "\n");
+        var lines = normalized.Split('\n');
+        var sb = new StringBuilder();
+        for (var i = 0; i < lines.Length; i++)
+        {
+            // Don't indent blank lines (avoids trailing whitespace-only lines).
+            if (lines[i].Length > 0)
+                sb.Append(indent);
+            sb.Append(lines[i]);
+            if (i < lines.Length - 1)
+                sb.Append('\n');
+        }
+        return sb.ToString();
+    }
+
     /// <summary>Parses trailing <c>key="value"</c> pairs from a parameterized include.</summary>
     private static IEnumerable<(string Key, string Value)> ParseArgs(string args)
     {
@@ -156,7 +183,7 @@ private static string TrimTrailingMarkerLine(string slice)
         _ => []
     };
 
-    [GeneratedRegex(@"^[ \t]*(?:;\s*)?--8<--(?:-)?[ \t]+""(?<spec>[^""]+)""[ \t]*\r?$", RegexOptions.Multiline)]
+    [GeneratedRegex(@"^(?<indent>[ \t]*)(?:;\s*)?--8<--(?:-)?[ \t]+""(?<spec>[^""]+)""[ \t]*\r?$", RegexOptions.Multiline)]
     private static partial Regex IncludeRegex();
 
     // Inline parameterized include: `--8<-- "file" key="value" ...` (at least one argument).

tests/Netdocs.Core.Tests/SnippetsPluginTests.cs

@@ -146,6 +146,55 @@ public async Task ResolvesFromDefaultRootSnippetsDirectory()
         Assert.Contains("Default snippets dir works.", result);
     }
 
+    [Fact]
+    public async Task PreservesIndentation_ForIndentedInclude()
+    {
+        // A `--8<--` indented inside a code fence within an admonition must keep that
+        // indentation on every included line. Otherwise the fence closes empty and the
+        // file spills out as top-level markdown (script comments become <h1> headers).
+        Write("script.sh", "#!/usr/bin/env bash\n# a comment\nset -euo pipefail\necho hi");
+        var plugin = PluginWith(("base_path", new object?[] { _dir }));
+
+        var markdown = "    --8<-- \"script.sh\"";
+        var result = await plugin.ProcessAsync(Page, markdown, Site(), default);
+
+        // Every non-blank included line is prefixed with the marker's 4-space indent.
+        Assert.Contains("    #!/usr/bin/env bash", result);
+        Assert.Contains("    # a comment", result);
+        Assert.Contains("    set -euo pipefail", result);
+        Assert.Contains("    echo hi", result);
+        Assert.DoesNotContain("--8<--", result);
+    }
+
+    [Fact]
+    public async Task PreservesIndentation_BlankLinesNotIndented()
+    {
+        // Blank lines in the included file must not gain trailing whitespace.
+        Write("script.sh", "line one\n\nline two");
+        var plugin = PluginWith(("base_path", new object?[] { _dir }));
+
+        var result = await plugin.ProcessAsync(Page, "    --8<-- \"script.sh\"", Site(), default);
+
+        Assert.Contains("    line one", result);
+        Assert.Contains("    line two", result);
+        // The blank line stays blank (no "    \n" with trailing spaces).
+        Assert.DoesNotContain("    \n", result.Replace("\r\n", "\n"));
+    }
+
+    [Fact]
+    public async Task NoIndentation_UnindentedIncludeUnchanged()
+    {
+        // An include at column 0 must not gain any indentation (regression guard so the
+        // reindent logic is a no-op for the common case).
+        Write("notice.md", "line a\nline b");
+        var plugin = PluginWith(("base_path", new object?[] { _dir }));
+
+        var result = await plugin.ProcessAsync(Page, "--8<-- \"notice.md\"", Site(), default);
+
+        Assert.Contains("line a\nline b", result.Replace("\r\n", "\n"));
+        Assert.DoesNotContain("  line a", result);
+    }
+
     private sealed class FakeContext(IReadOnlyDictionary<string, object?> options) : IPluginContext
     {
         public SiteConfig Config { get; init; } = new();