fix: keep surrogate pairs whole when NominalWordWrap hard-breaks a word [patch]

Extensions.Test/StringExtensionsTests.cs

@@ -449,6 +449,24 @@ public void NominalWordWrapClampsToAtLeastOneCharacterPerLine()
 		CollectionAssert.AreEqual(new List<string> { "a", "b" }, result);
 	}
 
+	[TestMethod]
+	public void NominalWordWrapHardBreakDoesNotSplitSurrogatePairs()
+	{
+		// Each 😀 is a surrogate pair: two UTF-16 code units.
+		List<string> emoji = [.. "😀😀😀".NominalWordWrap(3f, 1f)];
+		Assert.AreSequenceEqual(new List<string> { "😀", "😀", "😀" }, emoji);
+
+		List<string> mixed = [.. "ab😀cd".NominalWordWrap(3f, 1f)];
+		Assert.AreSequenceEqual(new List<string> { "ab", "😀c", "d" }, mixed);
+	}
+
+	[TestMethod]
+	public void NominalWordWrapLetsASurrogatePairOverhangAtWidthOne()
+	{
+		List<string> result = [.. "a😀b".NominalWordWrap(1f, 1f)];
+		Assert.AreSequenceEqual(new List<string> { "a", "😀", "b" }, result);
+	}
+
 	[TestMethod]
 	public void NominalWordWrapThrowsArgumentNullExceptionWhenTextIsNull()
 	{

Extensions/StringExtensions.cs

@@ -122,9 +122,9 @@
 #endif
 	}
 
 	private static Regex LineEndingRegexUnix { get; } = new(@"(?<!\r)\n", RegexOptions.Compiled);
 	private static Regex LineEndingRegexWindows { get; } = new(@"\r\n", RegexOptions.Compiled);
 	private static Regex LineEndingRegexMac { get; } = new(@"\r(?!\n)", RegexOptions.Compiled);
 
 	// One pass over every kind of line ending. Normalizing in several passes lets an earlier pass
 	// build a sequence the next one reads differently: under Mac, "\r\n\n" became "\r" + "\n", a new CRLF.
@@ -227,7 +227,8 @@
 	/// hyphen (the hyphen stays on the upper line) or at a soft hyphen (<c>­</c>), which renders as a hyphen only when
 	/// a break lands there and is otherwise removed. Words that still cannot fit are hard-broken as a last resort so that
 	/// no line exceeds the computed width, except that honoring a soft hyphen at a line boundary may add a single
-	/// overhanging character.
+	/// overhanging character. A hard break never splits a surrogate pair, so at a width of one character a line may
+	/// hold a whole pair (two UTF-16 code units).
 	/// </returns>
 	/// <exception cref="ArgumentNullException">Thrown when <paramref name="text"/> is null.</exception>
 	/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="wrapWidth"/> or <paramref name="nominalGlyphWidth"/> is not greater than zero.</exception>
@@ -259,7 +260,7 @@
 	/// </summary>
 	private const char SoftHyphen = '­';
 
 	private static IEnumerable<string> NominalWordWrapIterator(string text, int maxCharsPerLine)
 	{
 		string normalized = text.NormalizeLineEndings(LineEndingStyle.Unix);
 		string[] segments = normalized.Split('\n');
@@ -292,7 +293,7 @@
 
 					yield return line.ToString();
 					line.Clear();
 					atLineStart = true;
 				}
 				else if (!atLineStart)
 				{
@@ -309,8 +310,15 @@
 				string remaining = atomText;
 				while (remaining.Length > maxCharsPerLine)
 				{
-					yield return remaining.Substring(0, maxCharsPerLine);
-					remaining = remaining.Substring(maxCharsPerLine);
+					int cut = maxCharsPerLine;
+					if (char.IsHighSurrogate(remaining[cut - 1]) && char.IsLowSurrogate(remaining[cut]))
+					{
+						// Never split a surrogate pair. At a width of one, let the pair overhang instead.
+						cut = cut > 1 ? cut - 1 : 2;
+					}
+
+					yield return remaining.Substring(0, cut);
+					remaining = remaining.Substring(cut);
 				}
 
 				line.Append(remaining);