fix: reject NaN widths in NominalWordWrap and clamp an unbounded width ratio [patch]

Extensions.Test/StringExtensionsTests.cs

@@ -470,6 +470,32 @@ public void NominalWordWrapThrowsArgumentOutOfRangeExceptionWhenGlyphWidthNotPos
 		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => input.NominalWordWrap(100f, 0f).ToList());
 	}
 
+	[TestMethod]
+	public void NominalWordWrapThrowsArgumentOutOfRangeExceptionWhenWrapWidthIsNaN()
+	{
+		string input = "hello world foo";
+		ArgumentOutOfRangeException exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => input.NominalWordWrap(float.NaN, 1f).ToList());
+		Assert.AreEqual("wrapWidth", exception.ParamName);
+	}
+
+	[TestMethod]
+	public void NominalWordWrapThrowsArgumentOutOfRangeExceptionWhenGlyphWidthIsNaN()
+	{
+		string input = "hello world foo";
+		ArgumentOutOfRangeException exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => input.NominalWordWrap(10f, float.NaN).ToList());
+		Assert.AreEqual("nominalGlyphWidth", exception.ParamName);
+	}
+
+	[TestMethod]
+	[DataRow(float.PositiveInfinity, 1f)]
+	[DataRow(float.MaxValue, float.Epsilon)]
+	public void NominalWordWrapKeepsEachLineWholeWhenWidthRatioIsUnbounded(float wrapWidth, float nominalGlyphWidth)
+	{
+		string input = "hello world foo\nbar baz";
+		List<string> result = [.. input.NominalWordWrap(wrapWidth, nominalGlyphWidth)];
+		Assert.AreSequenceEqual(new List<string> { "hello world foo", "bar baz" }, result);
+	}
+
 	[TestMethod]
 	public void NominalWordWrapBreaksAfterVisibleHyphen()
 	{

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.
@@ -235,12 +235,13 @@
 	{
 		Ensure.NotNull(text);
 
-		if (wrapWidth <= 0)
+		// NaN fails every comparison, so it has to be rejected explicitly.
+		if (float.IsNaN(wrapWidth) || wrapWidth <= 0)
 		{
 			throw new ArgumentOutOfRangeException(nameof(wrapWidth), wrapWidth, "Wrap width must be greater than zero.");
 		}
 
-		if (nominalGlyphWidth <= 0)
+		if (float.IsNaN(nominalGlyphWidth) || nominalGlyphWidth <= 0)
 		{
 			throw new ArgumentOutOfRangeException(nameof(nominalGlyphWidth), nominalGlyphWidth, "Nominal glyph width must be greater than zero.");
 		}
@@ -250,7 +251,10 @@
 			return [];
 		}
 
-		int maxCharsPerLine = Math.Max(1, (int)Math.Floor(wrapWidth / nominalGlyphWidth));
+		// Clamp before casting: float-to-int conversion does not saturate before .NET 9, so an infinite or huge ratio
+		// would otherwise become int.MinValue and wrap one character per line.
+		double ratio = Math.Floor((double)wrapWidth / nominalGlyphWidth);
+		int maxCharsPerLine = ratio >= int.MaxValue ? int.MaxValue : Math.Max(1, (int)ratio);
 		return NominalWordWrapIterator(text, maxCharsPerLine);
 	}
 
@@ -259,7 +263,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 +296,7 @@
 
 					yield return line.ToString();
 					line.Clear();
 					atLineStart = true;
 				}
 				else if (!atLineStart)
 				{