@@ -967,15 +967,75 @@ public void GlobClassWithATrailingDashMatchesTheDashLiterally()
 	[TestMethod]
 	[DataRow("file[a-]", "file[-a]")]
 	[DataRow("file[!a-]", "file[!-a]")]
-	[DataRow("[0-9a-]x[b-]", "[-0-9a]x[-b]")]
-	[DataRow("[]-]", "[-]]")]
+	[DataRow("[0-9a-]x[b-]", "[-0123456789a]x[-b]")]
+	[DataRow("[0-9a-f]", "[0123456789abcdef]")]
+	[DataRow("[!0-9a-f]", "[!0123456789abcdef]")]
+	[DataRow("[a-c_]", "[_abc]")]
+	[DataRow("[]-]", "[]-]")]
+	[DataRow("[]a-]", "[]-a]")]
+	[DataRow("[!]a-]", "[!]-a]")]
 	[DataRow("[-]", "[-]")]
 	[DataRow("[a-z]", "[a-z]")]
+	[DataRow("[!0-9]", "[!0-9]")]
+	[DataRow("[abc]", "[abc]")]
+	[DataRow("[!-#]", "[!-#]")]
+	[DataRow("[ !-#]", "[ \"#!]")]
 	[DataRow("file[0-", "file[0-")]
 	[DataRow("a]b", "a]b")]
 	[DataRow("[a-]x[0-", "[-a]x[0-")]
-	public void MoveTrailingClassDashesRewritesOnlyClosedClasses(string token, string expected) =>
-		Assert.AreEqual(expected, TextFilter.MoveTrailingClassDashes(token));
+	public void ExpandGlobClassesRewritesOnlyClassesDotNetGlobMisreads(string token, string expected) =>
+		Assert.AreEqual(expected, TextFilter.ExpandGlobClasses(token));
+
+	[TestMethod]
+	[DataRow("[#-!]")]
+	[DataRow("[\u0001-\uffff_]")]
+	public void ExpandGlobClassesRejectsClassesThatCannotBeListed(string token) =>
+		Assert.IsNull(TextFilter.ExpandGlobClasses(token));
+
+	[TestMethod]
+	[DataRow("[0-9a-f]", "0 5 9 a c f", "g G - x _")]
+	[DataRow("[!0-9a-f]", "g - x _", "0 5 a c f")]
+	[DataRow("[a-z_]", "a q z _", "- 5 #")]
+	[DataRow("[-0-9]", "- 0 5 9", "a _")]
+	[DataRow("[ab-d]", "a b c d", "- e")]
+	[DataRow("[a-z-]", "q a z -", "5 _")]
+	[DataRow("file[0-9a-]", "file5 filea file-", "fileb file_")]
+	[DataRow("[]a-]", "a - ]", "b [")]
+	[DataRow("[!]a-]", "b [", "a - ]")]
+	[DataRow("[!-#]", "a $ ! \"", "- #")]
+	public void GlobClassMatchesEveryMemberOfEveryRange(string pattern, string matching, string notMatching)
+	{
+		// DotNet.Glob reads a class as one range or one plain list, never both, so a class mixing a range
+		// with other members silently dropped some of them (#152), and moving a trailing dash to the front
+		// pushed classes it read correctly into list mode (#153).
+		ArgumentNullException.ThrowIfNull(matching);
+		ArgumentNullException.ThrowIfNull(notMatching);
+		foreach (TextFilterCaseSensitivity caseSensitivity in new[] { TextFilterCaseSensitivity.CaseSensitive, TextFilterCaseSensitivity.CaseInsensitive })
+		{
+			foreach (string text in matching.Split(' '))
+			{
+				Assert.IsTrue(TextFilter.IsMatch(text, pattern, TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, caseSensitivity), $"{pattern} should match {text} ({caseSensitivity})");
+			}
+
+			foreach (string text in notMatching.Split(' '))
+			{
+				Assert.IsFalse(TextFilter.IsMatch(text, pattern, TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, caseSensitivity), $"{pattern} should not match {text} ({caseSensitivity})");
+			}
+		}
+	}
+
+	[TestMethod]
+	public void GlobClassWithBothLetterCasesMatchesEachCase()
+	{
+		Assert.IsTrue(TextFilter.IsMatch("Q", "[a-zA-Z]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseSensitive));
+		Assert.IsTrue(TextFilter.IsMatch("q", "[a-zA-Z]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseSensitive));
+		Assert.IsFalse(TextFilter.IsMatch("_", "[a-zA-Z]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseSensitive));
+
+		// Case folding still applies to the expanded list, in both directions.
+		Assert.IsTrue(TextFilter.IsMatch("C", "[0-9a-f]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseInsensitive));
+		Assert.IsFalse(TextFilter.IsMatch("C", "[0-9a-f]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseSensitive));
+		Assert.IsFalse(TextFilter.IsMatch("C", "[!0-9a-f]", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString, TextFilterCaseSensitivity.CaseInsensitive));
+	}
 
 	[TestMethod]
 	[DataRow("-readme[a-")]
 
@@ -475,11 +475,21 @@ internal static IReadOnlyList<string> ExpandGlobStarSegments(string maskedToken)
 		return [.. expansions.Select(prefix => prefix + tail).Distinct(StringComparer.Ordinal)];
 	}
 
-	// In glob syntax a "-" just before the closing "]" is a literal dash, so "[a-]" matches "a" or "-".
-	// DotNet.Glob's tokeniser reads it as a range left open and throws, as it does for the half-typed
-	// "[a-", so the dash is moved to the front of the class ("[-a]", "[!-a]"), a form it does parse.
-	// A class with no closing "]" is left alone and stays unparseable.
-	internal static string MoveTrailingClassDashes(string token)
+	// DotNet.Glob reads a bracket class as exactly one token: a single range when it starts "x-y" with
+	// two letters or two digits, otherwise a plain character list in which "-" is a member and no ranges
+	// are read. It never combines the two, so "[0-9a-f]" stops at the 0-9 range and misses "c", while
+	// "[-0-9]" and "[ab-d]" become lists that miss "5" and "c". A trailing dash ("[a-]") makes its
+	// tokeniser throw outright. So every closed class it would misread is rewritten here into the
+	// explicit character list it means, which it does read correctly, negation and case folding
+	// included: "[0-9a-f]" becomes "[0123456789abcdef]" and "[a-z-]" becomes "[-abc...z]". A lone
+	// letter or digit range is left for DotNet.Glob to match natively, since it reads that form
+	// correctly and it may span far more characters than are worth listing. A class with no closing
+	// "]" is left alone and stays unparseable.
+	// Returns null for a class that cannot be written as a list: one whose ranges span more than
+	// MaxGlobClassMembers characters, or that has no members at all because every range is reversed.
+	private const int MaxGlobClassMembers = 4096;
+
+	internal static string? ExpandGlobClasses(string token)
 	{
 		if (!token.Contains(']'))
 		{
@@ -496,35 +506,115 @@ internal static string MoveTrailingClassDashes(string token)
 				break;
 			}
 
-			int contentStart = open + 1;
-			string negation = contentStart < token.Length && token[contentStart] == '!' ? "!" : string.Empty;
-			contentStart += negation.Length;
-
-			// A "]" straight after the opening bracket is a member of the class rather than its end.
-			int close = contentStart < token.Length ? token.IndexOf(']', contentStart + 1) : -1;
+			int close = FindGlobClassEnd(token, open, out bool negated, out int contentStart);
 			if (close < 0)
 			{
 				break;
 			}
 
 			string content = token[contentStart..close];
-			result.Append(token, index, open - index).Append('[').Append(negation);
-			if (content.Length > 1 && content[^1] == '-')
-			{
-				result.Append('-').Append(content, 0, content.Length - 1);
-			}
-			else
+			string? rewritten = !content.Contains('-') || IsNativeGlobRange(content)
+				? token[open..(close + 1)]
+				: ToGlobCharacterList(content, negated);
+			if (rewritten is null)
 			{
-				result.Append(content);
+				return null;
 			}
 
-			result.Append(']');
+			result.Append(token, index, open - index).Append(rewritten);
 			index = close + 1;
 		}
 
 		return result.Append(token, index, token.Length - index).ToString();
 	}
 
+	// Returns the index of the "]" closing the class opened at "open", or -1 if it is never closed.
+	private static int FindGlobClassEnd(string token, int open, out bool negated, out int contentStart)
+	{
+		contentStart = open + 1;
+		negated = contentStart < token.Length && token[contentStart] == '!';
+		if (negated)
+		{
+			contentStart++;
+		}
+
+		// A "]" straight after the opening bracket is a member of the class rather than its end.
+		return contentStart < token.Length ? token.IndexOf(']', contentStart + 1) : -1;
+	}
+
+	private static bool IsNativeGlobRange(string content) =>
+		content.Length == 3 && content[1] == '-' && content[0] != ']'
+		&& ((char.IsLetter(content[0]) && char.IsLetter(content[2])) || (char.IsAsciiDigit(content[0]) && char.IsAsciiDigit(content[2])));
+
+	// Reads the class members with the usual glob rules (a leading "]" and a leading or trailing "-" are
+	// literal, "x-y" is an inclusive range) and writes them in an order DotNet.Glob reads as a plain list:
+	// "]" first, so it does not close the class, then "-", so no member pair looks like a range, and "!"
+	// never first, so it is not read as negation.
+	private static string? ToGlobCharacterList(string content, bool negated)
+	{
+		SortedSet<char> members = [];
+		int i = 0;
+		while (i < content.Length)
+		{
+			char first = content[i];
+			bool isRange = i + 2 < content.Length && content[i + 1] == '-' && !(i == 0 && first == ']');
+			if (!isRange)
+			{
+				members.Add(first);
+				i++;
+				continue;
+			}
+
+			char last = content[i + 2];
+			if (last - first + members.Count >= MaxGlobClassMembers)
+			{
+				return null;
+			}
+
+			for (int member = first; member <= last; member++)
+			{
+				members.Add((char)member);
+			}
+
+			i += 3;
+		}
+
+		if (members.Count == 0)
+		{
+			return null;
+		}
+
+		StringBuilder list = new(members.Count + 3);
+		list.Append('[');
+		if (negated)
+		{
+			list.Append('!');
+		}
+
+		if (members.Remove(']'))
+		{
+			list.Append(']');
+		}
+
+		if (members.Remove('-'))
+		{
+			list.Append('-');
+		}
+
+		bool hasBang = members.Remove('!');
+		foreach (char member in members)
+		{
+			list.Append(member);
+		}
+
+		if (hasBang)
+		{
+			list.Append('!');
+		}
+
+		return list.Append(']').ToString();
+	}
+
 	// Returns null for a token that cannot be parsed, so each caller can decide what ignoring it means.
 	private static Glob[]? ResolveGlob(string filterToken, TextFilterCaseSensitivity caseSensitivity)
 	{
@@ -534,8 +624,8 @@ internal static string MoveTrailingClassDashes(string token)
 		{
 			try
 			{
-				string maskedToken = MaskPathSeparators(MoveTrailingClassDashes(filterToken));
-				globs = [.. ExpandGlobStarSegments(maskedToken).Select(pattern => caseSensitivity is TextFilterCaseSensitivity.CaseInsensitive
+				string? expandedToken = ExpandGlobClasses(filterToken);
+				globs = expandedToken is null ? null : [.. ExpandGlobStarSegments(MaskPathSeparators(expandedToken)).Select(pattern => caseSensitivity is TextFilterCaseSensitivity.CaseInsensitive
 					? Glob.Parse(pattern, CaseInsensitiveGlobOptions)
 					: Glob.Parse(pattern))];
 			}