@@ -140,6 +140,31 @@ case pair, and a culture-sensitive fold would stop a filter of `img` matching `I
 machine whose locale happens to be `tr-TR`. A filter pattern is machine text rather than prose, so
 it folds the same way everywhere.
 
+### Glob Tokens
+
+A glob filter is split on whitespace into tokens, and the first character of each token says what
+kind it is:
+
+| Token | Kind | The text must |
+|-------|------|---------------|
+| `word*` | optional | contain a word matching at least one optional token (all of them under `ByWordAll`) |
+| `+word*` | required | contain a word matching every required token |
+| `-word*`, `!word*` or `^word*` | excluded | contain no word matching any excluded token |
+
+To match a word that itself starts with `+`, `-`, `!` or `^`, put a backslash before that character.
+`\+page.svelte` is the optional token `+page.svelte`, and `+\+page*` is the required token `+page*`.
+A one-character class works too: `[+]page.svelte`.
+
+```csharp
+using ktsu.TextFilter;
+
+string[] files = ["+page.svelte", "+layout.svelte", "!important.txt", "readme.md"];
+
+IEnumerable<string> page = TextFilter.Filter(files, @"\+page.svelte");          // +page.svelte
+IEnumerable<string> important = TextFilter.Filter(files, @"\!important.txt");   // !important.txt
+IEnumerable<string> notPages = TextFilter.Filter(files, "-+*");                 // !important.txt, readme.md
+```
+
 ### Filter Types
 
 TextFilter supports different filter types:
 
@@ -420,7 +420,7 @@ public void FilterWithKeySelectorNullFilterThrowsArgumentNullException()
 	public void GetHintReturnsCorrectHintForGlob()
 	{
 		string result = TextFilter.GetHint(TextFilterType.Glob);
-		Assert.AreEqual("glob pattern, 'optional1* opti?nal2 +required -excluded' etc, text must contain one of the optional tokens, all of the required tokens, and none of the excluded tokens", result);
+		Assert.AreEqual("glob pattern, 'optional1* opti?nal2 +required -excluded' etc, text must contain one of the optional tokens, all of the required tokens, and none of the excluded tokens; a token starting with + is required, and one starting with -, ! or ^ is excluded; put \\ before a leading +, -, ! or ^ to match it literally, as in \\+page.svelte", result);
 	}
 
 	[TestMethod]
@@ -1720,4 +1720,56 @@ public void SourceCallsWithAllPre17ArgumentsStillCompileAndMatchCaseSensitively(
 		Assert.HasCount(1, TextFilter.Filter(["Hello", "hello"], "Hello", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString).ToList());
 		Assert.HasCount(1, TextFilter.Filter([(1, "Hello"), (2, "hello")], t => t.Item2, "Hello", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString).ToList());
 	}
+
+	private static readonly string[] PrefixedItems = ["+page.svelte", "-draft.md", "!important.txt", "^notes.md", "readme.md"];
+
+	[TestMethod]
+	[DataRow(@"\+page.svelte", "+page.svelte")]
+	[DataRow(@"\-draft.md", "-draft.md")]
+	[DataRow(@"\!important.txt", "!important.txt")]
+	[DataRow(@"\^notes.md", "^notes.md")]
+	[DataRow(@"\+page*", "+page.svelte")]
+	[DataRow(@"[+]page.svelte", "+page.svelte")]
+	public void EscapedLeadingPrefixMatchesItLiterally(string filter, string expected)
+	{
+		CollectionAssert.AreEqual(new[] { expected }, TextFilter.Filter(PrefixedItems, filter).ToArray());
+		Assert.IsTrue(TextFilter.IsMatch(expected, filter));
+	}
+
+	[TestMethod]
+	[DataRow(@"+\+page*", "+page.svelte")]
+	[DataRow(@"+\!important*", "!important.txt")]
+	public void EscapedPrefixAfterRequiredPrefixIsARequiredLiteral(string filter, string expected)
+	{
+		CollectionAssert.AreEqual(new[] { expected }, TextFilter.Filter(PrefixedItems, filter).ToArray());
+	}
+
+	[TestMethod]
+	[DataRow(@"-\-draft*", "-draft.md")]
+	[DataRow(@"!\^notes*", "^notes.md")]
+	public void EscapedPrefixAfterExcludedPrefixIsAnExcludedLiteral(string filter, string excluded)
+	{
+		CollectionAssert.AreEqual(PrefixedItems.Where(item => item != excluded).ToArray(), TextFilter.Filter(PrefixedItems, filter).ToArray());
+	}
+
+	[TestMethod]
+	public void UnescapedPrefixesStillMeanRequiredAndExcluded()
+	{
+		string[] onlyReadme = [.. PrefixedItems.Where(item => item == "readme.md")];
+		string[] allButPage = [.. PrefixedItems.Where(item => item != "+page.svelte")];
+		string[] allButReadme = [.. PrefixedItems.Where(item => item != "readme.md")];
+
+		CollectionAssert.AreEqual(onlyReadme, TextFilter.Filter(PrefixedItems, "+readme*").ToArray());
+		CollectionAssert.AreEqual(allButPage, TextFilter.Filter(PrefixedItems, "-+*").ToArray());
+		CollectionAssert.AreEqual(allButReadme, TextFilter.Filter(PrefixedItems, "!readme*").ToArray());
+		CollectionAssert.AreEqual(allButReadme, TextFilter.Filter(PrefixedItems, "^readme*").ToArray());
+	}
+
+	[TestMethod]
+	public void BackslashBeforeAnOrdinaryCharacterIsStillAPathSeparator()
+	{
+		Assert.IsTrue(TextFilter.IsMatch(@"src\main.cs", @"src\main.cs", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString));
+		Assert.IsTrue(TextFilter.IsMatch("src/main.cs", @"src\main.cs", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString));
+		Assert.IsTrue(TextFilter.IsMatch(@"\server", @"\server", TextFilterType.Glob, TextFilterMatchOptions.ByWholeString));
+	}
 }
@@ -146,7 +146,7 @@ public static string GetHint(TextFilterType filterType)
 	{
 		return filterType switch
 		{
-			TextFilterType.Glob => "glob pattern, 'optional1* opti?nal2 +required -excluded' etc, text must contain one of the optional tokens, all of the required tokens, and none of the excluded tokens",
+			TextFilterType.Glob => "glob pattern, 'optional1* opti?nal2 +required -excluded' etc, text must contain one of the optional tokens, all of the required tokens, and none of the excluded tokens; a token starting with + is required, and one starting with -, ! or ^ is excluded; put \\ before a leading +, -, ! or ^ to match it literally, as in \\+page.svelte",
 			TextFilterType.Regex => "regex pattern, text must match the regex pattern",
 			TextFilterType.Fuzzy => "fuzzy pattern, text is ranked by how well it matches the pattern",
 			_ => throw new NotImplementedException($"{nameof(TextFilterType)}.{filterType} has not been implemented"),
@@ -313,13 +313,25 @@ internal static Dictionary<TextFilterTokenType, HashSet<string>> ExtractGlobFilt
 			return new
 			{
 				g.Key,
-				Value = (removePrefix ? g.Select(t => t[1..]) : g).Where(t => !string.IsNullOrEmpty(t)).ToHashSet(),
+				Value = (removePrefix ? g.Select(t => t[1..]) : g).Select(UnescapeLeadingPrefix).Where(t => !string.IsNullOrEmpty(t)).ToHashSet(),
 			};
 		})
 		.Where(g => g.Value.Count != 0)
 		.ToDictionary(g => g.Key, g => g.Value);
 	}
 
+	// A token that starts with a prefix character is always read as a prefixed token, so without an
+	// escape an item named "+page.svelte" or "!important.txt" could not be found by typing its name. A
+	// backslash before a leading prefix character makes that character literal: "\+page.svelte" is the
+	// optional token "+page.svelte", and "+\+page" is the required token "+page". A backslash anywhere
+	// else is still a path separator.
+	private static string UnescapeLeadingPrefix(string token) =>
+		token.Length >= 2 && token[0] == GlobPrefixEscape && IsTokenPrefix(token[1]) ? token[1..] : token;
+
+	private const char GlobPrefixEscape = '\\';
+
+	private static bool IsTokenPrefix(char c) => ExcludedTokenPrefixes.Contains(c) || RequiredTokenPrefixes.Contains(c);
+
 	/// <summary>
 	/// Determines whether the specified text matches the glob filter pattern.
 	/// </summary>