fixed a markup bug

Author: McJones

CHANGELOG.md

@@ -10,6 +10,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Changed
 
+- Fixed a bug where unbalanced markup without text siblings or children would cause an error
+
 ### Removed
 
 ## [3.1.0] 2025-12-02

YarnSpinner.Tests/MarkupTests.cs

@@ -367,6 +367,96 @@ public void TestUnsquishedNestedMarkupIsValid()
             tree.children.Should().HaveCount(3);
         }
 
+        [Fact]
+        public void TestUnsquishedImbalancedMarkupIsValidWhenImbalanceOccursAtEndOfLine()
+        {
+            var line = "start[a]ab[b]bc[c]cb[/b][/c][/a]";
+
+            /*
+            root
+                "start"
+                a
+                    "ab"
+                    b
+                        "bc"
+                        c
+                            "cb"
+            */
+
+            var lineParser = new LineParser();
+            var tokens = lineParser.LexMarkup(line);
+            var result = lineParser.BuildMarkupTreeFromTokens(tokens, line);
+            var tree = result.tree;
+            var errors = result.diagnostics;
+            errors.Should().BeEmpty();
+
+            tree.children.Should().HaveCount(2); // text and a node
+
+            // a has two kids
+            Descendant(tree, 1).children.Should().HaveCount(2);
+
+            // first is text
+            ((LineParser.MarkupTextNode)Descendant(tree, 1, 0)).text.Should().Be("ab");
+
+            // b has two kids
+            Descendant(tree, 1,1).children.Should().HaveCount(2);
+
+            // first is text
+            ((LineParser.MarkupTextNode)Descendant(tree, 1,1,0)).text.Should().Be("bc");
+
+            // c has one child and it's text
+            Descendant(tree, 1,1,1).children.Should().HaveCount(1);
+            ((LineParser.MarkupTextNode)Descendant(tree, 1,1,1,0)).text.Should().Be("cb");
+        }
+
+        [Fact]
+        public void TestUnsquishedImbalancedMarkupWithExcessCloseIsInvalid()
+        {
+            var line = "start[a]ab[b]bc[c]cb[/b][/c][/a][/d]";
+
+            var lineParser = new LineParser();
+            var tokens = lineParser.LexMarkup(line);
+            var result = lineParser.BuildMarkupTreeFromTokens(tokens, line);
+            var errors = result.diagnostics;
+            errors.Should().HaveCount(1);
+        }
+
+        [Fact]
+        public void TestUnsquishedImbalancedMarkupWithExcessCloseAndOpenIsInvalid()
+        {
+            var line = "start[a]ab[b]bc[c]cb[/b][/c][/d]";
+
+            var lineParser = new LineParser();
+            var tokens = lineParser.LexMarkup(line);
+            var result = lineParser.BuildMarkupTreeFromTokens(tokens, line);
+            var errors = result.diagnostics;
+            errors.Should().HaveCount(1);
+        }
+
+        [Fact]
+        public void TestUnclosedMarkupIsInvalid()
+        {
+            var line = "start[a]end";
+
+            var lineParser = new LineParser();
+            var tokens = lineParser.LexMarkup(line);
+            var result = lineParser.BuildMarkupTreeFromTokens(tokens, line);
+            var errors = result.diagnostics;
+            errors.Should().HaveCount(1);
+        }
+
+        [Fact]
+        public void TestUnopenedMarkupIsInvalid()
+        {
+            var line = "end[/a]";
+
+            var lineParser = new LineParser();
+            var tokens = lineParser.LexMarkup(line);
+            var result = lineParser.BuildMarkupTreeFromTokens(tokens, line);
+            var errors = result.diagnostics;
+            errors.Should().HaveCount(1);
+        }
+
         [Fact]
         public void TestUnsquishedImbalancedMarkupIsValid()
         {

YarnSpinner/YarnSpinner.Markup/LineParser.cs

@@ -1362,6 +1362,10 @@ string ValueFromInterpolatedToken(LexerToken token)
             // we have now run off the end of the line
             // if we have any unmatched closes still lying around we want to close them off now
             // because at this stage it doesn't matter about ordering
+            if (unmatchedCloses.Count > 1)
+            {
+                CleanUpUnmatchedCloses(openNodes, unmatchedCloses, diagnostics);
+            }
 
             // ok last thing to check is is there only one element left on the stack of open nodes
             if (openNodes.Count > 1)