diff --git a/.agents/skills/verify-querykit/SKILL.md b/.agents/skills/verify-querykit/SKILL.md
index ce7aaa4..6f60c6e 100644
--- a/.agents/skills/verify-querykit/SKILL.md
+++ b/.agents/skills/verify-querykit/SKILL.md
@@ -78,13 +78,14 @@ If the doctor fails and `qk rebuild` does not correct it, run `qk down` and then
 ## Drive
 
 ```bash
-.agents/skills/verify-querykit/qk run <label> [--filter '<f>'] [--sort '<s>'] [--config <preset>] [--target memory|postgres|both] [--aggregate]
+.agents/skills/verify-querykit/qk run <label> [--filter '<f>'] [--sort '<s>'] [--config <preset>] [--target memory|postgres|both] [--aggregate] [--culture <name>]
 ```
 
 - `<label>` names the evidence files. Use letters, digits, `.`, `_`, and `-` only. Use a label that tells the feature, for example `filtering-in-operator`.
 - `--filter` calls `ApplyQueryKitFilter`. `--sort` calls `ApplyQueryKitSort` after the filter.
 - `--aggregate` calls `ApplyQueryKit(new QueryKitData { Filters, SortOrder, Configuration })` instead.
 - `--config` selects a `QueryKitConfiguration` preset. The default is `none`. Run `qk configs` to list the presets. The presets are in `harness/Driver/Configs.cs`.
+- `--culture` sets the thread culture of the driver, for example `de-DE`. The default is the culture of the machine.
 - `--target` defaults to `both`. Use `both` for a proof. A difference between the two targets is a finding.
 
 Put the filter in single quotes in the shell, because QueryKit strings use double quotes:
diff --git a/.agents/skills/verify-querykit/features/README.md b/.agents/skills/verify-querykit/features/README.md
index 3cce104..d0a8fdb 100644
--- a/.agents/skills/verify-querykit/features/README.md
+++ b/.agents/skills/verify-querykit/features/README.md
@@ -14,12 +14,12 @@ In the commands below, `qk` means `.agents/skills/verify-querykit/qk`.
 
 The driver model is `Recipe`. Every recipe has one `Author` and zero or more `Ingredients`. The seed data is fixed in `harness/Driver/Model.cs`.
 
-| Title | Author.Name | Rating | Price | IsVegetarian | Visibility | CreatedAt (UTC) | DateOfOrigin | Directions | Tags | Ingredients (Name:Stock) |
-|---|---|---|---|---|---|---|---|---|---|---|
-| Pancakes | Julia Child | 5 | 4.50 | true | Public (1) | 2024-01-15 08:00 | 1900-01-01 | Whisk and fry | breakfast, sweet | flour:10, egg:0 |
-| Beef Stew | Gordon Ramsay | 3 | 12.00 | false | Public (1) | 2024-03-01 18:30 | null | Simmer for hours | dinner | beef:2, salt:50 |
-| Salt Bread | Julia Child | 4 | 3.25 | true | Private (2) | 2024-06-10 12:00 | 1950-05-20 | Knead and bake | bread, Winner | salt:5, flour:3 |
-| Plain Water | Anonymous | 1 | 0.00 | true | Private (2) | 2023-12-31 23:59 | null | null | (none) | (none) |
+| Title | Author.Name | Rating | Price | IsVegetarian | Visibility | CreatedAt (UTC) | DateOfOrigin | Sku | Serving | ServeTime | Directions | Tags | Ingredients (Name:Stock) |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+| Pancakes | Julia Child | 5 | 4.50 | true | Public (1) | 2024-01-15 08:00 | 1900-01-01 | 001 | Warm, with syrup | 08:30:00.5 | Whisk and fry | breakfast, sweet | flour:10, egg:0 |
+| Beef Stew | Gordon Ramsay | 3 | 12.00 | false | Public (1) | 2024-03-01 18:30 | null | 002 | Hot | 18:00:00 | Simmer for hours | dinner | beef:2, salt:50 |
+| Salt Bread | Julia Child | 4 | 3.25 | true | Private (2) | 2024-06-10 12:00 | 1950-05-20 | 003 | Sliced | 12:15:30.25 | Knead and bake | bread, Winner | salt:5, flour:3 |
+| Plain Water | Anonymous | 1 | 0.00 | true | Private (2) | 2023-12-31 23:59 | null | 004 | null | null | null | (none) | (none) |
 
 ## Driving conventions
 
diff --git a/.agents/skills/verify-querykit/harness/Driver/Configs.cs b/.agents/skills/verify-querykit/harness/Driver/Configs.cs
index 5f58b9d..f039f90 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Configs.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Configs.cs
@@ -28,11 +28,13 @@ public static class Configs
                 s.DerivedProperty<Recipe>(x => x.Rating >= 4).HasQueryName("top_rated");
             })),
 
-        ["custom-operation"] = ("CustomOperation: total_stock_above = sum of Ingredients.Stock > value.",
+        ["custom-operation"] = ("CustomOperation: total_stock_above = sum of Ingredients.Stock > value. sku_is = Sku == (string)value.",
             () => new QueryKitConfiguration(s =>
             {
                 s.CustomOperation<Recipe>((x, op, value) => x.Ingredients.Sum(i => i.Stock) > (int)value)
                     .HasQueryName("total_stock_above");
+                s.CustomOperation<Recipe>((x, op, value) => x.Sku == (string)value)
+                    .HasQueryName("sku_is");
             })),
 
         ["word-operators"] = ("Custom operators: eq neq gt gte lt lte ct sw ew, and/or, case-insensitive appendix i.",
@@ -52,6 +54,12 @@ public static class Configs
                 s.CaseInsensitiveAppendix = "i";
             })),
 
+        ["hidden-price"] = ("Price PreventFilter and PreventSort, with HasQueryName(\"cost\").",
+            () => new QueryKitConfiguration(s =>
+            {
+                s.Property<Recipe>(x => x.Price).HasQueryName("cost").PreventFilter().PreventSort();
+            })),
+
         ["allow-unknown"] = ("AllowUnknownProperties = true.",
             () => new QueryKitConfiguration(s => s.AllowUnknownProperties = true)),
 
diff --git a/.agents/skills/verify-querykit/harness/Driver/Model.cs b/.agents/skills/verify-querykit/harness/Driver/Model.cs
index 7bd6836..a4ff3ca 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Model.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Model.cs
@@ -33,6 +33,9 @@ public class Recipe
     public Visibility Visibility { get; set; }
     public DateTime CreatedAt { get; set; }
     public DateOnly? DateOfOrigin { get; set; }
+    public string Sku { get; set; } = "";
+    public string? Serving { get; set; }
+    public TimeOnly? ServeTime { get; set; }
     public List<string> Tags { get; set; } = [];
     public Guid AuthorId { get; set; }
     public Author Author { get; set; } = null!;
@@ -61,25 +64,29 @@ public static List<Recipe> Build()
             Recipe(1, "Pancakes", julia, rating: 5, price: 4.50m, vegetarian: true, Visibility.Public,
                 created: new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc), origin: new DateOnly(1900, 1, 1),
                 directions: "Whisk and fry", tags: ["breakfast", "sweet"],
-                ingredients: [("flour", 10), ("egg", 0)]),
+                ingredients: [("flour", 10), ("egg", 0)],
+                sku: "001", serving: "Warm, with syrup", serveTime: new TimeOnly(8, 30, 0, 500)),
             Recipe(2, "Beef Stew", gordon, rating: 3, price: 12.00m, vegetarian: false, Visibility.Public,
                 created: new DateTime(2024, 3, 1, 18, 30, 0, DateTimeKind.Utc), origin: null,
                 directions: "Simmer for hours", tags: ["dinner"],
-                ingredients: [("beef", 2), ("salt", 50)]),
+                ingredients: [("beef", 2), ("salt", 50)],
+                sku: "002", serving: "Hot", serveTime: new TimeOnly(18, 0, 0)),
             Recipe(3, "Salt Bread", julia, rating: 4, price: 3.25m, vegetarian: true, Visibility.Private,
                 created: new DateTime(2024, 6, 10, 12, 0, 0, DateTimeKind.Utc), origin: new DateOnly(1950, 5, 20),
                 directions: "Knead and bake", tags: ["bread", "Winner"],
-                ingredients: [("salt", 5), ("flour", 3)]),
+                ingredients: [("salt", 5), ("flour", 3)],
+                sku: "003", serving: "Sliced", serveTime: new TimeOnly(12, 15, 30, 250)),
             Recipe(4, "Plain Water", anon, rating: 1, price: 0m, vegetarian: true, Visibility.Private,
                 created: new DateTime(2023, 12, 31, 23, 59, 0, DateTimeKind.Utc), origin: null,
                 directions: null, tags: [],
-                ingredients: []),
+                ingredients: [],
+                sku: "004", serving: null, serveTime: null),
         ];
     }
 
     private static Recipe Recipe(int n, string title, Author author, int rating, decimal price, bool vegetarian,
         Visibility visibility, DateTime created, DateOnly? origin, string? directions, List<string> tags,
-        (string Name, int Stock)[] ingredients)
+        (string Name, int Stock)[] ingredients, string sku, string? serving, TimeOnly? serveTime)
     {
         var id = G(n);
         return new Recipe
@@ -93,6 +100,9 @@ private static Recipe Recipe(int n, string title, Author author, int rating, dec
             Visibility = visibility,
             CreatedAt = created,
             DateOfOrigin = origin,
+            Sku = sku,
+            Serving = serving,
+            ServeTime = serveTime,
             Tags = tags,
             AuthorId = author.Id,
             Author = author,
diff --git a/.agents/skills/verify-querykit/harness/Driver/Program.cs b/.agents/skills/verify-querykit/harness/Driver/Program.cs
index 38f43c0..d4a6eb0 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Program.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Program.cs
@@ -14,6 +14,7 @@
 var target = "both";
 var configName = "none";
 var aggregate = false;
+string? culture = null;
 
 for (var i = 0; i < args.Length; i++)
 {
@@ -24,16 +25,24 @@
         case "--target": target = args[++i]; break;
         case "--config": configName = args[++i]; break;
         case "--aggregate": aggregate = true; break;
+        case "--culture": culture = args[++i]; break;
         case "--list-configs":
             foreach (var (name, preset) in Configs.All) Console.WriteLine($"{name,-18} {preset.Description}");
             return 0;
         default:
             Console.Error.WriteLine($"Unknown argument '{args[i]}'.");
-            Console.Error.WriteLine("Usage: qk-driver [--filter <f>] [--sort <s>] [--target memory|postgres|both] [--config <preset>] [--aggregate] | --list-configs");
+            Console.Error.WriteLine("Usage: qk-driver [--filter <f>] [--sort <s>] [--target memory|postgres|both] [--config <preset>] [--aggregate] [--culture <name>] | --list-configs");
             return 1;
     }
 }
 
+if (culture is not null)
+{
+    // Simulates a consumer app whose thread culture is not en-US, for example de-DE.
+    System.Globalization.CultureInfo.CurrentCulture = new System.Globalization.CultureInfo(culture);
+    System.Globalization.CultureInfo.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
+}
+
 if (!Configs.All.TryGetValue(configName, out var configPreset))
 {
     Console.Error.WriteLine($"Unknown config preset '{configName}'. Run with --list-configs.");
@@ -72,7 +81,8 @@
 
 var doc = new JsonObject
 {
-    ["input"] = new JsonObject { ["filter"] = filter, ["sort"] = sort, ["config"] = configName, ["api"] = api },
+    ["input"] = new JsonObject { ["filter"] = filter, ["sort"] = sort, ["config"] = configName, ["api"] = api,
+        ["culture"] = System.Globalization.CultureInfo.CurrentCulture.Name, ["timeZone"] = TimeZoneInfo.Local.Id },
     ["expression"] = DescribeExpression(),
     ["results"] = results,
 };
@@ -162,6 +172,9 @@ void AddRows(JsonObject result, List<Recipe> recipes)
         ["visibility"] = r.Visibility.ToString(),
         ["createdAt"] = r.CreatedAt.ToString("O"),
         ["dateOfOrigin"] = r.DateOfOrigin?.ToString("O"),
+        ["sku"] = r.Sku,
+        ["serving"] = r.Serving,
+        ["serveTime"] = r.ServeTime?.ToString("O"),
         ["directions"] = r.Directions,
         ["tags"] = new JsonArray(r.Tags.Select(t => (JsonNode?)t).ToArray()),
         ["ingredients"] = new JsonArray(r.Ingredients.OrderBy(x => x.Name)
diff --git a/QueryKit.IntegrationTests/TestFixture.cs b/QueryKit.IntegrationTests/TestFixture.cs
index 1f97f3c..567fb72 100644
--- a/QueryKit.IntegrationTests/TestFixture.cs
+++ b/QueryKit.IntegrationTests/TestFixture.cs
@@ -28,7 +28,9 @@ public async Task InitializeAsync()
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions
         {
-            EnvironmentName = Consts.Testing.IntegrationTestingEnvName
+            EnvironmentName = Consts.Testing.IntegrationTestingEnvName,
+            // the file watcher for config reload can hang on start on macOS
+            Args = ["--hostBuilder:reloadConfigOnChange=false"]
         });
 
         _dbContainer = new PostgreSqlBuilder("postgres:15.1").Build();
diff --git a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
index b126188..8d3fd32 100644
--- a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
+++ b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
@@ -311,6 +311,31 @@ public async Task can_filter_by_string_for_collection_with_count()
         recipes.Count.Should().Be(1);
         recipes[0].Id.Should().Be(fakeRecipeOne.Id);
     }
+
+    [Fact]
+    public async Task can_filter_by_collection_count_less_than_or_equal()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"count {Guid.NewGuid()} ";
+        var recipeWithNone = new FakeRecipeBuilder().WithTitle($"{prefix}none").Build();
+        var recipeWithOne = new FakeRecipeBuilder().WithTitle($"{prefix}one").Build();
+        recipeWithOne.AddIngredient(new FakeIngredientBuilder().Build());
+        var recipeWithTwo = new FakeRecipeBuilder().WithTitle($"{prefix}two").Build();
+        recipeWithTwo.AddIngredient(new FakeIngredientBuilder().Build());
+        recipeWithTwo.AddIngredient(new FakeIngredientBuilder().Build());
+        await testingServiceScope.InsertAsync(recipeWithNone, recipeWithOne, recipeWithTwo);
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKitFilter("Ingredients #<= 1")
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().BeEquivalentTo(new[] { recipeWithNone.Id, recipeWithOne.Id });
+    }
     
     [Fact]
     public async Task can_filter_by_string_for_collection_contains()
@@ -1973,7 +1998,8 @@ public async Task can_filter_with_property_to_property_child_properties()
         
         // Act
         var queryableRecipes = testingServiceScope.DbContext().Recipes
-            .Include(x => x.Author);
+            .Include(x => x.Author)
+            .Where(x => x.Id == fakeRecipe.Id || x.Id == differentRecipe.Id);
         var appliedQueryable = queryableRecipes.ApplyQueryKitFilter(input);
         var recipes = await appliedQueryable.ToListAsync();
 
@@ -4258,4 +4284,35 @@ public async Task bare_property_name_on_the_right_is_still_a_property_to_propert
         people.Should().ContainSingle(p => p.Id == fakePersonOne.Id);
     }
 
+    [Fact]
+    public async Task can_apply_query_kit_data()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"data {Guid.NewGuid()} ";
+        var low = new FakeRecipeBuilder().WithTitle($"{prefix}low").WithRating(1).Build();
+        var high = new FakeRecipeBuilder().WithTitle($"{prefix}high").WithRating(5).Build();
+        var middle = new FakeRecipeBuilder().WithTitle($"{prefix}middle").WithRating(3).Build();
+        await testingServiceScope.InsertAsync(low, high, middle);
+
+        var queryKitData = new QueryKitData
+        {
+            Filters = "score >= 3",
+            SortOrder = "score desc",
+            Configuration = new QueryKitConfiguration(config =>
+            {
+                config.Property<Recipe>(x => x.Rating).HasQueryName("score");
+            })
+        };
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKit(queryKitData)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().Equal(high.Id, middle.Id);
+    }
 }
diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
new file mode 100644
index 0000000..f192c3d
--- /dev/null
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -0,0 +1,323 @@
+namespace QueryKit.IntegrationTests.Tests;
+
+using System.Globalization;
+using System.Linq.Expressions;
+using Configuration;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using Operators;
+using SharedTestingHelper.Fakes;
+using SharedTestingHelper.Fakes.Ingredients;
+using SharedTestingHelper.Fakes.Recipes;
+using WebApiTestProject.Entities;
+using WebApiTestProject.Entities.Recipes;
+
+public class FilterParsingRegressionTests : TestBase
+{
+    [Fact]
+    public async Task operator_alias_text_inside_quoted_value_is_kept()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"salt and pepper or eq {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder().Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} eq "{title}" and {nameof(TestingPerson.Id)} neq "{Guid.NewGuid()}" """;
+        var config = new QueryKitConfiguration(settings =>
+        {
+            settings.EqualsOperator = "eq";
+            settings.NotEqualsOperator = "neq";
+            settings.AndOperator = "and";
+            settings.OrOperator = "or";
+        });
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var appliedQueryable = queryablePeople.ApplyQueryKitFilter(input, config);
+        var people = await appliedQueryable.ToListAsync();
+
+        // Assert
+        people.Count.Should().Be(1);
+        people[0].Id.Should().Be(fakePersonOne.Id);
+    }
+
+    [Fact]
+    public async Task decimal_value_uses_invariant_culture()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"culture {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithRating(4.6m)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithRating(4.4m)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {nameof(TestingPerson.Rating)} > 4.5""";
+
+        // Act
+        var originalCulture = CultureInfo.CurrentCulture;
+        IQueryable<TestingPerson> appliedQueryable;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo("de-DE");
+            appliedQueryable = testingServiceScope.DbContext().People.ApplyQueryKitFilter(input);
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = originalCulture;
+        }
+        var people = await appliedQueryable.ToListAsync();
+
+        // Assert
+        people.Count.Should().Be(1);
+        people[0].Id.Should().Be(fakePersonOne.Id);
+    }
+
+    [Fact]
+    public async Task list_value_with_comma_is_one_item()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var suffix = Guid.NewGuid().ToString();
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle($"Warm, with syrup {suffix}")
+            .WithFirstName(suffix)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle("Warm")
+            .WithFirstName(suffix)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var inInput = $"""{nameof(TestingPerson.FirstName)} == "{suffix}" && {nameof(TestingPerson.Title)} ^^ ["Warm, with syrup {suffix}"]""";
+        var notInInput = $"""{nameof(TestingPerson.FirstName)} == "{suffix}" && {nameof(TestingPerson.Title)} !^^ ["Warm, with syrup {suffix}"]""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var inPeople = await queryablePeople.ApplyQueryKitFilter(inInput).ToListAsync();
+        var notInPeople = await queryablePeople.ApplyQueryKitFilter(notInInput).ToListAsync();
+
+        // Assert
+        inPeople.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+        notInPeople.Select(x => x.Id).Should().Equal(fakePersonTwo.Id);
+    }
+
+    [Theory]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00+02:00")]
+    [InlineData("SpecificDate ^^ [2024-01-15T10:00:00+02:00]")]
+    public async Task date_time_offset_value_with_offset_matches_same_instant(string valueFilter)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"offset {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero))
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 10, 0, 0, TimeSpan.Zero))
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+    }
+
+    [Theory]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.500Z")]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00.5+02:00")]
+    [InlineData("Time == 08:30:00.5")]
+    [InlineData("Time == \"08:30:00.5\"")]
+    public async Task fractional_seconds_are_kept(string valueFilter)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"fraction {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDateTime(new DateTime(2024, 1, 15, 8, 0, 0, 500, DateTimeKind.Utc))
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, 500, TimeSpan.Zero))
+            .WithTime(new TimeOnly(8, 30, 0, 500))
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDateTime(new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc))
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero))
+            .WithTime(new TimeOnly(8, 30, 0))
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+    }
+
+    [Theory]
+    [InlineData("Age == Rating", true)]
+    [InlineData("Rating == Age", true)]
+    [InlineData("Age != Rating", false)]
+    [InlineData("Rating != Age", false)]
+    public async Task int_property_compares_to_decimal_property(string valueFilter, bool expectEqualPerson)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"numeric {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(4)
+            .WithRating(4m)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(4)
+            .WithRating(4.5m)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(expectEqualPerson ? fakePersonOne.Id : fakePersonTwo.Id);
+    }
+
+    [Theory]
+    [InlineData("""Title @= "am" """, false)]
+    [InlineData("""Title _= "la" """, false)]
+    [InlineData("""Title _-= "mb" """, false)]
+    [InlineData("""Title !@= "am" """, true)]
+    [InlineData("""Title !_= "la" """, true)]
+    [InlineData("""Title !_-= "mb" """, true)]
+    public async Task case_sensitive_string_operator_handles_null_property(string valueFilter, bool expectNullPerson)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var firstName = $"null title {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithFirstName(firstName)
+            .WithTitle(null)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithFirstName(firstName)
+            .WithTitle("lamb")
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.FirstName)} == "{firstName}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(expectNullPerson ? fakePersonOne.Id : fakePersonTwo.Id);
+    }
+
+    [Fact]
+    public async Task comparison_operator_factory_with_uses_all_matches_every_item()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var name = $"waffle {Guid.NewGuid()}";
+        var fakeRecipeOne = new FakeRecipeBuilder().Build();
+        fakeRecipeOne.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        fakeRecipeOne.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        var fakeRecipeTwo = new FakeRecipeBuilder().Build();
+        fakeRecipeTwo.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        fakeRecipeTwo.AddIngredient(new FakeIngredientBuilder().WithName($"other {Guid.NewGuid()}").Build());
+        await testingServiceScope.InsertAsync(fakeRecipeOne, fakeRecipeTwo);
+
+        Expression<Func<Recipe, IEnumerable<string>>> ingredientNames = x => x.Ingredients.Select(y => y.Name);
+        var body = ComparisonOperator.EqualsOperator(usesAll: true)
+            .GetExpression<Recipe>(ingredientNames.Body, Expression.Constant(name), null);
+        var filterExpression = Expression.Lambda<Func<Recipe, bool>>(body, ingredientNames.Parameters);
+        var recipeIds = new[] { fakeRecipeOne.Id, fakeRecipeTwo.Id };
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => recipeIds.Contains(x.Id))
+            .Where(filterExpression)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().Equal(fakeRecipeOne.Id);
+    }
+
+    [Fact]
+    public async Task sort_direction_after_double_space_is_read()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"sort {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(20)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(40)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople
+            .Where(x => x.Title == title)
+            .ApplyQueryKitSort("Age  desc")
+            .ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonTwo.Id, fakePersonOne.Id);
+    }
+
+    [Theory]
+    [InlineData("""Tags ^$ "sweet" """, new[] { "pancakes" })]
+    [InlineData("""Tags ^$* "WINNER" """, new[] { "bread" })]
+    [InlineData("""Tags %^$ "dinner" """, new[] { "stew", "water" })]
+    public async Task has_returns_matching_rows(string input, string[] expectedTitles)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"tags {Guid.NewGuid()} ";
+        var pancakes = new FakeRecipeBuilder().WithTitle($"{prefix}pancakes").Build().SetTags(["breakfast", "sweet"]);
+        var stew = new FakeRecipeBuilder().WithTitle($"{prefix}stew").Build().SetTags(["dinner"]);
+        var bread = new FakeRecipeBuilder().WithTitle($"{prefix}bread").Build().SetTags(["bread", "Winner"]);
+        var water = new FakeRecipeBuilder().WithTitle($"{prefix}water").Build().SetTags([]);
+        await testingServiceScope.InsertAsync(pancakes, stew, bread, water);
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKitFilter(input)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Title[prefix.Length..]).Should().BeEquivalentTo(expectedTitles);
+    }
+}
diff --git a/QueryKit.UnitTests/EnumerableFilteringTests.cs b/QueryKit.UnitTests/EnumerableFilteringTests.cs
index 2a3478d..dc2d1b3 100644
--- a/QueryKit.UnitTests/EnumerableFilteringTests.cs
+++ b/QueryKit.UnitTests/EnumerableFilteringTests.cs
@@ -1,6 +1,7 @@
 namespace QueryKit.UnitTests;
 
 using FluentAssertions;
+using QueryKit.Configuration;
 using QueryKit.WebApiTestProject.Entities.Recipes;
 using SharedTestingHelper.Fakes.Recipes;
 
@@ -232,6 +233,32 @@ public void bare_property_name_on_the_right_is_still_a_property_to_property_comp
         result[0].Id.Should().Be(1);
     }
 
+    [Fact]
+    public void can_apply_query_kit_data_to_enumerable()
+    {
+        // Arrange
+        var low = new FakeRecipeBuilder().WithTitle("low").WithRating(1).Build();
+        var high = new FakeRecipeBuilder().WithTitle("high").WithRating(5).Build();
+        var middle = new FakeRecipeBuilder().WithTitle("middle").WithRating(3).Build();
+        var listOfRecipes = new List<Recipe> { low, high, middle };
+
+        var queryKitData = new QueryKitData
+        {
+            Filters = "score >= 3",
+            SortOrder = "score desc",
+            Configuration = new QueryKitConfiguration(config =>
+            {
+                config.Property<Recipe>(x => x.Rating).HasQueryName("score");
+            })
+        };
+
+        // Act
+        var result = listOfRecipes.ApplyQueryKit(queryKitData).ToList();
+
+        // Assert
+        result.Select(x => x.Title).Should().Equal("high", "middle");
+    }
+
     private class PersonWithNullableEmail
     {
         public string Name { get; set; } = null!;
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
index 87ce7fd..420ec16 100644
--- a/QueryKit.UnitTests/FilterParserTests.cs
+++ b/QueryKit.UnitTests/FilterParserTests.cs
@@ -42,7 +42,7 @@ public void complex_with_lots_of_types()
 
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
         filterExpression.ToDisplayString().Should()
-            .Be(""""x => (((((((((x.Title != null) AndAlso x.Title.ToLower().Contains("waffle & chicken".ToLower())) AndAlso (x.Age > 30)) OrElse (x.Id == aa648248-cb69-4217-ac95-d7484795afb2)) OrElse (x.Title == "lamb")) OrElse (x.Title == null)) AndAlso ((x.Age < 18) OrElse ((x.BirthMonth == January) AndAlso x.Title.StartsWith("ally")))) OrElse (x.Rating > 3.5)) OrElse ((x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso ((x.Date == new Nullable`1(new DateOnly(2022, 7, 1))) OrElse (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))))"""");
+            .Be(""""x => (((((((((x.Title != null) AndAlso x.Title.ToLower().Contains("waffle & chicken".ToLower())) AndAlso (x.Age > 30)) OrElse (x.Id == aa648248-cb69-4217-ac95-d7484795afb2)) OrElse (x.Title == "lamb")) OrElse (x.Title == null)) AndAlso ((x.Age < 18) OrElse ((x.BirthMonth == January) AndAlso ((x.Title != null) AndAlso x.Title.StartsWith("ally"))))) OrElse (x.Rating > 3.5)) OrElse ((x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso ((x.Date == new Nullable`1(new DateOnly(2022, 7, 1))) OrElse (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))))"""");
     }
 
     [Fact]
@@ -173,7 +173,7 @@ public void starts_with_operator()
     {
         var input = """Title _= "lam" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.StartsWith(\"lam\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.StartsWith(\"lam\"))");
     }
 
     [Fact]
@@ -189,7 +189,7 @@ public void ends_with_operator()
     {
         var input = """Title _-= "b" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.EndsWith(\"b\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.EndsWith(\"b\"))");
     }
 
     [Fact]
@@ -273,7 +273,7 @@ public void can_handle_datetime_comparison_with_timezone()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03+01:00""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 01:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922268030000000, 00:00:00)))");
     }
 
     [Theory]
@@ -308,7 +308,7 @@ public void can_handle_datetime_comparison_with_timezone_another()
     {
         var input = """SpecificDate == "2022-07-01T00:00:03+01:00" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 01:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922268030000000, 00:00:00)))");
     }
 
     [Fact]
@@ -324,7 +324,7 @@ public void can_handle_datetime_comparison_with_negative_timezone()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03-02:00""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, -02:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922376030000000, 00:00:00)))");
     }
 
     [Fact]
@@ -332,7 +332,7 @@ public void can_handle_datetime_comparison_with_timezone_no_minutes()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03+02""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 02:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922232030000000, 00:00:00)))");
     }
 
     [Fact]
@@ -372,7 +372,7 @@ public void multiple_properties_and_operators()
     {
         var input = """Title _= "lamb" && Age >= 25 && Rating < 4.5 && SpecificDate <= 2022-07-01T00:00:03Z && Time == 00:00:03""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => ((((x.Title.StartsWith(\"lamb\") AndAlso (x.Age >= 25)) AndAlso (x.Rating < 4.5)) AndAlso (x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00)))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))");
+        filterExpression.ToDisplayString().Should().Be("x => ((((((x.Title != null) AndAlso x.Title.StartsWith(\"lamb\")) AndAlso (x.Age >= 25)) AndAlso (x.Rating < 4.5)) AndAlso (x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00)))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))");
     }
 
     [Fact]
@@ -380,7 +380,7 @@ public void complex_filter_with_nested_parentheses()
     {
         var input = """(Title == "lamb" && ((Age >= 25 && Rating < 4.5) || (SpecificDate <= 2022-07-01T00:00:03Z && Time == 00:00:03)) && (Favorite == true || Email.Value _= "example"))""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("""x => (((x.Title == "lamb") AndAlso (((x.Age >= 25) AndAlso (x.Rating < 4.5)) OrElse ((x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0)))))) AndAlso ((x.Favorite == True) OrElse x.Email.Value.StartsWith("example")))""");
+        filterExpression.ToDisplayString().Should().Be("""x => (((x.Title == "lamb") AndAlso (((x.Age >= 25) AndAlso (x.Rating < 4.5)) OrElse ((x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0)))))) AndAlso ((x.Favorite == True) OrElse ((x.Email.Value != null) AndAlso x.Email.Value.StartsWith("example"))))""");
     }
 
     [Fact]
@@ -412,7 +412,7 @@ public void ends_with_works()
     {
         var input = """Title _-= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.EndsWith(\"lamb\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.EndsWith(\"lamb\"))");
     }
 
     [Fact]
@@ -428,7 +428,7 @@ public void contains_is_case_sensitive()
     {
         var input = """Title @= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.Contains(\"lamb\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.Contains(\"lamb\"))");
     }
 
     [Fact]
@@ -436,7 +436,7 @@ public void not_contains_works()
     {
         var input = """Title !@= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => Not(x.Title.Contains(\"lamb\"))");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title == null) OrElse Not(x.Title.Contains(\"lamb\")))");
     }
 
     [Fact]
@@ -725,6 +725,15 @@ public void collection_has_operator_greater_than_equal()
             .Be(""""x => (x.Ingredients.Count() >= 0)"""");
     }
 
+    [Fact]
+    public void collection_has_operator_less_than_equal()
+    {
+        var input = """"Ingredients #<= 1"""";
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToDisplayString().Should()
+            .Be(""""x => (x.Ingredients.Count() <= 1)"""");
+    }
+
     [Fact]
     public void primitive_collection_has()
     {
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
new file mode 100644
index 0000000..2116f59
--- /dev/null
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -0,0 +1,305 @@
+namespace QueryKit.UnitTests;
+
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using Exceptions;
+using FluentAssertions;
+using Operators;
+using SharedTestingHelper.Fakes.Recipes;
+using WebApiTestProject.Entities;
+using WebApiTestProject.Entities.Recipes;
+
+public class FilterParsingRegressionTests
+{
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("fr-FR")]
+    [InlineData("en-US")]
+    public void decimal_value_uses_invariant_culture(string cultureName)
+    {
+        var input = """Rating > 4.5""";
+
+        var filterExpression = WithCulture(cultureName, () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Rating > 4.5)");
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("fr-FR")]
+    public void decimal_value_with_culture_decimal_comma_is_read_as_before(string cultureName)
+    {
+        var input = """Rating > 4,5""";
+
+        var filterExpression = WithCulture(cultureName, () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Rating > 45)");
+    }
+
+    [Fact]
+    public void decimal_value_with_decimal_comma_is_not_accepted_in_a_culture_with_decimal_point()
+    {
+        var input = """Rating > 4,5""";
+
+        var act = () => WithCulture("en-US", () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        act.Should().Throw<QueryKitException>();
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("en-US")]
+    public void list_numbers_are_separated_by_commas_in_every_culture(string cultureName)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "four", Rating = 4m },
+            new TestingPerson { Title = "four and a half", Rating = 4.5m },
+            new TestingPerson { Title = "five", Rating = 5m },
+        };
+
+        var result = WithCulture(cultureName, () => people.AsQueryable().ApplyQueryKitFilter("Rating ^^ [4,5]").ToList());
+
+        result.Select(x => x.Title).Should().Equal("four", "five");
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("en-US")]
+    public void list_number_uses_invariant_culture(string cultureName)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "four", Rating = 4m },
+            new TestingPerson { Title = "four and a half", Rating = 4.5m },
+        };
+
+        var result = WithCulture(cultureName, () => people.AsQueryable().ApplyQueryKitFilter("Rating ^^ [4.5, 6]").ToList());
+
+        result.Select(x => x.Title).Should().Equal("four and a half");
+    }
+
+    [Fact]
+    public void decimal_value_uses_invariant_culture_in_memory()
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "low", Rating = 4.4m },
+            new TestingPerson { Title = "high", Rating = 4.6m },
+        };
+
+        var result = WithCulture("de-DE", () => people.AsQueryable().ApplyQueryKitFilter("Rating > 4.5").ToList());
+
+        result.Select(x => x.Title).Should().Equal("high");
+    }
+
+    [Theory]
+    [InlineData("Title ^^ [\"Warm, with syrup\", \"a\\b\"]", new[] { "Warm, with syrup", "a\\b" })]
+    [InlineData("Title !^^ [\"Warm, with syrup\", \"a\\b\"]", new[] { "Warm", "with syrup" })]
+    [InlineData("Title ^^* [\"WARM, WITH SYRUP\"]", new[] { "Warm, with syrup" })]
+    [InlineData("Title ^^ [\"\"\"Warm, with syrup\"\"\", \"Warm\"]", new[] { "Warm, with syrup", "Warm" })]
+    [InlineData("Title ^^ [\" Warm \", \"with syrup \"]", new[] { "Warm", "with syrup" })]
+    public void list_value_with_comma_is_one_item(string input, string[] expectedTitles)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "Warm, with syrup" },
+            new TestingPerson { Title = "Warm" },
+            new TestingPerson { Title = "with syrup" },
+            new TestingPerson { Title = "a\\b" },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo(expectedTitles);
+    }
+
+    [Fact]
+    public void enum_list_value_is_split_into_items()
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "jan", BirthMonth = BirthMonthEnum.January },
+            new TestingPerson { Title = "feb", BirthMonth = BirthMonthEnum.February },
+            new TestingPerson { Title = "mar", BirthMonth = BirthMonthEnum.March },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter("""BirthMonth ^^ ["January", "March"]""").ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo("jan", "mar");
+    }
+
+    [Theory]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.500Z")]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.5Z")]
+    [InlineData("SpecificDateTime == \"2024-01-15T08:00:00.5Z\"")]
+    [InlineData("SpecificDateTime ^^ [2024-01-15T08:00:00.5Z]")]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00.5+02:00")]
+    [InlineData("SpecificDate == 2024-01-15T08:00:00.5000000Z")]
+    [InlineData("Time == 08:30:00.5")]
+    [InlineData("Time == \"08:30:00.5\"")]
+    [InlineData("Time == \"08:30:00.50\"")]
+    [InlineData("Time ^^ [08:30:00.5]")]
+    public void fractional_seconds_are_kept(string input)
+    {
+        var people = new[]
+        {
+            new TestingPerson
+            {
+                Title = "match",
+                SpecificDateTime = new DateTime(2024, 1, 15, 8, 0, 0, 500, DateTimeKind.Utc),
+                SpecificDate = new DateTimeOffset(2024, 1, 15, 8, 0, 0, 500, TimeSpan.Zero),
+                Time = new TimeOnly(8, 30, 0, 500),
+            },
+            new TestingPerson
+            {
+                Title = "whole second",
+                SpecificDateTime = new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc),
+                SpecificDate = new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero),
+                Time = new TimeOnly(8, 30, 0),
+            },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal("match");
+    }
+
+    [Fact]
+    public void time_fraction_keeps_microseconds()
+    {
+        var filterExpression = FilterParser.ParseFilter<TestingPerson>("Time == 08:30:00.123456");
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Time == new Nullable`1(new TimeOnly(8, 30, 0, 123, 456)))");
+    }
+
+    [Theory]
+    [InlineData("Age == Rating", "equal")]
+    [InlineData("Rating == Age", "equal")]
+    [InlineData("Age != Rating", "different")]
+    [InlineData("Rating != Age", "different")]
+    public void int_property_compares_to_decimal_property(string input, string expectedTitle)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "equal", Age = 4, Rating = 4m },
+            new TestingPerson { Title = "different", Age = 4, Rating = 4.5m },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal(expectedTitle);
+    }
+
+    [Theory]
+    [InlineData("""Title @= "am" """, new[] { "lamb" })]
+    [InlineData("""Title _= "la" """, new[] { "lamb" })]
+    [InlineData("""Title _-= "mb" """, new[] { "lamb" })]
+    [InlineData("""Title !@= "am" """, new[] { "null", "other" })]
+    [InlineData("""Title !_= "la" """, new[] { "null", "other" })]
+    [InlineData("""Title !_-= "mb" """, new[] { "null", "other" })]
+    public void case_sensitive_string_operator_handles_null_property(string input, string[] expectedFirstNames)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = null, FirstName = "null" },
+            new TestingPerson { Title = "lamb", FirstName = "lamb" },
+            new TestingPerson { Title = "other", FirstName = "other" },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.FirstName).Should().Equal(expectedFirstNames);
+    }
+
+    public static IEnumerable<object[]> ComparisonOperatorFactories() =>
+        typeof(ComparisonOperator).GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .Where(x => x.ReturnType == typeof(ComparisonOperator)
+                && x.GetParameters().Select(p => p.Name).SequenceEqual(new[] { "caseInsensitive", "usesAll" }))
+            .Select(x => new object[] { x.Name });
+
+    [Theory]
+    [MemberData(nameof(ComparisonOperatorFactories))]
+    public void comparison_operator_factory_keeps_uses_all(string factoryName)
+    {
+        var factory = typeof(ComparisonOperator).GetMethod(factoryName, BindingFlags.Public | BindingFlags.Static)!;
+
+        var comparisonOperator = (ComparisonOperator)factory.Invoke(null, new object[] { true, true })!;
+
+        comparisonOperator.UsesAll.Should().BeTrue();
+        comparisonOperator.CaseInsensitive.Should().BeTrue();
+    }
+
+    [Fact]
+    public void comparison_operator_factory_has_one_test_case_per_operator_type()
+    {
+        ComparisonOperatorFactories().Should().HaveCount(24);
+    }
+
+    [Fact]
+    public void comparison_operator_factory_with_uses_all_builds_all_expression()
+    {
+        Expression<Func<Recipe, IEnumerable<string>>> ingredientNames = x => x.Ingredients.Select(y => y.Name);
+
+        var body = ComparisonOperator.EqualsOperator(usesAll: true)
+            .GetExpression<Recipe>(ingredientNames.Body, Expression.Constant("waffle"), null);
+        var filterExpression = Expression.Lambda<Func<Recipe, bool>>(body, ingredientNames.Parameters);
+
+        filterExpression.ToDisplayString().Should()
+            .Be(FilterParser.ParseFilter<Recipe>("""Ingredients.Name %== "waffle" """).ToDisplayString());
+    }
+
+    [Theory]
+    [InlineData("Age  desc")]
+    [InlineData("Age   desc")]
+    [InlineData("Age\tdesc")]
+    public void sort_direction_after_extra_white_space_is_read(string input)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "young", Age = 20 },
+            new TestingPerson { Title = "old", Age = 40 },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitSort(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal("old", "young");
+    }
+
+    [Theory]
+    [InlineData("""Tags ^$ "sweet" """, new[] { "pancakes" })]
+    [InlineData("""Tags ^$* "WINNER" """, new[] { "bread" })]
+    [InlineData("""Tags %^$ "dinner" """, new[] { "stew", "water" })]
+    public void has_returns_matching_rows(string input, string[] expectedTitles)
+    {
+        var recipes = new[]
+        {
+            new FakeRecipeBuilder().WithTitle("pancakes").Build().SetTags(["breakfast", "sweet"]),
+            new FakeRecipeBuilder().WithTitle("stew").Build().SetTags(["dinner"]),
+            new FakeRecipeBuilder().WithTitle("bread").Build().SetTags(["bread", "Winner"]),
+            new FakeRecipeBuilder().WithTitle("water").Build().SetTags([]),
+        };
+
+        var result = recipes.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo(expectedTitles);
+    }
+
+    private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
+    {
+        var originalCulture = CultureInfo.CurrentCulture;
+        var originalUiCulture = CultureInfo.CurrentUICulture;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo(cultureName);
+            CultureInfo.CurrentUICulture = new CultureInfo(cultureName);
+            return action();
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = originalCulture;
+            CultureInfo.CurrentUICulture = originalUiCulture;
+        }
+    }
+}
diff --git a/QueryKit.UnitTests/OperatorAliasTests.cs b/QueryKit.UnitTests/OperatorAliasTests.cs
index 681cef1..1751706 100644
--- a/QueryKit.UnitTests/OperatorAliasTests.cs
+++ b/QueryKit.UnitTests/OperatorAliasTests.cs
@@ -153,7 +153,7 @@ public void can_use_contains_not_case_sensitive()
             config.CaseInsensitiveAppendix = "$";
         });
         var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
-        filterExpression.ToDisplayString().Should().Be($"""x => x.Title.Contains("titilating")""");
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title != null) AndAlso x.Title.Contains("titilating"))""");
     }
 
     [Fact]
@@ -204,6 +204,39 @@ public void can_use_ints()
         filterExpression.ToDisplayString().Should().Be($"""x => (x.Rating > 10)""");
     }
 
+    [Fact]
+    public void alias_text_inside_quoted_value_is_not_replaced()
+    {
+        var input = """Title eq "salt and pepper or eq gt" and Rating gt 3""";
+
+        var config = new CustomQueryKitConfiguration();
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title == "salt and pepper or eq gt") AndAlso (x.Rating > 3))""");
+    }
+
+    [Fact]
+    public void case_insensitive_alias_text_inside_quoted_value_is_not_replaced()
+    {
+        var input = """Title eqi "Whisk AND fry" """;
+
+        var config = new CustomQueryKitConfiguration();
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title != null) AndAlso (x.Title.ToLower() == "Whisk AND fry".ToLower()))""");
+    }
+
+    [Fact]
+    public void can_use_alias_operator_with_query_name()
+    {
+        var input = """name eq "a eq b" """;
+
+        var config = new CustomQueryKitConfiguration(settings =>
+        {
+            settings.Property<Recipe>(x => x.Title).HasQueryName("name");
+        });
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => (x.Title == "a eq b")""");
+    }
+
     public class CustomQueryKitConfiguration : QueryKitConfiguration
     {
         public CustomQueryKitConfiguration(Action<QueryKitSettings>? configureSettings = null)
diff --git a/QueryKit/Configuration/QueryKitConfigurationExtensions.cs b/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
index 43735b6..f025780 100644
--- a/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
+++ b/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
@@ -1,37 +1,9 @@
 namespace QueryKit.Configuration;
 
-using System.Text.RegularExpressions;
 using QueryKit.Exceptions;
-using QueryKit.Operators;
 
 internal static class QueryKitConfigurationExtensions
 {
-    internal static string ReplaceComparisonAliases(this IQueryKitConfiguration configuration, string input)
-    {
-        var aliasedOperators = ComparisonOperator.GetAliasMatches(configuration);
-        foreach (var comparisonAliasMatch in aliasedOperators)
-        {
-            var escapedAlias = Regex.Escape(comparisonAliasMatch.Alias);
-            var regex = AliasRegexCache.Get($@"(?<=\s|^){escapedAlias}(?=\s|$)");
-            input = regex.Replace(input, comparisonAliasMatch.Operator);
-        }
-        
-        return input;
-    }
-    
-    internal static string ReplaceLogicalAliases(this IQueryKitConfiguration configuration, string input)
-    {
-        var aliasedOperators = LogicalOperator.GetAliasMatches(configuration);
-        foreach (var logicalAliasMatch in aliasedOperators)
-        {
-            var escapedAlias = Regex.Escape(logicalAliasMatch.Alias);
-            var regex = AliasRegexCache.Get($@"(?<=\s|^){escapedAlias}(?=\s|$)");
-            input = regex.Replace(input, logicalAliasMatch.Operator);
-        }
-        
-        return input;
-    }    
-    
     internal static string? GetPropertyPathByQueryName(this IQueryKitConfiguration configuration, string? queryName)
     {
         return configuration.PropertyMappings.GetPropertyPathByQueryName(queryName);
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index c36c616..37bac4d 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Text;
 using Configuration;
 using Exceptions;
 using Operators;
@@ -21,9 +22,6 @@ public static class FilterParser
     public static Expression<Func<T, bool>> ParseFilter<T>(string input, IQueryKitConfiguration? config = null)
     {
         EnsureWithinParseLimits(input, config);
-
-        input = config?.ReplaceLogicalAliases(input) ?? input;
-        input = config?.ReplaceComparisonAliases(input) ?? input;
         
         var parameter = Expression.Parameter(typeof(T), "x");
         Expression expr;
@@ -136,12 +134,45 @@ from closeParen in Parse.Char(')')
             .Or(Parse.String(ComparisonOperator.HasOperator().Operator()).Text())
             .Or(Parse.String(ComparisonOperator.DoesNotHaveOperator().Operator()).Text());
 
-    private static readonly Parser<ComparisonOperator> ComparisonOperatorParser =
-        Parse.Char(ComparisonOperator.AllPrefix).Optional().Select(opt => opt.IsDefined)
-            .Then(hasHash => 
-                ComparisonOperatorTextParser
-                    .SelectMany(op => Parse.Char(ComparisonOperator.CaseSensitiveAppendix).Optional(), (op, caseInsensitive) => new { op, caseInsensitive, hasHash })
-                    .Select(x => ComparisonOperator.GetByOperatorString(x.op, x.caseInsensitive.IsDefined, x.hasHash)));
+    private static readonly Parser<(string Operator, bool CaseInsensitive)> CanonicalComparisonOperatorParser =
+        ComparisonOperatorTextParser
+            .SelectMany(op => Parse.Char(ComparisonOperator.CaseSensitiveAppendix).Optional(), (op, caseInsensitive) => (op, caseInsensitive.IsDefined));
+
+    private static Parser<ComparisonOperator> ComparisonOperatorParser(IQueryKitConfiguration? config)
+    {
+        var operatorParser = ComparisonOperatorAliasParser(config).Or(CanonicalComparisonOperatorParser);
+        return Parse.Char(ComparisonOperator.AllPrefix).Optional().Select(opt => opt.IsDefined)
+            .Then(hasHash => operatorParser.Select(x => ComparisonOperator.GetByOperatorString(x.Operator, x.CaseInsensitive, hasHash)));
+    }
+
+    // Aliases are matched in the grammar (not by rewriting the input) so text inside quoted values is never changed.
+    // Longer aliases are tried first so an alias that starts with another alias (e.g. `@@$$` and `@@$`) still matches.
+    private static Parser<(string Operator, bool CaseInsensitive)> ComparisonOperatorAliasParser(IQueryKitConfiguration? config)
+    {
+        Parser<(string Operator, bool CaseInsensitive)> parser = i => Result.Failure<(string, bool)>(i, "no operator alias", Array.Empty<string>());
+        if (config == null)
+            return parser;
+
+        var caseInsensitiveSuffix = ComparisonOperator.CaseSensitiveAppendix.ToString();
+        foreach (var match in ComparisonOperator.GetAliasMatches(config).OrderByDescending(x => x.Alias.Length))
+        {
+            var caseInsensitive = match.Operator.EndsWith(caseInsensitiveSuffix);
+            var op = caseInsensitive ? match.Operator[..^caseInsensitiveSuffix.Length] : match.Operator;
+            parser = parser.Or(OperatorAlias(match.Alias).Return((op, caseInsensitive)));
+        }
+
+        return parser;
+    }
+
+    // An alias is a whole word: it must be followed by whitespace or the end of the input.
+    private static Parser<string> OperatorAlias(string alias) => input =>
+    {
+        var result = Parse.IgnoreCase(alias).Text()(input);
+        if (!result.WasSuccessful || result.Remainder.AtEnd || char.IsWhiteSpace(result.Remainder.Current))
+            return result;
+
+        return Result.Failure<string>(input, $"Operator alias '{alias}' must be followed by whitespace", new[] { alias });
+    };
 
     private static PropertyInfo? GetPropertyInfo(Type type, string propertyName)
         => type.GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
@@ -164,20 +195,37 @@ private static readonly Parser<string> DoubleQuoteParser
      * DateTime (no offset information): yyyy-MM-ddTHH:mm:ss.ffffff
      * DateTime (in UTC): yyyy-MM-ddTHH:mm:ss.ffffffZ
      */
-    private static readonly Parser<string> TimeFormatParser = Parse.Regex(@"\d{2}:\d{2}:\d{2}").Text();
+    private static readonly Parser<string> TimeFormatParser = Parse.Regex(@"\d{2}:\d{2}:\d{2}(\.\d{1,7})?").Text();
     private static readonly Parser<string> DateTimeTimeParser = Parse.Regex(@"T\d{2}:\d{2}:\d{2}").Text().Optional().Select(x => x.GetOrElse(""));
+    private static readonly Parser<string> DateTimeMicrosParser = Parse.Regex(@"\.\d{1,7}").Text().Optional().Select(x => x.GetOrElse(""));
     private static readonly Parser<string> DateTimeZoneParser = Parse.Regex(@"Z|[+-]\d{2}(:\d{2})?").Text().Optional().Select(x => x.GetOrElse(""));
-    private static readonly Parser<string> DateTimeMicrosParser = Parse.Regex(@"\.\d{1,6}").Text().Optional().Select(x => x.GetOrElse(""));
     private static readonly Parser<string> DateTimeFormatParser =
         from dateFormat in Parse.Regex(@"\d{4}-\d{2}-\d{2}").Text()
         from timeFormat in DateTimeTimeParser
-        from timeZone in DateTimeZoneParser
         from micros in DateTimeMicrosParser
+        from timeZone in DateTimeZoneParser
         select dateFormat + timeFormat + micros + timeZone;
 
+    // A number with a '.' decimal point, or with the decimal separator of the current culture.
+    // The longer match wins, so '4.5' parses in every culture and '4,5' still parses in a culture that uses ','.
+    private static readonly Parser<string> UnsignedNumberParser = input =>
+    {
+        var invariant = Parse.DecimalInvariant(input);
+        var culture = Parse.Decimal(input);
+        return culture.WasSuccessful && (!invariant.WasSuccessful || culture.Remainder.Position > invariant.Remainder.Position)
+            ? culture
+            : invariant;
+    };
+
     private static readonly Parser<string> NumberParser =
         from sign in Parse.Char('-').Optional().Select(x => x.IsDefined ? "-" : "")
-        from number in Parse.Decimal
+        from number in UnsignedNumberParser
+        select sign + number;
+
+    // List items are separated by ',', so a list number always uses the '.' decimal point.
+    private static readonly Parser<string> ListNumberParser =
+        from sign in Parse.Char('-').Optional().Select(x => x.IsDefined ? "-" : "")
+        from number in Parse.DecimalInvariant
         select sign + number;
 
     private static readonly Parser<string> GuidFormatParser = Parse.Regex(@"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}").Text();
@@ -199,7 +247,7 @@ from closingQuotes in Parse.Char('"').Repeat(count).Text()
             .Or(GuidFormatParser)
             .Or(DateTimeFormatParser)
             .Or(TimeFormatParser)
-            .Or(NumberParser)
+            .Or(ListNumberParser)
             .Or(RawStringLiteralParser.Or(DoubleQuoteParser))
             .Or(Identifier)
             .DelimitedBy(Parse.Char(',').Token());
@@ -208,7 +256,37 @@ from closingQuotes in Parse.Char('"').Repeat(count).Text()
         from openingBracket in Parse.Char('[')
         from content in SquareBracketValuesParser
         from closingBracket in Parse.Char(']')
-        select "[" + string.Join(",", content) + "]";
+        select "[" + string.Join(",", content.Select(EscapeListItem)) + "]";
+
+    // List items are joined with ',' so quoted items that contain ',' or '\' are escaped and split back with SplitListItems, which trims each item
+    private static string EscapeListItem(string item)
+        => item.Replace(@"\", @"\\").Replace(",", @"\,");
+
+    private static List<string> SplitListItems(string list)
+    {
+        var items = new List<string>();
+        var current = new StringBuilder();
+        var content = list.Substring(1, list.Length - 2);
+        for (var i = 0; i < content.Length; i++)
+        {
+            if (content[i] == '\\' && i + 1 < content.Length)
+            {
+                current.Append(content[++i]);
+            }
+            else if (content[i] == ',')
+            {
+                items.Add(current.ToString().Trim());
+                current.Clear();
+            }
+            else
+            {
+                current.Append(content[i]);
+            }
+        }
+        items.Add(current.ToString().Trim());
+
+        return items;
+    }
 
     private static readonly Parser<RightSideValue> RightSideValueChoiceParser =
         Parse.String("null").Text().Select(v => new RightSideValue(v, false))
@@ -269,6 +347,18 @@ from trailingSpaces in Parse.WhiteSpace.Many()
             ArithmeticFactorParser.Token(),
             (op, left, right) => new BinaryArithmeticExpression(left, op, right));
 
+    private static Parser<LogicalOperator> LogicalOperatorParserWithAliases(IQueryKitConfiguration? config)
+    {
+        var aliases = config == null ? new List<LogicalOperator.LogicalAliasMatch>() : LogicalOperator.GetAliasMatches(config);
+        return aliases.Aggregate(
+            LogicalOperatorParser,
+            (parser, match) => parser.Or(
+                from leadingSpaces in Parse.WhiteSpace.Many()
+                from op in OperatorAlias(match.Alias)
+                from trailingSpaces in Parse.WhiteSpace.Many()
+                select LogicalOperator.GetByOperatorString(match.Operator)));
+    }
+
     private static readonly Dictionary<Type, Func<string, object>> TypeConversionFunctions = new()
     {
         { typeof(string), value => value },
@@ -283,7 +373,7 @@ from trailingSpaces in Parse.WhiteSpace.Many()
         { typeof(short), value => short.Parse(value, CultureInfo.InvariantCulture) },
         { typeof(byte), value => byte.Parse(value, CultureInfo.InvariantCulture) },
         { typeof(DateTime), value => DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal) },
-        { typeof(DateTimeOffset), value => DateTimeOffset.Parse(value) },
+        { typeof(DateTimeOffset), value => DateTimeOffset.Parse(value).ToUniversalTime() },
         { typeof(DateOnly), value => DateOnly.Parse(value) },
         { typeof(TimeOnly), value => TimeOnly.Parse(value) },
         { typeof(TimeSpan), value => TimeSpan.Parse(value) },
@@ -382,7 +472,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
         var targetType = leftExprType;
         if (isEnumerable)
         {
-            if (op.IsCountOperator() && int.TryParse(right, out var intVal))
+            if (op.IsCountOperator() && (int.TryParse(right, out var intVal) || int.TryParse(right, NumberStyles.Integer, CultureInfo.InvariantCulture, out intVal)))
             {
                 return FilterValue.Parameter(intVal, typeof(int));
             }
@@ -414,7 +504,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
                 {
                     targetType = typeof(string);
                 }
-                var values = right.Trim('[', ']').Split(',').Select(x => x.Trim()).ToList();
+                var values = SplitListItems(right);
                 var elementType = targetType.IsArray ? targetType.GetElementType()! : targetType;
 
                 var expressions = values.Select(x =>
@@ -453,7 +543,8 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             {
                 var dtStyle = right.EndsWith("Z") ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.AssumeLocal;
                 var dto = DateTimeOffset.Parse(right, CultureInfo.InvariantCulture, dtStyle);
-                return FilterValue.Parameter(dto, rawType);
+                // Npgsql only accepts a DateTimeOffset parameter with offset 0. The UTC value is the same instant.
+                return FilterValue.Parameter(dto.ToUniversalTime(), rawType);
             }
 
             if (targetType == typeof(DateOnly))
@@ -466,19 +557,9 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             {
                 var time = TimeOnly.Parse(right, CultureInfo.InvariantCulture);
 
-                int millisecond = 0, microsecond = 0;
-                if (right.Contains('.'))
-                {
-                    var fractionalSeconds = right.Split('.')[1];
-                    if (fractionalSeconds.Length >= 3)
-                    {
-                        millisecond = int.Parse(fractionalSeconds.Substring(0, 3));
-                    }
-                    if (fractionalSeconds.Length >= 6)
-                    {
-                        microsecond = int.Parse(fractionalSeconds.Substring(3, 3));
-                    }
-                }
+                var fractionalTicks = time.Ticks % TimeSpan.TicksPerSecond;
+                var millisecond = (int)(fractionalTicks / TimeSpan.TicksPerMillisecond);
+                var microsecond = (int)(fractionalTicks % TimeSpan.TicksPerMillisecond / 10);
 
                 // One microsecond is 10 ticks. The TimeOnly constructor with microseconds needs .NET 7.
                 var value = new TimeOnly(time.Hour, time.Minute, time.Second, millisecond)
@@ -515,7 +596,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             
             if (right.StartsWith("[") && right.EndsWith("]"))
             {
-                var values = right.Trim('[', ']').Split(',').Select(x => x.Trim()).ToList();
+                var values = SplitListItems(right);
                 var elementType = targetType.IsArray ? targetType.GetElementType() : targetType;
             
                 var expressions = values.Select<string, Expression>(x =>
@@ -584,7 +665,7 @@ private static bool IsEnumerable(Type targetType)
     // New arithmetic-aware comparison parser - only matches expressions in parentheses with arithmetic operators
     private static Parser<Expression> ArithmeticComparisonExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
         
         // Only parse arithmetic expressions that are in parentheses and contain arithmetic operators
@@ -703,7 +784,7 @@ private static CaseInsensitiveMode ResolveCaseMode(string? propertyPath, IQueryK
 
     private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
 
         // Try property list comparison first (e.g., (firstName, lastName) @=* "paul")
@@ -1029,7 +1110,7 @@ private static Parser<Expression> PropertyListComparisonExprParser<T>(
         ParameterExpression parameter,
         IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
 
         return PropertyListParser
@@ -1124,14 +1205,14 @@ private static Parser<Expression> ExprParser<T>(ParameterExpression parameter, I
     
     private static Parser<Expression> AndExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config = null)
         => Parse.ChainOperator(
-            LogicalOperatorParser.Where(x => x.Name == LogicalOperator.AndOperator.Operator()),
+            LogicalOperatorParserWithAliases(config).Where(x => x.Name == LogicalOperator.AndOperator.Operator()),
             AtomicExprParser<T>(parameter, config),
             CombineClauses<T>
         );
 
     private static Parser<Expression> OrExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config = null)
         => Parse.ChainOperator(
-            LogicalOperatorParser.Where(x => x.Name == LogicalOperator.OrOperator.Operator()),
+            LogicalOperatorParserWithAliases(config).Where(x => x.Name == LogicalOperator.OrOperator.Operator()),
             AndExprParser<T>(parameter, config),
             CombineClauses<T>
         );
@@ -1284,8 +1365,9 @@ private static bool IsPropertyPath(string value, Type entityType)
         if (value == "null" || 
             value.StartsWith("\"") || 
             value.StartsWith("[") ||
-            value.Contains("-") && DateTime.TryParse(value, out _) ||
+            value.Contains("-") && (DateTime.TryParse(value, out _) || DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out _)) ||
             decimal.TryParse(value, out _) ||
+            decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _) ||
             bool.TryParse(value, out _) ||
             Guid.TryParse(value, out _))
         {
diff --git a/QueryKit/Operators/ComparisonOperator.cs b/QueryKit/Operators/ComparisonOperator.cs
index 0d4e468..97c959a 100644
--- a/QueryKit/Operators/ComparisonOperator.cs
+++ b/QueryKit/Operators/ComparisonOperator.cs
@@ -34,30 +34,30 @@ public abstract class ComparisonOperator : SmartEnum<ComparisonOperator>
     public static ComparisonOperator CaseSensitiveHasOperator = new HasType();
     public static ComparisonOperator CaseSensitiveDoesNotHaveOperator = new DoesNotHaveType();
     
-    public static ComparisonOperator EqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new EqualsType(caseInsensitive);
-    public static ComparisonOperator NotEqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEqualsType(caseInsensitive);
-    public static ComparisonOperator GreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanType(caseInsensitive);
-    public static ComparisonOperator LessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanType(caseInsensitive);
-    public static ComparisonOperator GreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator LessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator ContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new ContainsType(caseInsensitive);
-    public static ComparisonOperator StartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new StartsWithType(caseInsensitive);
-    public static ComparisonOperator EndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new EndsWithType(caseInsensitive);
-    public static ComparisonOperator NotContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotContainsType(caseInsensitive);
-    public static ComparisonOperator NotStartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotStartsWithType(caseInsensitive);
-    public static ComparisonOperator NotEndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEndsWithType(caseInsensitive);
-    public static ComparisonOperator InOperator(bool caseInsensitive = false, bool usesAll = false) => new InType(caseInsensitive);
-    public static ComparisonOperator NotInOperator(bool caseInsensitive = false, bool usesAll = false) => new NotInType(caseInsensitive);
-    public static ComparisonOperator SoundsLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new SoundsLikeType(caseInsensitive);
-    public static ComparisonOperator DoesNotSoundLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotSoundLikeType(caseInsensitive);
-    public static ComparisonOperator HasCountEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountEqualToType(caseInsensitive);
-    public static ComparisonOperator HasCountNotEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountNotEqualToType(caseInsensitive);
-    public static ComparisonOperator HasCountGreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanType(caseInsensitive);
-    public static ComparisonOperator HasCountLessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanType(caseInsensitive);
-    public static ComparisonOperator HasCountGreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator HasCountLessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator HasOperator(bool caseInsensitive = false, bool usesAll = false) => new HasType(caseInsensitive);
-    public static ComparisonOperator DoesNotHaveOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotHaveType(caseInsensitive);
+    public static ComparisonOperator EqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new EqualsType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotEqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEqualsType(caseInsensitive, usesAll);
+    public static ComparisonOperator GreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator LessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator GreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator LessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator ContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new ContainsType(caseInsensitive, usesAll);
+    public static ComparisonOperator StartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new StartsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator EndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new EndsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotContainsType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotStartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotStartsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotEndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEndsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator InOperator(bool caseInsensitive = false, bool usesAll = false) => new InType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotInOperator(bool caseInsensitive = false, bool usesAll = false) => new NotInType(caseInsensitive, usesAll);
+    public static ComparisonOperator SoundsLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new SoundsLikeType(caseInsensitive, usesAll);
+    public static ComparisonOperator DoesNotSoundLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotSoundLikeType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountEqualToType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountNotEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountNotEqualToType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountGreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountLessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountGreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountLessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasOperator(bool caseInsensitive = false, bool usesAll = false) => new HasType(caseInsensitive, usesAll);
+    public static ComparisonOperator DoesNotHaveOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotHaveType(caseInsensitive, usesAll);
     
     public static ComparisonOperator GetByOperatorString(string op, bool caseInsensitive = false, bool usesAll = false)
     {
@@ -222,8 +222,8 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, caseComparison);
             }
 
-            // for some complex derived expressions
-            if (left.NodeType == ExpressionType.Convert)
+            // A derived property boxes its value to object. Unbox it to bool for a derived bool comparison.
+            if (left.NodeType == ExpressionType.Convert && left.Type == typeof(object))
             {
                 left = Expression.Convert(left, typeof(bool));
             }
@@ -261,8 +261,8 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, caseComparison);
             }
 
-            // for some complex derived expressions
-            if (left.NodeType == ExpressionType.Convert)
+            // A derived property boxes its value to object. Unbox it to bool for a derived bool comparison.
+            if (left.NodeType == ExpressionType.Convert && left.Type == typeof(object))
             {
                 left = Expression.Convert(left, typeof(bool));
             }
@@ -383,7 +383,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, containsCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right);
+            // null doesn't contain anything, so we need: left != null && left.Contains(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right));
         }
     }
 
@@ -415,7 +418,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, startsWithCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right);
+            // null doesn't start with anything, so we need: left != null && left.StartsWith(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right));
         }
     }
 
@@ -447,7 +453,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, endsWithCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right);
+            // null doesn't end with anything, so we need: left != null && left.EndsWith(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right));
         }
     }
 
@@ -479,7 +488,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notContainsCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right));
+            // null doesn't contain anything, so it should be included: left == null || !left.Contains(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right)));
         }
     }
 
@@ -511,7 +523,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notStartsWithCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right));
+            // null doesn't start with anything, so it should be included: left == null || !left.StartsWith(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right)));
         }
     }
 
@@ -543,7 +558,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notEndsWithCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right));
+            // null doesn't end with anything, so it should be included: left == null || !left.EndsWith(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right)));
         }
     }
 
diff --git a/QueryKit/SortParser.cs b/QueryKit/SortParser.cs
index af1c5f6..26c0280 100644
--- a/QueryKit/SortParser.cs
+++ b/QueryKit/SortParser.cs
@@ -40,9 +40,9 @@ public static List<SortExpressionInfo<T>> ParseSort<T>(string input, IQueryKitCo
 
     private static SortExpressionInfo<T> CreateSortExpression<T>(string sortClause, IQueryKitConfiguration? config = null)
     {
-        var parts = sortClause.Split();
+        var parts = sortClause.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
 
-        var propertyName = parts[0];
+        var propertyName = parts.Length > 0 ? parts[0] : sortClause;
         var direction = parts.Length > 1 ? parts[1].ToLowerInvariant() : Ascending;
         if (sortClause.StartsWith("-"))
         {