[unicode] reverse() learned not to break composite character sequen…

…ces.

src/jmespath.net/Functions/Impl/TextExtensions.cs

@@ -0,0 +1,17 @@
+using DevLab.JmesPath.Utils;
+using System;
+using System.Linq;
+
+namespace jmespath.net.Functions.Impl
+{
+    internal static class TextExtensions
+    {
+        /// <summary>
+        /// Supports the `reverse()` the function.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <returns></returns>
+        public static Text Invert(this Text text)
+            => (Text)String.Join( "", text.ToArray().Reverse() );
+    }
+}

src/jmespath.net/Functions/ReverseFunction.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using DevLab.JmesPath.Utils;
+using jmespath.net.Functions.Impl;
 using Newtonsoft.Json.Linq;
 
 namespace DevLab.JmesPath.Functions
@@ -30,8 +31,8 @@ public override JToken Execute(params JmesPathFunctionArgument[] args)
                 case "string":
                     {
                         var text = (Text)token.Value<String>();
-                        var reversed = new Text(text.CodePoints.Reverse().ToArray());
-                        return new JValue((string)reversed);
+                        var reversed = text.Invert();
+                        return new JValue((string) reversed);
                     }
                 case "array":
                     {

src/jmespath.net/Utils/Text.cs

@@ -11,6 +11,25 @@ namespace DevLab.JmesPath.Utils
     /// The <see cref="Text" /> class represents a sequence of Unicode codepoints.
     /// If differs from the .NET <see cref="String" /> class in that is correctly
     /// handles codepoints from supplementary planes, including surrogate pairs.
+    ///
+    /// characters in a .NET string are represented by a 21-bit code value
+    /// of a character in the Basic Multilingual Plane (0x0000 - 0x10FFFF)
+    /// it can consists of either:
+    ///
+    /// - a single 16-bit codepoint (U+0000 to U+FFFF excluding the surrogate range U+D800 to U+DFFF).
+    /// In that case, a Unicode character, identified by its codepoint, maps to a single 16-bit code unit.
+    ///   
+    /// or
+    ///
+    /// - a pair of 16-bit surrogate code units (high U+D800 to U+DBFF and low U+DC00 to U+DFFF).
+    /// In that case, a Unicode character, identifier by its codepoint, maps to a sequence of two 16-bit code units.
+    ///
+    /// Additionally, some Unicode characters can have multiple representations. For instance, the
+    /// character 'é' can be encoded using the following two difference sequences of codepoints:
+    ///
+    /// - 'é' U+00E9 LATIN SMALL LETTER E WITH ACUTE ACCENT.
+    /// - 'è' U+0065 LATIN SMALL LETTER E, U+0301 COMBINING ACUTE ACCENT.
+    ///
     /// </summary>
     internal sealed partial class Text : IEnumerable<string>, IEquatable<Text>, IComparable<Text>
     {

tests/jmespathnet.tests/Utils/StringFunctionsTest.cs

@@ -56,6 +56,8 @@ JToken MakeObject(string text)
 
         [Theory]
         [InlineData("a𝌆b", "b𝌆a")]
+        [InlineData("aéb", "béa")]
+        [InlineData("ae\x0301b", "béa")]
 
         public void Reverse(string text, string expected)
         {

tests/jmespathnet.tests/Utils/TextTest.cs

@@ -10,6 +10,8 @@ public sealed class TextTest
         [Theory]
         [InlineData("𝌆", 1, "U+1D306 TETRAGRAM FOR CENTER")]
         [InlineData("😀", 1, "U+1F600 GRINNING FACE")]
+        [InlineData("é", 1, "U+00E9 LATIN SMALL LETTER E WITH ACUTE ACCENT")]
+        [InlineData("è", 1, "U+0065 LATIN SMALL LETTER E, U+0301 COMBINING ACUTE ACCENT")]
         public void Length(string text, int expected, string name)
         {
             var t = new Text(text);