Under annotations

.gitignore

@@ -12,7 +12,7 @@ CSharpMath.Xaml.Tests.NuGet/Test.*.png
 /.benchmarkresults
 /.nupkgs
 /.testcoverage
-
+/.vscode
 ## END Specifically added for CSharpMath
 
 ## Ignore Visual Studio temporary files, build results, and

CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs

@@ -408,6 +408,34 @@ public void TestUnderline() {
       Assert.Equal(@"\underline{2}", LaTeXParser.MathListToLaTeX(list).ToString());
     }
 
+    /// <summary>
+    /// Test underbrace without under
+    /// </summary>
+    [Fact]
+    public void TestUnderbrace() {
+      var list = ParseLaTeX(@"\underbrace{x}");
+
+      Assert.Collection(list,
+        CheckAtom<UnderAnnotation>("\u23df", underBrace =>
+          Assert.Collection(underBrace.InnerList, CheckAtom<Variable>("x"))
+        )
+      );
+    }
+
+    /// <summary>
+    /// Test underbrace with under (not implemented yet)
+    /// </summary>
+    [Fact]
+    public void TestUnderbraceWithUnder() {
+      var list = ParseLaTeX(@"\underbrace{x}_{y}");
+
+      Assert.Collection(list,
+        CheckAtom<UnderAnnotation>("\u23df", underBrace =>
+          Assert.Collection(underBrace.InnerList, CheckAtom<Variable>("x"))
+        )
+      );
+    }
+
     [Fact]
     public void TestAccent() {
       var list = ParseLaTeX(@"\bar x");

CSharpMath/Atom/Atoms/UnderAnnotation.cs

@@ -0,0 +1,30 @@
+namespace CSharpMath.Atom.Atoms; 
+/// <summary>
+/// Abstract name of under annotations implementation \underbrace, \underbracket etc..
+/// </summary>
+public sealed class UnderAnnotation : MathAtom, IMathListContainer {
+  public UnderAnnotation(string value, MathList innerList, MathList? underList = null) : base(value) {
+    InnerList = innerList;
+    UnderList = underList;
+  }
+
+  public MathList InnerList { get; }
+  public MathList? UnderList { get; }
+
+  System.Collections.Generic.IEnumerable<MathList> IMathListContainer.InnerLists =>
+    new[] { InnerList };
+  public new UnderAnnotation Clone(bool finalize) => (UnderAnnotation)base.Clone(finalize);
+  protected override MathAtom CloneInside(bool finalize) =>
+    new UnderAnnotation(Nucleus, InnerList.Clone(finalize), UnderList?.Clone(finalize));
+  public override bool ScriptsAllowed => true;
+  //depending on nucleus, DebugString will change to \underbrace , \underbracket etc..
+  public override string DebugString =>
+    new System.Text.StringBuilder(@"\underbrace")
+    .AppendInBracesOrLiteralNull(InnerList.DebugString)
+    .ToString();
+  public bool EqualsUnderAnnotation(UnderAnnotation other) =>
+    EqualsAtom(other) && InnerList.EqualsList(other.InnerList);
+  public override bool Equals(object obj) =>
+    obj is UnderAnnotation u ? EqualsUnderAnnotation(u) : false;
+  public override int GetHashCode() => (base.GetHashCode(), InnerList).GetHashCode();
+}

CSharpMath/Atom/LaTeXParser.cs

@@ -77,7 +77,7 @@ private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', M
         if (error != null) return error;
 
         switch (handlerResult) {
-          case ({ } /* dummy */, { } atoms): // Atoms producer (pre-styled)
+          case ( { } /* dummy */, { } atoms): // Atoms producer (pre-styled)
             r.Append(atoms);
             prevAtom = r.Atoms.LastOrDefault();
             if (oneCharOnly)
@@ -87,7 +87,7 @@ private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', M
             return @return;
           case (null, null): // Atom modifier
             continue;
-          case ({ } resultAtom, null): // Atom producer
+          case ( { } resultAtom, null): // Atom producer
             atom = resultAtom;
             break;
         }
@@ -98,8 +98,7 @@ private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', M
           return r; // we consumed our character.
         }
       }
-      return stopChar switch
-      {
+      return stopChar switch {
         '\0' => r,
         '}' => "Missing closing brace",
         _ => "Expected character not found: " + stopChar.ToStringInvariant(),
@@ -329,8 +328,7 @@ public Result<MathAtom> ReadTable
               cell.Insert(0, style);
             }
           }
-          return delimiters switch
-          {
+          return delimiters switch {
             (var left, var right) => new Inner(
               new Boundary(left),
               new MathList(table),
@@ -346,8 +344,7 @@ public Result<MathAtom> ReadTable
           for (int i = 0, j = 0; i < arrayAlignments.Length && j < table.NColumns; i++, j++) {
             // TODO: vertical lines in array currently unsupported
             while (arrayAlignments[i] == '|') i++;
-            table.SetAlignment(arrayAlignments[i] switch
-            {
+            table.SetAlignment(arrayAlignments[i] switch {
               'l' => ColumnAlignment.Left,
               'c' => ColumnAlignment.Center,
               'r' => ColumnAlignment.Right,
@@ -520,12 +517,11 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
               builder.Append('{');
               MathListToLaTeX(fraction.Numerator, builder, currentFontStyle);
               builder.Append(@" \").Append(
-                (fraction.LeftDelimiter, fraction.RightDelimiter) switch
-                {
-                  ({ Nucleus: null }, { Nucleus: null }) => "atop",
-                  ({ Nucleus: "(" }, { Nucleus: ")" }) => "choose",
-                  ({ Nucleus: "{" }, { Nucleus: "}" }) => "brace",
-                  ({ Nucleus: "[" }, { Nucleus: "]" }) => "brack",
+                (fraction.LeftDelimiter, fraction.RightDelimiter) switch {
+                  ( { Nucleus: null }, { Nucleus: null }) => "atop",
+                  ( { Nucleus: "(" }, { Nucleus: ")" }) => "choose",
+                  ( { Nucleus: "{" }, { Nucleus: "}" }) => "brace",
+                  ( { Nucleus: "[" }, { Nucleus: "]" }) => "brack",
                   (var left, var right) => $"atopwithdelims{BoundaryToLaTeX(left)}{BoundaryToLaTeX(right)}",
                 }).Append(' ');
               MathListToLaTeX(fraction.Denominator, builder, currentFontStyle);
@@ -568,8 +564,7 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
             if (table.Environment == "array") {
               builder.Append('{');
               foreach (var alignment in table.Alignments)
-                builder.Append(alignment switch
-                {
+                builder.Append(alignment switch {
                   ColumnAlignment.Left => 'l',
                   ColumnAlignment.Right => 'r',
                   _ => 'c'
@@ -586,8 +581,7 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
                   // remove the first atom.
                   cell = cell.Slice(1, cell.Count - 1);
                 }
-                if (table.Environment switch
-                {
+                if (table.Environment switch {
                   "eqalign" => true,
                   "aligned" => true,
                   "split" => true,
@@ -624,6 +618,14 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
             builder.Append(@"\underline{");
             MathListToLaTeX(under.InnerList, builder, currentFontStyle);
             builder.Append('}');
+            break;
+          case UnderAnnotation underAnotation:
+            if (MathAtomToLaTeX(underAnotation, builder, out var underAnnotationCommand)) {
+              builder.Append(@$"\{underAnnotationCommand}{{");
+              MathListToLaTeX(underAnotation.InnerList, builder, currentFontStyle);
+              builder.Append('}');
+            }
+
             break;
           case Accent accent:
             MathAtomToLaTeX(accent, builder, out _);

CSharpMath/Atom/LaTeXSettings.cs

@@ -160,6 +160,9 @@ public static class LaTeXSettings {
           parser.ReadArgument().Bind(mathList => Ok(new Overline(mathList))) },
         { @"\underline", (parser, accumulate, stopChar) =>
           parser.ReadArgument().Bind(mathList => Ok(new Underline(mathList))) },
+        { @"\underbrace", (parser, accumulate, stopChar) => 
+          parser.ReadArgument().Bind(mathList => Ok(new UnderAnnotation("\u23df", mathList)))},
+          //Adding under element should happen when adding sub script later or here?
         { @"\begin", (parser, accumulate, stopChar) =>
           parser.ReadEnvironment().Bind(env =>
             parser.ReadTable(env, null, false, stopChar)).Bind(Ok) },