New DeepEquals for JsonDocument and JsonElement (#25)

* Add default DeepEquals comparison
* Add DeepEquals to JsonElement and JsonDocument
* Refactor deep equals
* Move node tests to a new directory
* Add tests for JsonElement
* Add tests for JsonDocument
* Paper work for 1.3.0

Author: weichch

Benchmark.md

@@ -15,10 +15,10 @@ BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1645 (21H1/May2021Update)
 
 ## Comparison Modes
 
-|   Method | FileSize |     Mean |   Median |      Min |      Max |      P80 |      P95 | Allocated |
-|--------- |--------- |---------:|---------:|---------:|---------:|---------:|---------:|----------:|
-|  RawText |    Small | 100.9 μs | 100.3 μs | 98.36 μs | 105.7 μs | 102.0 μs | 104.9 μs |     77 KB |
-| Semantic |    Small | 102.2 μs | 101.9 μs | 99.37 μs | 107.0 μs | 103.1 μs | 105.6 μs |     76 KB |
+|   Method | FileSize |      Mean |    Median |       Min |       Max |       P80 |       P95 | Allocated |
+|--------- |--------- |----------:|----------:|----------:|----------:|----------:|----------:|----------:|
+|  RawText |    Small |  94.05 μs |  94.09 μs |  93.13 μs |  95.36 μs |  94.35 μs |  94.80 μs |     75 KB |
+| Semantic |    Small | 104.65 μs | 104.27 μs | 102.67 μs | 107.86 μs | 105.55 μs | 107.76 μs |     75 KB |
 
 \* _All benchmarks are generated using the same small JSON object used in the **System.Text.Json vs Newtonsoft Json** section below, with array move detection enabled (default)._
 
@@ -28,23 +28,25 @@ BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1645 (21H1/May2021Update)
 
 |             Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
 |------------------- |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
-|     **SystemTextJson** |    **Small** |    **79.09 μs** |    **78.25 μs** |    **75.72 μs** |    **84.89 μs** |    **81.91 μs** |    **84.16 μs** |     **66 KB** |
-|            JsonNet |    Small |    91.98 μs |    92.15 μs |    90.06 μs |    94.50 μs |    92.77 μs |    93.78 μs |    132 KB |
-| SystemTextJson_Rfc |    Small |    94.88 μs |    94.74 μs |    93.34 μs |    97.80 μs |    95.69 μs |    96.86 μs |     87 KB |
-|        JsonNet_Rfc |    Small |   106.41 μs |   106.01 μs |   103.58 μs |   110.69 μs |   107.38 μs |   109.75 μs |    150 KB |
-|     **SystemTextJson** |    **Large** | **3,717.44 μs** | **3,700.53 μs** | **3,577.00 μs** | **3,913.15 μs** | **3,766.22 μs** | **3,901.23 μs** |  **3,258 KB** |
-|            JsonNet |    Large | 4,104.18 μs | 4,085.60 μs | 3,922.80 μs | 4,343.10 μs | 4,199.56 μs | 4,273.98 μs |  4,386 KB |
-| SystemTextJson_Rfc |    Large | 4,900.93 μs | 4,890.86 μs | 4,772.28 μs | 5,128.16 μs | 4,958.30 μs | 5,021.94 μs |  4,561 KB |
-|        JsonNet_Rfc |    Large | 5,569.83 μs | 5,535.12 μs | 5,354.93 μs | 5,976.46 μs | 5,682.46 μs | 5,822.63 μs |  6,147 KB |
+|     **SystemTextJson** |    **Small** |    **76.93 μs** |    **76.88 μs** |    **75.62 μs** |    **79.28 μs** |    **77.43 μs** |    **78.11 μs** |     **67 KB** |
+|            JsonNet |    Small |    84.97 μs |    84.75 μs |    83.72 μs |    87.68 μs |    85.64 μs |    86.38 μs |    132 KB |
+| SystemTextJson_Rfc |    Small |    91.88 μs |    91.71 μs |    90.70 μs |    95.01 μs |    92.37 μs |    94.37 μs |     89 KB |
+|        JsonNet_Rfc |    Small |   102.15 μs |   102.10 μs |   100.49 μs |   104.37 μs |   102.58 μs |   103.29 μs |    150 KB |
+|     **SystemTextJson** |    **Large** | **3,739.64 μs** | **3,734.25 μs** | **3,626.78 μs** | **3,902.76 μs** | **3,781.22 μs** | **3,844.92 μs** |  **3,365 KB** |
+|            JsonNet |    Large | 3,846.70 μs | 3,850.62 μs | 3,760.20 μs | 3,917.07 μs | 3,887.43 μs | 3,896.80 μs |  4,386 KB |
+| SystemTextJson_Rfc |    Large | 4,897.11 μs | 4,868.30 μs | 4,722.99 μs | 5,196.12 μs | 4,930.06 μs | 5,159.49 μs |  4,667 KB |
+|        JsonNet_Rfc |    Large | 5,260.99 μs | 5,249.26 μs | 5,121.82 μs | 5,487.74 μs | 5,322.84 μs | 5,460.47 μs |  6,147 KB |
 
 ### DeepEquals
 
-|         Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
-|--------------- |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
-| **SystemTextJson** |    **Small** |    **52.92 μs** |    **52.89 μs** |    **52.00 μs** |    **54.46 μs** |    **53.31 μs** |    **53.90 μs** |     **39 KB** |
-|        JsonNet |    Small |    58.82 μs |    58.77 μs |    57.78 μs |    60.41 μs |    59.16 μs |    59.74 μs |     91 KB |
-| **SystemTextJson** |    **Large** | **2,099.55 μs** | **2,090.78 μs** | **1,963.92 μs** | **2,302.56 μs** | **2,161.80 μs** | **2,223.10 μs** |  **1,631 KB** |
-|        JsonNet |    Large | 2,296.54 μs | 2,293.76 μs | 2,239.68 μs | 2,393.52 μs | 2,323.09 μs | 2,378.88 μs |  2,426 KB |
+|                  Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
+|------------------------ |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
+|     **SystemTextJson_Node** |    **Small** |    **55.10 μs** |    **54.96 μs** |    **54.14 μs** |    **56.93 μs** |    **55.49 μs** |    **56.57 μs** |     **38 KB** |
+| SystemTextJson_Document |    Small |    40.63 μs |    40.58 μs |    40.08 μs |    41.27 μs |    40.80 μs |    41.12 μs |     26 KB |
+|                 JsonNet |    Small |    57.84 μs |    57.62 μs |    57.17 μs |    59.40 μs |    58.07 μs |    58.98 μs |     91 KB |
+|     **SystemTextJson_Node** |    **Large** | **2,143.34 μs** | **2,125.71 μs** | **2,048.46 μs** | **2,328.43 μs** | **2,194.35 μs** | **2,266.60 μs** |  **1,571 KB** |
+| SystemTextJson_Document |    Large | 1,372.31 μs | 1,371.00 μs | 1,352.61 μs | 1,391.00 μs | 1,379.30 μs | 1,388.30 μs |    920 KB |
+|                 JsonNet |    Large | 2,208.71 μs | 2,209.77 μs | 2,182.51 μs | 2,246.30 μs | 2,223.80 μs | 2,235.96 μs |  2,426 KB |
 
 ### Patch
 

README.md

@@ -8,39 +8,40 @@ High-performance, low-allocating JSON object diff and patch extension for System
 
 - Compatible with [jsondiffpatch delta format](https://github.com/benjamine/jsondiffpatch/blob/master/docs/deltas.md)
 - Support generating patch document in RFC 6902 JSON Patch format
-- Target latest .NET Standard and .NET Framework 4.6.1 (for legacy apps) and leverage latest .NET features
+- Target latest **.NET Standard** and **.NET Framework 4.6.1** (for legacy apps) and leverage latest .NET features
 - Alternative to [jsondiffpatch.net](https://github.com/wbish/jsondiffpatch.net) which is based on Newtonsoft.Json
 - Fast large JSON document diffing with less memory consumption (see [benchmark](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md))
 - Support smart array diffing (e.g. move detect) using LCS (Longest Common Subsequence) and custom array item matcher
 - _(Only when not using RFC 6902 format)_ Support diffing long text using [google-diff-match-patch](http://code.google.com/p/google-diff-match-patch/), or write your own diff algorithm
-- Bonus `JsonNode.DeepClone` and `JsonNode.DeepEquals` methods
-- Bouns [`JsonValueComparer`](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.cs) that implements semantic comparison of two `JsonValue` objects (including `JsonValue` backed by `JsonElement`)
+- Bonus `DeepEquals` method for comparing `JsonDocument`, `JsonElement` and `JsonNode`
+- Bonus `DeepClone` method
+- Bonus [`JsonValueComparer`](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.cs) that implements semantic comparison of two `JsonValue` objects
 - JSON assert for xUnit, MSTest v2 and NUnit with customizable delta output
 
 ## Install
 
 #### JsonDiffPatch
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch
+PM> Install-Package SystemTextJson.JsonDiffPatch
 ```
 
 #### xUnit Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.Xunit
+PM> Install-Package SystemTextJson.JsonDiffPatch.Xunit
 ```
 
 #### MSTest v2 Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.MSTest
+PM> Install-Package SystemTextJson.JsonDiffPatch.MSTest
 ```
 
 #### NUnit Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.NUnit
+PM> Install-Package SystemTextJson.JsonDiffPatch.NUnit
 ```
 
 ## Usage
@@ -51,80 +52,91 @@ Install-Package SystemTextJson.JsonDiffPatch.NUnit
 // Diff JsonNode
 var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
 var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
-JsonNode? diff = node1.Diff(node2);
+var diff = node1.Diff(node2);
 // Diff with options
-JsonNode? diff = node1.Diff(node2, new JsonDiffOptions
+var diff = node1.Diff(node2, new JsonDiffOptions
 {
     JsonElementComparison = JsonElementComparison.Semantic
 });
 // Diff and convert delta into RFC 6902 JSON Patch format
-JsonNode? diff = node1.Diff(node2, new JsonPatchDeltaFormatter());
+var diff = node1.Diff(node2, new JsonPatchDeltaFormatter());
 // Diff JSON files
-JsonNode? diff = JsonDiffPatcher.DiffFile(file1, file2);
+var diff = JsonDiffPatcher.DiffFile(file1, file2);
 // Diff Span<byte>
-JsonNode? diff = JsonDiffPatcher.Diff(span1, span2);
+var diff = JsonDiffPatcher.Diff(span1, span2);
 // Diff streams
-JsonNode? diff = JsonDiffPatcher.Diff(stream1, stream2);
+var diff = JsonDiffPatcher.Diff(stream1, stream2);
 // Diff JSON strings
-JsonNode? diff = JsonDiffPatcher.Diff(json1, json2);
+var diff = JsonDiffPatcher.Diff(json1, json2);
 // Diff JSON readers
-JsonNode? diff = JsonDiffPatcher.Diff(ref reader1, ref reader2);
+var diff = JsonDiffPatcher.Diff(ref reader1, ref reader2);
 ```
 
-### DeepClone
+### Patch & Unpatch
 
 ```csharp
-var node = JsonNode.Parse("{\"foo\":\"bar\"}");
-JsonNode? cloned = node.DeepClone();
+var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
+var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
+var diff = node1.Diff(node2);
+// In-place patch
+JsonDiffPatcher.Patch(ref node1, diff);
+// Clone & patch
+var patched = node1.PatchNew(diff);
+// In-place unpatch
+JsonDiffPatcher.ReversePatch(ref node1, diff);
+// Clone & unpatch
+var patched = node1.ReversePatchNew(diff);
 ```
 
 ### DeepEquals
 
 ```csharp
-var node1 = JsonNode.Parse("{\"foo\":1.0}");
-var node2 = JsonNode.Parse("{\"foo\":1}");
-// equal is false
-bool equal = node1.DeepEquals(node2);
-// semanticEqual is true
-bool semanticEqual = node1.DeepEquals(node2, JsonElementComparison.Semantic);
-```
-
-### Semantic Value Comparison
-```csharp
-var node1 = JsonNode.Parse("\"2019-11-27\"");
-var node2 = JsonNode.Parse("\"2019-11-27T00:00:00.000\"");
-// dateCompare is 0
-var dateCompare = JsonValueComparer.Compare(node1, node2);
+// JsonDocument
+var doc1 = JsonDocument.Parse("{\"foo\":1}");
+var doc2 = JsonDocument.Parse("{\"foo\":1.0}");
+var equal = doc1.DeepEquals(doc2);
+var textEqual = doc1.DeepEquals(doc2, JsonElementComparison.RawText);
+var semanticEqual = doc1.DeepEquals(doc2, JsonElementComparison.Semantic);
 
-var node3 = JsonNode.Parse("1");
-var node4 = JsonNode.Parse("1.00");
-// numCompare is 0
-var numCompare = JsonValueComparer.Compare(node3, node4);
+// JsonNode
+var node1 = JsonNode.Parse("{\"foo\":1}");
+var node2 = JsonNode.Parse("{\"foo\":1.0}");
+var equal = node1.DeepEquals(node2);
+var textEqual = node1.DeepEquals(node2, JsonElementComparison.RawText);
+var semanticEqual = node1.DeepEquals(node2, JsonElementComparison.Semantic);
 ```
 
-### Patch & Unpatch
+### DeepClone
 
 ```csharp
-var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
-var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
-JsonNode? diff = node1.Diff(node2);
-// In-place patch
-JsonDiffPatcher.Patch(ref node1, diff);
-// Clone & patch
-node1.PatchNew(diff);
-// In-place unpatch
-JsonDiffPatcher.ReversePatch(ref node1, diff);
-// Clone & unpatch
-node1.ReversePatchNew(diff);
+var node = JsonNode.Parse("{\"foo\":\"bar\"}");
+var cloned = node.DeepClone();
 ```
 
 ### Default Options
 
 ```csharp
+// Default diff options
 JsonDiffPatcher.DefaultOptions = () => new JsonDiffOptions
 {
     JsonElementComparison = JsonElementComparison.Semantic
 };
+
+// Default comparison mode for DeepEquals
+JsonDiffPatcher.DefaultComparison = JsonElementComparison.Semantic;
+```
+
+### Semantic Value Comparison
+```csharp
+var node1 = JsonNode.Parse("\"2019-11-27\"");
+var node2 = JsonNode.Parse("\"2019-11-27T00:00:00.000\"");
+// dateCompare is 0
+var dateCompare = JsonValueComparer.Compare(node1, node2);
+
+var node3 = JsonNode.Parse("1");
+var node4 = JsonNode.Parse("1.00");
+// numCompare is 0
+var numCompare = JsonValueComparer.Compare(node3, node4);
 ```
 
 ### Assert (Unit Testing)
@@ -178,4 +190,4 @@ Delta:
 
 ## Benchmark
 
-[Benchmark results](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md) were generated using example objects [here](https://github.com/weichch/system-text-json-jsondiffpatch/tree/main/test/Examples) and benchmark tests [here](https://github.com/weichch/system-text-json-jsondiffpatch/tree/main/test/SystemTextJson.JsonDiffPatch.Benchmark/).
+See detailed [benchmark results](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md).

ReleaseNotes.md

@@ -1,5 +1,12 @@
 # Release Notes
 
+## 1.3.0
+
+- **Added `DeepEquals` implementation for `JsonDocument` and `JsonElement`**
+- Performance improvements in raw text comparison mode
+- Removed unnecessary allocation when default diff option is used
+- Removed one `DeepEquals` overload that was accidentally exposed as a public method
+
 ## 1.2.0
 
 - Major performance improvement in array comparison

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffOptions.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Text.Json.JsonDiffPatch.Diffs;
 using System.Text.Json.Nodes;
 
@@ -9,8 +10,7 @@ namespace System.Text.Json.JsonDiffPatch
     /// </summary>
     public class JsonDiffOptions
     {
-        internal static readonly JsonDiffOptions Default = new();
-        private JsonComparerOptions _comparerOptions;
+        private JsonElementComparison? _jsonElementComparison;
 
         /// <summary>
         /// Specifies whether to suppress detect array move. Default value is <c>false</c>.
@@ -49,22 +49,18 @@ public class JsonDiffOptions
         /// <summary>
         /// Gets or sets the mode to compare two <see cref="JsonElement"/> instances.
         /// </summary>
-        public JsonElementComparison JsonElementComparison { get; set; }
+        public JsonElementComparison JsonElementComparison
+        {
+            get => _jsonElementComparison ?? JsonDiffPatcher.DefaultComparison;
+            set => _jsonElementComparison = value;
+        }
 
         /// <summary>
         /// Gets or sets the <see cref="JsonValue"/> comparer.
         /// </summary>
         public IEqualityComparer<JsonValue>? ValueComparer { get; set; }
 
-        internal ref JsonComparerOptions CreateComparerOptions()
-        {
-            if (JsonElementComparison != _comparerOptions.JsonElementComparison
-                || !ReferenceEquals(ValueComparer, _comparerOptions.ValueComparer))
-            {
-                _comparerOptions = new JsonComparerOptions(JsonElementComparison, ValueComparer);
-            }
-
-            return ref _comparerOptions;
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal JsonComparerOptions CreateComparerOptions() => new(JsonElementComparison, ValueComparer);
     }
 }

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Array.cs

@@ -11,17 +11,17 @@ static partial class JsonDiffPatcher
         // https://github.com/benjamine/jsondiffpatch/blob/master/docs/deltas.md#array-with-inner-changes
         private static void DiffArray(
             ref JsonDiffDelta delta,
-            JsonArray left, 
+            JsonArray left,
             JsonArray right,
-            JsonDiffOptions options)
+            JsonDiffOptions? options)
         {
             // Both are empty arrays
             if (left.Count == 0 && right.Count == 0)
             {
                 return;
             }
 
-            ref var comparerOptions = ref options.CreateComparerOptions();
+            var comparerOptions = options?.CreateComparerOptions() ?? default;
 
             // Find command head
             int commonHead;
@@ -41,8 +41,8 @@ private static void DiffArray(
             // Find common tail
             int commonTail;
             for (commonTail = 0;
-                commonHead + commonTail < left.Count && commonHead + commonTail < right.Count;
-                commonTail++)
+                 commonHead + commonTail < left.Count && commonHead + commonTail < right.Count;
+                 commonTail++)
             {
                 var leftIndex = left.Count - 1 - commonTail;
                 var rightIndex = right.Count - 1 - commonTail;
@@ -67,21 +67,21 @@ private static void DiffArray(
 
                 // Otherwise, the left is shorter, so there were items added to the middle of the right array
                 for (var i = commonHead /* pointed to the first non-equal item */;
-                    i + commonTail < right.Count;
-                    i++)
+                     i + commonTail < right.Count;
+                     i++)
                 {
                     delta.ArrayChange(i, false, JsonDiffDelta.CreateAdded(right[i]));
                 }
 
                 return;
             }
-            
+
             if (commonHead + commonTail == right.Count)
             {
                 // The right is shorter, so there were items removed from the middle of left array
                 for (var i = commonHead /* pointed to the first non-equal item */;
-                    i + commonTail < left.Count;
-                    i++)
+                     i + commonTail < left.Count;
+                     i++)
                 {
                     delta.ArrayChange(i, true, JsonDiffDelta.CreateDeleted(left[i]));
                 }
@@ -131,15 +131,15 @@ private static void DiffArray(
                     {
                         // Added, detect if it's moved item
                         var isMoved = false;
-                        if (!options.SuppressDetectArrayMove && removedIndices is not null)
+                        if (options?.SuppressDetectArrayMove != true && removedIndices is not null)
                         {
                             for (var j = 0; j < removedIndices.Count; j++)
                             {
                                 var removedLeftIndex = removedIndices[j];
                                 if (lcs.AreEqual(
-                                    removedLeftIndex - commonHead /* Deleted in left */,
-                                    i - commonHead /* Current in right */,
-                                    out var isDeepEqual))
+                                        removedLeftIndex - commonHead /* Deleted in left */,
+                                        i - commonHead /* Current in right */,
+                                        out var isDeepEqual))
                                 {
                                     delta.ArrayMoveFromDeleted(removedLeftIndex, i);
 
@@ -178,7 +178,7 @@ private static void DiffArray(
             static void AddDiffResult(
                 ref JsonDiffDelta delta,
                 ref ArrayItemMatchContext context,
-                JsonDiffOptions options)
+                JsonDiffOptions? options)
             {
                 if (context.IsDeepEqual)
                 {
@@ -194,7 +194,7 @@ static void AddDiffResult(
             }
         }
 
-        internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffOptions options,
+        internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffOptions? options,
             in JsonComparerOptions comparerOptions)
         {
             if (context.Left.DeepEquals(context.Right, comparerOptions))
@@ -203,15 +203,16 @@ internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffO
                 return true;
             }
 
-            if (context.Left is JsonObject or JsonArray && context.Right is JsonObject or JsonArray)
+            if (options is not null && context.Left is JsonObject or JsonArray &&
+                context.Right is JsonObject or JsonArray)
             {
                 if (FuzzyMatchArrayItem(ref context, options, out var fuzzyResult))
                 {
                     return fuzzyResult;
                 }
             }
 
-            if (options.ArrayItemMatcher is not null)
+            if (options?.ArrayItemMatcher is not null)
             {
                 return options.ArrayItemMatcher(ref context);
             }
@@ -221,18 +222,18 @@ internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffO
 
         internal static bool MatchArrayItem(
             ref ArrayItemMatchContext context,
-            ref JsonValueComparisonContext valueContextLeft,
-            ref JsonValueComparisonContext valueContextRight,
-            JsonDiffOptions options,
+            ref JsonValueWrapper wrapperLeft,
+            ref JsonValueWrapper wrapperRight,
+            JsonDiffOptions? options,
             in JsonComparerOptions comparerOptions)
         {
-            if (valueContextLeft.DeepEquals(ref valueContextRight, comparerOptions))
+            if (wrapperLeft.DeepEquals(ref wrapperRight, comparerOptions))
             {
                 context.DeepEqual();
                 return true;
             }
 
-            if (options.ArrayItemMatcher is not null)
+            if (options?.ArrayItemMatcher is not null)
             {
                 return options.ArrayItemMatcher(ref context);
             }

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Diff.cs

@@ -200,6 +200,7 @@ static partial class JsonDiffPatcher
             JsonDiffOptions? options)
         {
             var delta = new JsonDiffDelta();
+            options ??= DefaultOptions?.Invoke();
             DiffInternal(ref delta, left, right, options);
 
             if (formatter is not null)
@@ -223,8 +224,6 @@ private static void DiffInternal(
         {
             Debug.Assert(delta.Document is null);
 
-            options ??= DefaultOptions?.Invoke() ?? JsonDiffOptions.Default;
-
             left ??= "";
             right ??= "";
 
@@ -246,13 +245,14 @@ private static void DiffInternal(
             // Compare two long texts
             if (IsLongText(left, right, options, out var leftText, out var rightText))
             {
-                DiffLongText(ref delta, leftText!, rightText!, options);
+                Debug.Assert(options is not null);
+                DiffLongText(ref delta, leftText!, rightText!, options!);
                 return;
             }
 
             // None of the above methods returned a result, fallback to check if both values are deeply equal
             // This should also handle DateTime and other CLR types that are strings in JSON
-            ref var comparerOptions = ref options.CreateComparerOptions();
+            var comparerOptions = options?.CreateComparerOptions() ?? default;
             if (!left.DeepEquals(right, comparerOptions))
             {
                 delta.Modified(left, right);

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Object.cs

@@ -12,7 +12,7 @@ private static void DiffObject(
             ref JsonDiffDelta delta, 
             JsonObject left, 
             JsonObject right,
-            JsonDiffOptions options)
+            JsonDiffOptions? options)
         {
             var leftProperties = (left as IDictionary<string, JsonNode?>).Keys;
             var rightProperties = (right as IDictionary<string, JsonNode?>).Keys;

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Text.cs

@@ -45,13 +45,18 @@ private static void DiffLongText(
         private static bool IsLongText(
             JsonNode? left,
             JsonNode? right,
-            JsonDiffOptions options,
+            JsonDiffOptions? options,
             out string? leftText,
             out string? rightText)
         {
             leftText = null;
             rightText = null;
 
+            if (options is null)
+            {
+                return false;
+            }
+
             if (left is not JsonValue || right is not JsonValue)
             {
                 return false;

src/SystemTextJson.JsonDiffPatch/Diffs/Lcs.cs

@@ -1,6 +1,7 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text.Json.Nodes;
 
 namespace System.Text.Json.JsonDiffPatch.Diffs
@@ -14,20 +15,22 @@ internal readonly ref struct Lcs
         private readonly Dictionary<int, LcsEntry>? _lookupByRightIndex;
         private readonly int[]? _matrixRented;
         private readonly int[]? _matchMatrixRented;
-        private readonly JsonValueComparisonContext[]? _comparisonContextCacheRented;
+        private readonly JsonValueWrapper[]? _wrapperCacheRented;
         private readonly int _rowSize;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private Lcs(List<LcsEntry> indices, int[] matrixRented, int[] matchMatrixRented,
-            JsonValueComparisonContext[]? comparisonContextCacheRented, int rowSize)
+            JsonValueWrapper[]? wrapperCacheRented, int rowSize)
         {
             _lookupByLeftIndex = indices.ToDictionary(entry => entry.LeftIndex);
             _lookupByRightIndex = indices.ToDictionary(entry => entry.RightIndex);
             _matrixRented = matrixRented;
             _matchMatrixRented = matchMatrixRented;
-            _comparisonContextCacheRented = comparisonContextCacheRented;
+            _wrapperCacheRented = wrapperCacheRented;
             _rowSize = rowSize;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool FindLeftIndex(int index, out LcsEntry result)
         {
             if (_lookupByLeftIndex is null)
@@ -39,6 +42,7 @@ public bool FindLeftIndex(int index, out LcsEntry result)
             return _lookupByLeftIndex.TryGetValue(index, out result);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool FindRightIndex(int index, out LcsEntry result)
         {
             if (_lookupByRightIndex is null)
@@ -50,6 +54,7 @@ public bool FindRightIndex(int index, out LcsEntry result)
             return _lookupByRightIndex.TryGetValue(index, out result);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool AreEqual(int indexX, int indexY, out bool deepEqual)
         {
             if (_matchMatrixRented is null)
@@ -75,13 +80,13 @@ public void Free()
                 ArrayPool<int>.Shared.Return(_matchMatrixRented);
             }
 
-            if (_comparisonContextCacheRented is not null)
+            if (_wrapperCacheRented is not null)
             {
-                ArrayPool<JsonValueComparisonContext>.Shared.Return(_comparisonContextCacheRented);
+                ArrayPool<JsonValueWrapper>.Shared.Return(_wrapperCacheRented);
             }
         }
 
-        public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions options)
+        public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions? options)
         {
             if (x.Length == 0 || y.Length == 0)
             {
@@ -98,27 +103,27 @@ public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions opti
             var matchMatrixSpan = matchMatrixRented.AsSpan(0, matrixLength);
             // For performance reasons, we set materialized values into a cache.
             // We only cache JSON values as they are more efficient to cache than objects and arrays.
-            var valueCacheRented = ArrayPool<JsonValueComparisonContext>.Shared.Rent(x.Length + y.Length);
-            var valueCacheSpan = valueCacheRented.AsSpan(0, x.Length + y.Length);
-            ref var comparerOptions = ref options.CreateComparerOptions();
+            var wrapperCacheRented = ArrayPool<JsonValueWrapper>.Shared.Rent(x.Length + y.Length);
+            var wrapperCacheSpan = wrapperCacheRented.AsSpan(0, x.Length + y.Length);
+            var comparerOptions = options?.CreateComparerOptions() ?? default;
 
             matrix.Fill(0);
             matchMatrixSpan.Fill(0);
-            valueCacheSpan.Fill(default);
+            wrapperCacheSpan.Fill(default);
 
             for (var i = 1; i < m; i++)
             {
                 if (x[i - 1] is JsonValue jsonValueX)
                 {
-                    valueCacheSpan[i - 1] = new JsonValueComparisonContext(jsonValueX, true);
+                    wrapperCacheSpan[i - 1] = new JsonValueWrapper(jsonValueX);
                 }
             }
 
             for (var j = 1; j < n; j++)
             {
                 if (y[j - 1] is JsonValue jsonValueY)
                 {
-                    valueCacheSpan[x.Length + j - 1] = new JsonValueComparisonContext(jsonValueY, true);
+                    wrapperCacheSpan[x.Length + j - 1] = new JsonValueWrapper(jsonValueY);
                 }
             }
 
@@ -149,8 +154,8 @@ public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions opti
                     if (x[i - 1] is JsonValue && y[j - 1] is JsonValue)
                     {
                         itemMatched = JsonDiffPatcher.MatchArrayItem(ref matchContext,
-                            ref valueCacheSpan[i - 1],
-                            ref valueCacheSpan[x.Length + j - 1],
+                            ref wrapperCacheSpan[i - 1],
+                            ref wrapperCacheSpan[x.Length + j - 1],
                             options,
                             comparerOptions);
                     }
@@ -222,7 +227,7 @@ public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions opti
                 }
             }
 
-            return new Lcs(entries, matrixRented, matchMatrixRented, valueCacheRented, n);
+            return new Lcs(entries, matrixRented, matchMatrixRented, wrapperCacheRented, n);
         }
 
         internal readonly struct LcsEntry

src/SystemTextJson.JsonDiffPatch/JsonComparerOptions.cs

@@ -3,29 +3,20 @@
 
 namespace System.Text.Json.JsonDiffPatch
 {
-    /// <summary>
-    /// Represents the options for internal JSON comparer.
-    /// </summary>
-    public readonly struct JsonComparerOptions
-    { 
-        /// <summary>
-        /// Creates an instance of the options.
-        /// </summary>
-        public JsonComparerOptions(JsonElementComparison jsonElementComparison,
+    internal readonly struct JsonComparerOptions
+    {
+        private readonly JsonElementComparison? _jsonElementComparison;
+
+        public JsonComparerOptions(JsonElementComparison? jsonElementComparison,
             IEqualityComparer<JsonValue>? valueComparer)
         {
-            JsonElementComparison = jsonElementComparison;
+            _jsonElementComparison = jsonElementComparison;
             ValueComparer = valueComparer;
         }
 
-        /// <summary>
-        /// Gets the mode to compare two <see cref="JsonElement"/> instances.
-        /// </summary>
-        public JsonElementComparison JsonElementComparison { get; }
+        public JsonElementComparison JsonElementComparison
+            => _jsonElementComparison ?? JsonDiffPatcher.DefaultComparison;
 
-        /// <summary>
-        /// Gets the value comparer.
-        /// </summary>
         public IEqualityComparer<JsonValue>? ValueComparer { get; }
     }
-}
+}

src/SystemTextJson.JsonDiffPatch/JsonDiffPatcher.DeepEquals.cs

@@ -36,7 +36,7 @@ public static bool DeepEquals(this JsonNode? left, JsonNode? right, JsonElementC
         public static bool DeepEquals(this JsonNode? left, JsonNode? right, IEqualityComparer<JsonValue> valueComparer)
         {
             _ = valueComparer ?? throw new ArgumentNullException(nameof(valueComparer));
-            return DeepEquals(left, right, new JsonComparerOptions(default, valueComparer));
+            return DeepEquals(left, right, new JsonComparerOptions(null, valueComparer));
         }
 
         /// <summary>
@@ -45,7 +45,7 @@ public static bool DeepEquals(this JsonNode? left, JsonNode? right, IEqualityCom
         /// <param name="left">The left value.</param>
         /// <param name="right">The right value.</param>
         /// <param name="comparerOptions">The value comparer options.</param>
-        public static bool DeepEquals(this JsonNode? left, JsonNode? right, in JsonComparerOptions comparerOptions)
+        internal static bool DeepEquals(this JsonNode? left, JsonNode? right, in JsonComparerOptions comparerOptions)
         {
             Debug.Assert(left is null or JsonObject or JsonArray or JsonValue);
             Debug.Assert(right is null or JsonObject or JsonArray or JsonValue);
@@ -69,26 +69,100 @@ public static bool DeepEquals(this JsonNode? left, JsonNode? right, in JsonCompa
             };
         }
 
-        private static bool ObjectEquals(JsonObject obj1, JsonObject obj2, in JsonComparerOptions comparerOptions)
+        /// <summary>
+        /// Determines whether two <see cref="JsonElement"/> objects are deeply equal.
+        /// </summary>
+        /// <param name="left">The left value.</param>
+        /// <param name="right">The right value.</param>
+        /// <param name="elementComparison">The JSON element comparison.</param>
+        public static bool DeepEquals(this JsonDocument? left, JsonDocument? right,
+            JsonElementComparison? elementComparison = null)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return true;
+            }
+
+            if (left is null || right is null)
+            {
+                return false;
+            }
+
+            return left.RootElement.DeepEquals(right.RootElement, elementComparison);
+        }
+
+        /// <summary>
+        /// Determines whether two <see cref="JsonElement"/> objects are deeply equal.
+        /// </summary>
+        /// <param name="left">The left value.</param>
+        /// <param name="right">The right value.</param>
+        /// <param name="elementComparison">The JSON element comparison.</param>
+        public static bool DeepEquals(this in JsonElement left, in JsonElement right,
+            JsonElementComparison? elementComparison = null)
         {
-            if (obj1.Count == 0 && obj2.Count == 0)
+            if (left.ValueKind != right.ValueKind)
+            {
+                return false;
+            }
+
+            elementComparison ??= DefaultComparison;
+
+            switch (left.ValueKind)
+            {
+                case JsonValueKind.Number:
+                    var leftNumber = new JsonNumber(left);
+                    var rightNumber = new JsonNumber(right);
+
+                    return elementComparison is JsonElementComparison.RawText
+                        ? leftNumber.RawTextEquals(ref rightNumber)
+                        : leftNumber.CompareTo(ref rightNumber) == 0;
+
+                case JsonValueKind.String:
+                    var leftString = new JsonString(left);
+                    var rightString = new JsonString(right);
+
+                    return elementComparison is JsonElementComparison.RawText
+                        ? leftString.ValueEquals(ref rightString)
+                        : leftString.Equals(ref rightString);
+                
+                case JsonValueKind.Object:
+                    return ObjectEquals(left, right, elementComparison.Value);
+
+                case JsonValueKind.Array:
+                    return ArrayEquals(left, right, elementComparison.Value);
+                
+                case JsonValueKind.True:
+                case JsonValueKind.False:
+                case JsonValueKind.Null:
+                case JsonValueKind.Undefined:
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(left.ValueKind),
+                        $"Unexpected JSON value kind {left.ValueKind:G}.");
+            }
+        }
+
+        private static bool ObjectEquals(JsonObject x, JsonObject y, in JsonComparerOptions comparerOptions)
+        {
+            if (x.Count == 0 && y.Count == 0)
             {
                 // Empty objects
                 return true;
             }
 
-            if (obj1.Count != obj2.Count)
+            if (x.Count != y.Count)
             {
                 // Property count mismatch
                 return false;
             }
 
-            foreach (var kvp in obj1)
+            foreach (var kvp in x)
             {
                 var propertyName = kvp.Key;
                 var obj1Value = kvp.Value;
 
-                if (!obj2.TryGetPropertyValue(propertyName, out var obj2Value))
+                if (!y.TryGetPropertyValue(propertyName, out var obj2Value))
                 {
                     // Missing property
                     return false;
@@ -104,22 +178,73 @@ private static bool ObjectEquals(JsonObject obj1, JsonObject obj2, in JsonCompar
             return true;
         }
 
-        private static bool ArrayEquals(JsonArray arr1, JsonArray arr2, in JsonComparerOptions comparerOptions)
+        private static bool ObjectEquals(in JsonElement x, in JsonElement y, JsonElementComparison elementComparison)
+        {
+            EnumerateProperty(x, out var propertiesX);
+            EnumerateProperty(y, out var propertiesY);
+
+            if (propertiesX is null && propertiesY is null)
+            {
+                return true;
+            }
+
+            if (propertiesX is null || propertiesY is null)
+            {
+                return false;
+            }
+
+            if (propertiesX.Count != propertiesY.Count)
+            {
+                return false;
+            }
+
+            foreach (var kvp in propertiesX)
+            {
+                if (!propertiesY.TryGetValue(kvp.Key, out var propertyY))
+                {
+                    return false;
+                }
+
+                if (!kvp.Value.Value.DeepEquals(propertyY.Value, elementComparison))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+
+            static void EnumerateProperty(in JsonElement element, out Dictionary<string, JsonProperty>? properties)
+            {
+                properties = null;
+
+                foreach (var property in element.EnumerateObject())
+                {
+                    if (properties is null)
+                    {
+                        properties = new Dictionary<string, JsonProperty>();
+                    }
+
+                    properties[property.Name] = property;
+                }
+            }
+        }
+
+        private static bool ArrayEquals(JsonArray x, JsonArray y, in JsonComparerOptions comparerOptions)
         {
-            if (arr1.Count == 0 && arr2.Count == 0)
+            if (x.Count == 0 && y.Count == 0)
             {
                 return true;
             }
 
-            if (arr1.Count != arr2.Count)
+            if (x.Count != y.Count)
             {
                 // Item count mismatch
                 return false;
             }
 
-            for (var i = 0; i < arr1.Count; i++)
+            for (var i = 0; i < x.Count; i++)
             {
-                if (!DeepEquals(arr1[i], arr2[i], comparerOptions))
+                if (!DeepEquals(x[i], y[i], comparerOptions))
                 {
                     return false;
                 }
@@ -128,25 +253,50 @@ private static bool ArrayEquals(JsonArray arr1, JsonArray arr2, in JsonComparerO
             return true;
         }
 
-        private static bool ValueEquals(JsonValue val1, JsonValue val2, in JsonComparerOptions comparerOptions)
+        private static bool ArrayEquals(in JsonElement x, in JsonElement y, JsonElementComparison elementComparison)
+        {
+            if (x.GetArrayLength() != y.GetArrayLength())
+            {
+                return false;
+            }
+
+            using var enumeratorX = x.EnumerateArray();
+            using var enumeratorY = y.EnumerateArray();
+
+            while (enumeratorX.MoveNext())
+            {
+                if (!enumeratorY.MoveNext() ||
+                    !enumeratorX.Current.DeepEquals(enumeratorY.Current, elementComparison))
+                {
+                    return false;
+                }
+            }
+
+            Debug.Assert(enumeratorX.MoveNext() == false);
+            Debug.Assert(enumeratorY.MoveNext() == false);
+
+            return true;
+        }
+
+        private static bool ValueEquals(JsonValue x, JsonValue y, in JsonComparerOptions comparerOptions)
         {
             var valueComparer = comparerOptions.ValueComparer;
             if (valueComparer is not null)
             {
-                var hash1 = valueComparer.GetHashCode(val1);
-                var hash2 = valueComparer.GetHashCode(val2);
+                var hash1 = valueComparer.GetHashCode(x);
+                var hash2 = valueComparer.GetHashCode(y);
 
                 if (hash1 != hash2)
                 {
                     return false;
                 }
 
-                return valueComparer.Equals(val1, val2);
+                return valueComparer.Equals(x, y);
             }
 
-            var ctx1 = new JsonValueComparisonContext(val1);
-            var ctx2 = new JsonValueComparisonContext(val2);
-            return ctx1.DeepEquals(ref ctx2, comparerOptions.JsonElementComparison);
+            var wrapperX = new JsonValueWrapper(x);
+            var wrapperY = new JsonValueWrapper(y);
+            return wrapperX.DeepEquals(ref wrapperY, comparerOptions.JsonElementComparison);
         }
     }
 }

src/SystemTextJson.JsonDiffPatch/JsonDiffPatcher.cs

@@ -9,5 +9,10 @@ public static partial class JsonDiffPatcher
         /// Gets or sets the default diff options.
         /// </summary>
         public static Func<JsonDiffOptions>? DefaultOptions { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default comparison mode used by <c>DeepEquals</c> to compare <see cref="JsonElement"/>.
+        /// </summary>
+        public static JsonElementComparison DefaultComparison { get; set; } = JsonElementComparison.RawText;
     }
 }

src/SystemTextJson.JsonDiffPatch/JsonNumber.cs

@@ -0,0 +1,317 @@
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Text.Json.Nodes;
+
+namespace System.Text.Json.JsonDiffPatch
+{
+    internal struct JsonNumber
+    {
+        private long? _longValue;
+        private decimal? _decimalValue;
+        private double? _doubleValue;
+        private readonly float? _floatValue;
+        private bool _isValueRead;
+
+        // Keep as field to avoid copy
+        public readonly JsonElement Element;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(in JsonElement element)
+        {
+            Debug.Assert(element.ValueKind is JsonValueKind.Number,
+                $"Expect JSON element type {JsonValueKind.Number:G}, but found {element.ValueKind:G}.");
+
+            Parent = null;
+            HasElement = true;
+            Element = element;
+            _longValue = null;
+            _decimalValue = null;
+            _doubleValue = null;
+            _floatValue = null;
+            _isValueRead = false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, int value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, long value)
+            : this(parent)
+        {
+            _longValue = value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, double value)
+            : this(parent)
+        {
+            _doubleValue = value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, short value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, decimal value)
+            : this(parent)
+        {
+            _decimalValue = value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, byte value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, float value)
+            : this(parent)
+        {
+            _floatValue = value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, uint value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, ushort value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, ulong value)
+            : this(parent)
+        {
+            _decimalValue = Convert.ToDecimal(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public JsonNumber(JsonValue parent, sbyte value)
+            : this(parent)
+        {
+            _longValue = Convert.ToInt64(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private JsonNumber(JsonValue parent)
+        {
+            Debug.Assert(parent is not null);
+
+            Parent = parent;
+            HasElement = false;
+            Element = default;
+            _longValue = null;
+            _decimalValue = null;
+            _doubleValue = null;
+            _floatValue = null;
+            _isValueRead = true;
+        }
+
+        public JsonValue? Parent { get; }
+        public bool HasElement { get; }
+
+        private long? LongValue
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                CreateValue();
+                return _longValue;
+            }
+        }
+
+        private decimal? DecimalValue
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                CreateValue();
+                return _decimalValue;
+            }
+        }
+
+        private double? DoubleValue
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                CreateValue();
+                return _doubleValue;
+            }
+        }
+
+        private float? FloatValue
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                CreateValue();
+                return _floatValue;
+            }
+        }
+
+        private void CreateValue()
+        {
+            if (_isValueRead)
+            {
+                return;
+            }
+
+            if (HasElement)
+            {
+                if (Element.TryGetInt64(out var longValue))
+                {
+                    _longValue = longValue;
+                }
+                else if (Element.TryGetDecimal(out var decimalValue))
+                {
+                    _decimalValue = decimalValue;
+                }
+                else if (Element.TryGetDouble(out var doubleValue))
+                {
+                    _doubleValue = doubleValue;
+                }
+            }
+
+            _isValueRead = true;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private decimal GetDecimal() => DecimalValue ?? (LongValue.HasValue
+            ? Convert.ToDecimal(LongValue.Value)
+            : DoubleValue.HasValue
+                ? Convert.ToDecimal(DoubleValue.Value)
+                : Convert.ToDecimal(FloatValue!.Value));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private double GetDouble() => DoubleValue ?? (LongValue.HasValue
+            ? Convert.ToDouble(LongValue.Value)
+            : Convert.ToDouble(FloatValue!.Value));
+            
+        public int CompareTo(ref JsonNumber another)
+        {
+            if (DecimalValue.HasValue || another.DecimalValue.HasValue)
+            {
+                return GetDecimal().CompareTo(another.GetDecimal());
+            }
+
+            if (DoubleValue.HasValue || FloatValue.HasValue ||
+                another.DoubleValue.HasValue || another.FloatValue.HasValue)
+            {
+                return JsonValueComparer.CompareDouble(GetDouble(), another.GetDouble());
+            }
+
+            return LongValue!.Value.CompareTo(another.LongValue!.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool RawTextEquals(ref JsonNumber another)
+        {
+            if (!HasElement || HasElement != another.HasElement)
+            {
+                return false;
+            }
+
+            return string.Equals(Element.GetRawText(), another.Element.GetRawText());
+        }
+
+        public static bool TryGetJsonNumber(JsonValue jsonValue, out JsonNumber result)
+        {
+            if (jsonValue.TryGetValue<JsonElement>(out var element))
+            {
+                if (element.ValueKind is JsonValueKind.Number)
+                {
+                    result = new JsonNumber(element);
+                    return true;
+                }
+            }
+            else
+            {
+                if (jsonValue.TryGetValue<int>(out var intValue))
+                {
+                    result = new JsonNumber(jsonValue, intValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<long>(out var longValue))
+                {
+                    result = new JsonNumber(jsonValue, longValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<double>(out var doubleValue))
+                {
+                    result = new JsonNumber(jsonValue, doubleValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<short>(out var shortValue))
+                {
+                    result = new JsonNumber(jsonValue, shortValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<decimal>(out var decimalValue))
+                {
+                    result = new JsonNumber(jsonValue, decimalValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<byte>(out var byteValue))
+                {
+                    result = new JsonNumber(jsonValue, byteValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<float>(out var floatValue))
+                {
+                    result = new JsonNumber(jsonValue, floatValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<uint>(out var uintValue))
+                {
+                    result = new JsonNumber(jsonValue, uintValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<ushort>(out var ushortValue))
+                {
+                    result = new JsonNumber(jsonValue, ushortValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<ulong>(out var ulongValue))
+                {
+                    result = new JsonNumber(jsonValue, ulongValue);
+                    return true;
+                }
+
+                if (jsonValue.TryGetValue<sbyte>(out var sbyteValue))
+                {
+                    result = new JsonNumber(jsonValue, sbyteValue);
+                    return true;
+                }
+            }
+
+            result = default;
+            return false;
+        }
+    }
+}

src/SystemTextJson.JsonDiffPatch/JsonString.cs

@@ -20,7 +20,7 @@ private static bool AreDoubleClose(double x, double y)
             return false;
         }
 
-        private static int CompareDouble(double x, double y)
+        internal static int CompareDouble(double x, double y)
         {
             return AreDoubleClose(x, y) ? 0 : x.CompareTo(y);
         }

src/SystemTextJson.JsonDiffPatch/JsonValueComparer.Number.cs

@@ -2,57 +2,8 @@
 {
     static partial class JsonValueComparer
     {
-        private static int CompareDateTime(ref JsonValueComparisonContext x, ref JsonValueComparisonContext y)
+        internal static int CompareByteArray(byte[] x, byte[] y)
         {
-            if (x.ValueType == typeof(DateTime))
-            {
-                return x.GetDateTime().CompareTo(y.GetDateTime());
-            }
-
-            return x.GetDateTimeOffset().CompareTo(y.GetDateTimeOffset());
-        }
-
-        private static bool TryCompareByteArray(ref JsonValueComparisonContext x, ref JsonValueComparisonContext y,
-            out int result)
-        {
-            if (x.ValueType == typeof(byte[]))
-            {
-                if (y.TryGetByteArray(out var byteArrayY))
-                {
-                    result = CompareByteArray(x.GetByteArray(), byteArrayY);
-                    return true;
-                }
-            }
-            else if (y.ValueType == typeof(byte[]))
-            {
-                if (x.TryGetByteArray(out var byteArrayX))
-                {
-                    result = CompareByteArray(byteArrayX, y.GetByteArray());
-                    return true;
-                }
-            }
-
-            result = -1;
-            return false;
-        }
-
-        private static int CompareByteArray(byte[]? x, byte[]? y)
-        {
-            if (x is null && y is null)
-            {
-                return 0;
-            }
-
-            if (x is null)
-            {
-                return -1;
-            }
-
-            if (y is null)
-            {
-                return 1;
-            }
-
             if (x.Length == 0 && y.Length == 0)
             {
                 return 0;

src/SystemTextJson.JsonDiffPatch/JsonValueComparer.String.cs

@@ -1,5 +1,4 @@
-using System.Diagnostics;
-using System.Text.Json.Nodes;
+using System.Text.Json.Nodes;
 
 namespace System.Text.Json.JsonDiffPatch
 {
@@ -30,84 +29,10 @@ public static int Compare(JsonValue? x, JsonValue? y)
                 return 1;
             }
 
-            var contextX = new JsonValueComparisonContext(x);
-            var contextY = new JsonValueComparisonContext(y);
+            var wrapperX = new JsonValueWrapper(x);
+            var wrapperY = new JsonValueWrapper(y);
 
-            if (contextX.ValueKind != contextY.ValueKind)
-            {
-                return -((int) contextX.ValueKind - (int) contextY.ValueKind);
-            }
-
-            return Compare(contextX.ValueKind, ref contextX, ref contextY);
-        }
-
-        internal static int Compare(JsonValueKind valueKind, ref JsonValueComparisonContext x,
-            ref JsonValueComparisonContext y)
-        {
-            Debug.Assert(x.Value is not null);
-            Debug.Assert(y.Value is not null);
-            Debug.Assert(x.ValueKind == y.ValueKind);
-
-            switch (valueKind)
-            {
-                case JsonValueKind.Number:
-                    if (x.ValueType == typeof(decimal) || y.ValueType == typeof(decimal) ||
-                        x.ValueType == typeof(ulong) || y.ValueType == typeof(ulong))
-                    {
-                        return x.GetDecimal().CompareTo(y.GetDecimal());
-                    }
-
-                    if (x.ValueType == typeof(double) || y.ValueType == typeof(double) ||
-                        x.ValueType == typeof(float) || y.ValueType == typeof(float))
-                    {
-                        return CompareDouble(x.GetDouble(), y.GetDouble());
-                    }
-
-                    return x.GetInt64().CompareTo(y.GetInt64());
-
-                case JsonValueKind.String:
-                    if (x.StringValueKind == y.StringValueKind)
-                    {
-                        switch (x.StringValueKind)
-                        {
-                            case JsonStringValueKind.DateTime:
-                                return CompareDateTime(ref x, ref y);
-                            case JsonStringValueKind.Guid:
-                                return x.GetGuid().CompareTo(y.GetGuid());
-                            case JsonStringValueKind.String:
-                                if ((x.ValueType == typeof(string) || x.ValueType == typeof(char))
-                                    && (y.ValueType == typeof(string) || y.ValueType == typeof(char)))
-                                {
-                                    return StringComparer.Ordinal.Compare(x.GetString(), y.GetString());
-                                }
-                                // Because testing whether string is based64 encoded is expensive operation,
-                                // we only test it when comparing with a byte array. Otherwise, we compare raw text.
-                                else if (x.ValueType == typeof(byte[]) || y.ValueType == typeof(byte[]))
-                                {
-                                    if (TryCompareByteArray(ref x, ref y, out var compareResult))
-                                    {
-                                        return compareResult;
-                                    }
-                                }
-
-                                break;
-                        }
-                    }
-
-                    return StringComparer.Ordinal.Compare(x.GetRawText(), y.GetRawText());
-
-                case JsonValueKind.Null:
-                case JsonValueKind.False:
-                case JsonValueKind.True:
-                    return 0;
-
-                case JsonValueKind.Undefined:
-                case JsonValueKind.Object:
-                case JsonValueKind.Array:
-                default:
-                    throw new ArgumentOutOfRangeException(
-                        nameof(valueKind), $"Unexpected value kind {valueKind:G}");
-            }
+            return wrapperX.CompareTo(ref wrapperY);
         }
     }
 }

src/SystemTextJson.JsonDiffPatch/JsonValueComparer.cs

@@ -0,0 +1,134 @@
+using System.Text.Json.Nodes;
+
+namespace System.Text.Json.JsonDiffPatch
+{
+    /// <summary>
+    /// Wrapper of <see cref="JsonNode"/> for value comparison purpose.
+    /// </summary>
+    internal struct JsonValueWrapper
+    {
+        // Keep as fields to avoid copy
+        public JsonNumber NumberValue;
+        public JsonString StringValue;
+        
+        public JsonValueWrapper(JsonValue value)
+        {
+            Value = value;
+            ValueKind = JsonValueKind.Undefined;
+            StringValue = default;
+
+            if (JsonNumber.TryGetJsonNumber(value, out NumberValue))
+            {
+                ValueKind = JsonValueKind.Number;
+            }
+            else if (JsonString.TryGetJsonString(value, out StringValue))
+            {
+                ValueKind = JsonValueKind.String;
+            }
+            else if (value.TryGetValue<bool>(out var booleanValue))
+            {
+                ValueKind = booleanValue ? JsonValueKind.True : JsonValueKind.False;
+            }
+        }
+        
+        public JsonValueKind ValueKind { get; }
+        public JsonValue Value { get; }
+
+        public bool DeepEquals(ref JsonValueWrapper another, in JsonComparerOptions comparerOptions)
+        {
+            var valueComparer = comparerOptions.ValueComparer;
+            if (valueComparer is not null)
+            {
+                var hash1 = valueComparer.GetHashCode(Value);
+                var hash2 = valueComparer.GetHashCode(another.Value);
+
+                if (hash1 != hash2)
+                {
+                    return false;
+                }
+
+                return valueComparer.Equals(Value, another.Value);
+            }
+
+            return DeepEquals(ref another, comparerOptions.JsonElementComparison);
+        }
+
+        public bool DeepEquals(ref JsonValueWrapper another, JsonElementComparison jsonElementComparison)
+        {
+            if (ReferenceEquals(Value, another.Value))
+            {
+                return true;
+            }
+            
+            if (ValueKind != another.ValueKind)
+            {
+                return false;
+            }
+
+            switch (ValueKind)
+            {
+                case JsonValueKind.Number:
+                    if (jsonElementComparison is JsonElementComparison.RawText &&
+                        NumberValue.HasElement &&
+                        another.NumberValue.HasElement)
+                    {
+                        return NumberValue.RawTextEquals(ref another.NumberValue);
+                    }
+
+                    return NumberValue.CompareTo(ref another.NumberValue) == 0;
+
+                case JsonValueKind.String:
+                    if (jsonElementComparison is JsonElementComparison.RawText &&
+                        StringValue.HasElement &&
+                        another.StringValue.HasElement)
+                    {
+                        return StringValue.ValueEquals(ref another.StringValue);
+                    }
+
+                    return StringValue.Equals(ref another.StringValue);
+
+                case JsonValueKind.True:
+                case JsonValueKind.False:
+                    return true;
+
+                case JsonValueKind.Null:
+                case JsonValueKind.Undefined:
+                case JsonValueKind.Object:
+                case JsonValueKind.Array:
+                default:
+                    return Value.TryGetValue<object>(out var objX)
+                           && another.Value.TryGetValue<object>(out var objY)
+                           && Equals(objX, objY);
+            }
+        }
+
+        public int CompareTo(ref JsonValueWrapper another)
+        {
+            if (ValueKind != another.ValueKind)
+            {
+                return -((int) ValueKind - (int) another.ValueKind);
+            }
+
+            switch (ValueKind)
+            {
+                case JsonValueKind.Number:
+                    return NumberValue.CompareTo(ref another.NumberValue);
+
+                case JsonValueKind.String:
+                    return StringValue.CompareTo(ref another.StringValue);
+
+                case JsonValueKind.True:
+                case JsonValueKind.False:
+                    return 0;
+                
+                case JsonValueKind.Null:
+                case JsonValueKind.Undefined:
+                case JsonValueKind.Object:
+                case JsonValueKind.Array:
+                default:
+                    throw new ArgumentOutOfRangeException(
+                        nameof(ValueKind), $"Unexpected value kind {ValueKind:G}");
+            }
+        }
+    }
+}

src/SystemTextJson.JsonDiffPatch/JsonValueComparisonContext.cs

@@ -1,3 +1,4 @@
 using System.Runtime.CompilerServices;
 
-[assembly:InternalsVisibleTo("SystemTextJson.JsonDiffPatch.Benchmark")]
+[assembly:InternalsVisibleTo("SystemTextJson.JsonDiffPatch.Benchmark")]
+[assembly:InternalsVisibleTo("SystemTextJson.JsonDiffPatch.UnitTests")]

src/SystemTextJson.JsonDiffPatch/JsonValueWrapper.cs

@@ -1,4 +1,5 @@
-using System.Text.Json.JsonDiffPatch;
+using System.Text.Json;
+using System.Text.Json.JsonDiffPatch;
 using System.Text.Json.Nodes;
 using BenchmarkDotNet.Attributes;
 using Newtonsoft.Json.Linq;
@@ -8,21 +9,30 @@ namespace SystemTextJson.JsonDiffPatch.Benchmark
     public class DeepEqualsJsonFileBenchmark : JsonFileBenchmark
     {
         [Benchmark]
-        public bool SystemTextJson()
+        public bool SystemTextJson_Node()
         {
-            var node1 = JsonNode.Parse(JsonLeft);
-            var node2 = JsonNode.Parse(JsonLeft);
+            var json1 = JsonNode.Parse(JsonLeft);
+            var json2 = JsonNode.Parse(JsonLeft);
 
-            return node1.DeepEquals(node2, JsonElementComparison.Semantic);
+            return json1.DeepEquals(json2, JsonElementComparison.Semantic);
+        }
+
+        [Benchmark]
+        public bool SystemTextJson_Document()
+        {
+            using var json1 = JsonDocument.Parse(JsonLeft);
+            using var json2 = JsonDocument.Parse(JsonLeft);
+
+            return json1.DeepEquals(json2, JsonElementComparison.Semantic);
         }
 
         [Benchmark]
         public bool JsonNet()
         {
-            var token1 = JToken.Parse(JsonLeft);
-            var token2 = JToken.Parse(JsonLeft);
+            var json1 = JToken.Parse(JsonLeft);
+            var json2 = JToken.Parse(JsonLeft);
 
-            return JToken.DeepEquals(token1, token2);
+            return JToken.DeepEquals(json1, json2);
         }
     }
 }

src/SystemTextJson.JsonDiffPatch/Properties/AssemblyInfo.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Buffers;
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
 namespace SystemTextJson.JsonDiffPatch.Benchmark
 {
-    public static class JsonNodeHelper
+    internal static class JsonHelper
     {
         public static JsonNode? Parse(string json)
         {
@@ -66,5 +68,32 @@ public static class JsonNodeHelper
 
             throw new ArgumentException("Cannot parse JSON element.");
         }
+
+#if NET
+        public static JsonElementWrapper ParseElement(string json)
+        {
+            var jsonChars = json.AsSpan();
+            var byteCount = Encoding.UTF8.GetByteCount(jsonChars);
+            var buffer = ArrayPool<byte>.Shared.Rent(byteCount);
+            var length = Encoding.UTF8.GetBytes(jsonChars, buffer);
+            var reader = new Utf8JsonReader(buffer.AsSpan().Slice(0, length));
+            return new JsonElementWrapper
+            {
+                Value = JsonElement.ParseValue(ref reader),
+                Buffer = buffer
+            };
+        }
+
+        public ref struct JsonElementWrapper
+        {
+            public JsonElement Value;
+            public byte[] Buffer;
+
+            public void Dispose()
+            {
+                ArrayPool<byte>.Shared.Return(Buffer, true);
+            }
+        }
+#endif
     }
-}
+}

test/SystemTextJson.JsonDiffPatch.Benchmark/DeepEqualsJsonFileBenchmark.cs

@@ -0,0 +1,51 @@
+using System.Text.Json;
+using System.Text.Json.JsonDiffPatch;
+using System.Text.Json.Nodes;
+using BenchmarkDotNet.Attributes;
+using Newtonsoft.Json.Linq;
+
+namespace SystemTextJson.JsonDiffPatch.Benchmark
+{
+    [IterationCount(10)]
+    public class QuickDeepEquals : JsonFileBenchmark
+    {
+        [Params(JsonFileSize.Small)]
+        public override JsonFileSize FileSize { get; set; }
+
+        [Benchmark]
+        public bool SystemTextJson()
+        {
+            var node1 = JsonNode.Parse(JsonLeft);
+            var node2 = JsonNode.Parse(JsonLeft);
+
+            return node1.DeepEquals(node2, JsonElementComparison.Semantic);
+        }
+
+        [Benchmark]
+        public bool SystemTextJson_Document()
+        {
+            var node1 = JsonDocument.Parse(JsonLeft);
+            var node2 = JsonDocument.Parse(JsonLeft);
+
+            return node1.DeepEquals(node2, JsonElementComparison.Semantic);
+        }
+
+        [Benchmark]
+        public bool SystemTextJson_Document_RawText()
+        {
+            var node1 = JsonDocument.Parse(JsonLeft);
+            var node2 = JsonDocument.Parse(JsonLeft);
+
+            return node1.DeepEquals(node2);
+        }
+
+        [Benchmark]
+        public JToken JsonNet()
+        {
+            var token1 = JToken.Parse(JsonLeft);
+            var token2 = JToken.Parse(JsonLeft);
+
+            return JToken.DeepEquals(token1, token2);
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.Benchmark/JsonNodeHelper.cs test/SystemTextJson.JsonDiffPatch.Benchmark/JsonHelper.cs

@@ -0,0 +1,32 @@
+using System.Text.Json.JsonDiffPatch;
+using System.Text.Json.Nodes;
+using BenchmarkDotNet.Attributes;
+using Newtonsoft.Json.Linq;
+
+namespace SystemTextJson.JsonDiffPatch.Benchmark
+{
+    [IterationCount(10)]
+    public class QuickDiff : JsonFileBenchmark
+    {
+        [Params(JsonFileSize.Small)]
+        public override JsonFileSize FileSize { get; set; }
+
+        [Benchmark]
+        public JsonNode? SystemTextJson()
+        {
+            var node1 = JsonNode.Parse(JsonLeft);
+            var node2 = JsonNode.Parse(JsonRight);
+
+            return node1.Diff(node2, BenchmarkHelper.CreateDiffOptionsWithJsonNetMatch());
+        }
+
+        [Benchmark]
+        public JToken JsonNet()
+        {
+            var token1 = JToken.Parse(JsonLeft);
+            var token2 = JToken.Parse(JsonRight);
+
+            return BenchmarkHelper.CreateJsonNetDiffPatch().Diff(token1, token2);
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.Benchmark/QuickDeepEquals.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests
+{
+    [SuppressMessage("ReSharper", "HeapView.BoxingAllocation")]
+    public static class DeepEqualsTestData
+    {
+        public static IEnumerable<object?[]> RawTextEqual(Func<string?, object?> jsonizer)
+        {
+            yield return new[] {jsonizer("true"), jsonizer("true"), true};
+            yield return new[] {jsonizer("true"), jsonizer("false"), false};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"2019-11-27\""), true};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"2019-11-27T00:00:00.000\""), false};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"Shaun is a rabbit\""), false};
+            yield return new[] {jsonizer("1"), jsonizer("1"), true};
+            yield return new[] {jsonizer("1"), jsonizer("2"), false};
+            yield return new[] {jsonizer("1.0"), jsonizer("1"), false};
+            yield return new[] {jsonizer("1.12e1"), jsonizer("11.2"), false};
+            yield return new[] {jsonizer("-1"), jsonizer("-1"), true};
+            yield return new[] {jsonizer("-1"), jsonizer("-1.0"), false};
+            yield return new[] {jsonizer("-1.1e1"), jsonizer("-11"), false};
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                true
+            };
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"b8baf656-8e97-4694-ae1a-be35e3a86db5\""),
+                false
+            };
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"9D423BBA-B9A8-4D19-A39A-B421BED58E02\""),
+                false
+            };
+            yield return new[] {jsonizer("\"Shaun is a rabbit\""), jsonizer("\"Shaun is a rabbit\""), true};
+            yield return new[] {jsonizer("\"Shaun is a rabbit\""), jsonizer("\"Shawn is a rabbit\""), false};
+            yield return new[] {jsonizer("1"), jsonizer("\"Shaun is a rabbit\""), false};
+        }
+
+        public static IEnumerable<object?[]> SemanticEqual(Func<string?, object?> jsonizer)
+        {
+            yield return new[] {jsonizer("true"), jsonizer("true"), true};
+            yield return new[] {jsonizer("true"), jsonizer("false"), false};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"2019-11-27\""), true};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"2019-11-27T00:00:00.000\""), true};
+            yield return new[] {jsonizer("\"2019-11-27\""), jsonizer("\"Shaun is a rabbit\""), false};
+            yield return new[] {jsonizer("1"), jsonizer("1"), true};
+            yield return new[] {jsonizer("1"), jsonizer("2"), false};
+            yield return new[] {jsonizer("1.0"), jsonizer("1"), true};
+            yield return new[] {jsonizer("1.12e1"), jsonizer("11.2"), true};
+            yield return new[] {jsonizer("-1"), jsonizer("-1"), true};
+            yield return new[] {jsonizer("-1"), jsonizer("-1.0"), true};
+            yield return new[] {jsonizer("-1.1e1"), jsonizer("-11"), true};
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                true
+            };
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"b8baf656-8e97-4694-ae1a-be35e3a86db5\""),
+                false
+            };
+            yield return new[]
+            {
+                jsonizer("\"9d423bba-b9a8-4d19-a39a-b421bed58e02\""),
+                jsonizer("\"9D423BBA-B9A8-4D19-A39A-B421BED58E02\""),
+                true
+            };
+            yield return new[] {jsonizer("\"Shaun is a rabbit\""), jsonizer("\"Shaun is a rabbit\""), true};
+            yield return new[] {jsonizer("\"Shaun is a rabbit\""), jsonizer("\"Shawn is a rabbit\""), false};
+            yield return new[] {jsonizer("1"), jsonizer("\"Shaun is a rabbit\""), false};
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.Benchmark/QuickDiff.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Text.Json.JsonDiffPatch;
+using Xunit;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests
+{
+    public class DefaultOptionsTests : IDisposable
+    {
+        private readonly JsonElementComparison _comparisonMode;
+
+        public DefaultOptionsTests()
+        {
+            _comparisonMode = JsonDiffPatcher.DefaultComparison;
+        }
+
+        [Fact]
+        public void DefaultDeepEqualsComparison_ComparerOptions()
+        {
+            JsonDiffPatcher.DefaultComparison = JsonElementComparison.Semantic;
+            
+            JsonComparerOptions comparerOptions = default;
+
+            Assert.Equal(JsonDiffPatcher.DefaultComparison, comparerOptions.JsonElementComparison);
+        }
+
+        [Fact]
+        public void DefaultDeepEqualsComparison_DiffOptions()
+        {
+            JsonDiffPatcher.DefaultComparison = JsonElementComparison.Semantic;
+
+            var diffOptions = new JsonDiffOptions();
+
+            Assert.Equal(JsonDiffPatcher.DefaultComparison, diffOptions.JsonElementComparison);
+        }
+
+        public void Dispose()
+        {
+            JsonDiffPatcher.DefaultComparison = _comparisonMode;
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/DeepEqualsTestData.cs

@@ -0,0 +1,149 @@
+using System.Text.Json;
+using System.Text.Json.JsonDiffPatch;
+using Xunit;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests.DocumentTests
+{
+    public class DeepEqualsTests
+    {
+        [Fact]
+        public void Default()
+        {
+            Assert.True(default(JsonDocument).DeepEquals(default));
+        }
+
+        [Fact]
+        public void Object_Identical()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            using var json2 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_Whitespace()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            using var json2 = JsonDocument.Parse("{  \"foo\":    \"bar\",    \"baz\":\"qux\"  }");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_PropertyOrdering()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            using var json2 = JsonDocument.Parse("{\"baz\":\"qux\",\"foo\":\"bar\"}");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_PropertyValue()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            using var json2 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"quz\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_MissingProperty()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            using var json2 = JsonDocument.Parse("{\"foo\":\"bar\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_ExtraProperty()
+        {
+            using var json1 = JsonDocument.Parse("{\"foo\":\"bar\"}");
+            using var json2 = JsonDocument.Parse("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_Identical()
+        {
+            using var json1 = JsonDocument.Parse("[1,2,3]");
+            using var json2 = JsonDocument.Parse("[1,2,3]");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_Whitespace()
+        {
+            using var json1 = JsonDocument.Parse("[1,2,3]");
+            using var json2 = JsonDocument.Parse("[ 1, 2, 3 ]");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ItemOrdering()
+        {
+            using var json1 = JsonDocument.Parse("[1,2,3]");
+            using var json2 = JsonDocument.Parse("[1,3,2]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ItemValue()
+        {
+            using var json1 = JsonDocument.Parse("[1,2,3]");
+            using var json2 = JsonDocument.Parse("[1,2,5]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_MissingItem()
+        {
+            using var json1 = JsonDocument.Parse("[1,2,3]");
+            using var json2 = JsonDocument.Parse("[1,2]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ExtraItem()
+        {
+            using var json1 = JsonDocument.Parse("[1,2]");
+            using var json2 = JsonDocument.Parse("[1,2,3]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Theory]
+        [MemberData(nameof(DocumentTestData.RawTextEqual), MemberType = typeof(DocumentTestData))]
+        public void Value_RawText(JsonDocument json1, JsonDocument json2, bool expected)
+        {
+            using (json1)
+            {
+                using (json2)
+                {
+                    Assert.Equal(expected, json1.DeepEquals(json2));
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(DocumentTestData.SemanticEqual), MemberType = typeof(DocumentTestData))]
+        public void Value_Semantic(JsonDocument json1, JsonDocument json2, bool expected)
+        {
+            using (json1)
+            {
+                using (json2)
+                {
+                    Assert.Equal(expected, json1.DeepEquals(json2, JsonElementComparison.Semantic));
+                }
+            }
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/DefaultOptionsTests.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Text.Json;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests.DocumentTests
+{
+    public class DocumentTestData
+    {
+        public static IEnumerable<object?[]> RawTextEqual => DeepEqualsTestData.RawTextEqual(Json);
+
+        public static IEnumerable<object?[]> SemanticEqual => DeepEqualsTestData.SemanticEqual(Json);
+
+        private static JsonDocument? Json(string? jsonValue)
+        {
+            return jsonValue is null ? null : JsonDocument.Parse($"{jsonValue}");
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/DocumentTests/DeepEqualsTests.cs

@@ -0,0 +1,137 @@
+using System.Text.Json;
+using System.Text.Json.JsonDiffPatch;
+using Xunit;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests.ElementTests
+{
+    public class DeepEqualsTests
+    {
+        [Fact]
+        public void Default()
+        {
+            Assert.True(default(JsonElement).DeepEquals(default));
+        }
+
+        [Fact]
+        public void Object_Identical()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_Whitespace()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{  \"foo\":    \"bar\",    \"baz\":\"qux\"  }");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_PropertyOrdering()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{\"baz\":\"qux\",\"foo\":\"bar\"}");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_PropertyValue()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"quz\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_MissingProperty()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Object_ExtraProperty()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\"}");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("{\"foo\":\"bar\",\"baz\":\"qux\"}");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_Identical()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_Whitespace()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[ 1, 2, 3 ]");
+
+            Assert.True(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ItemOrdering()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[1,3,2]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ItemValue()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[1,2,5]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_MissingItem()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[1,2]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Fact]
+        public void Array_ExtraItem()
+        {
+            var json1 = JsonSerializer.Deserialize<JsonElement>("[1,2]");
+            var json2 = JsonSerializer.Deserialize<JsonElement>("[1,2,3]");
+
+            Assert.False(json1.DeepEquals(json2));
+        }
+
+        [Theory]
+        [MemberData(nameof(ElementTestData.RawTextEqual), MemberType = typeof(ElementTestData))]
+        public void Value_RawText(JsonElement json1, JsonElement json2, bool expected)
+        {
+            Assert.Equal(expected, json1.DeepEquals(json2));
+        }
+        
+        [Theory]
+        [MemberData(nameof(ElementTestData.SemanticEqual), MemberType = typeof(ElementTestData))]
+        public void Value_Semantic(JsonElement json1, JsonElement json2, bool expected)
+        {
+            Assert.Equal(expected, json1.DeepEquals(json2, JsonElementComparison.Semantic));
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/DocumentTests/DocumentTestData.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Text.Json;
+
+namespace SystemTextJson.JsonDiffPatch.UnitTests.ElementTests
+{
+    public class ElementTestData
+    {
+        public static IEnumerable<object?[]> RawTextEqual => DeepEqualsTestData.RawTextEqual(Json);
+
+        public static IEnumerable<object?[]> SemanticEqual => DeepEqualsTestData.SemanticEqual(Json);
+
+        private static object? Json(string? jsonValue)
+        {
+            // ReSharper disable once HeapView.BoxingAllocation
+            return jsonValue is null
+                ? default
+                : JsonSerializer.Deserialize<JsonElement>($"{jsonValue}");
+        }
+    }
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/ElementTests/DeepEqualsTests.cs

@@ -4,7 +4,7 @@
 using System.Text.Json.Nodes;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests.Formatters
+namespace SystemTextJson.JsonDiffPatch.UnitTests.FormatterTests
 {
     public class JsonPatchDeltaFormatterTests
     {
@@ -162,4 +162,4 @@ public void JsonPointer_EscapeSpecialChar()
             Assert.Equal("[{\"op\":\"replace\",\"path\":\"/data/~1/~01\",\"value\":2}]", diff!.ToJsonString());
         }
     }
-}
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/ElementTests/ElementTestData.cs

@@ -2,7 +2,7 @@
 using System.Text.Json.Nodes;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests
+namespace SystemTextJson.JsonDiffPatch.UnitTests.NodeTests
 {
     public class DiffTests
     {

test/SystemTextJson.JsonDiffPatch.UnitTests/Formatters/JsonPatchDeltaFormatterTests.cs test/SystemTextJson.JsonDiffPatch.UnitTests/FormatterTests/JsonPatchDeltaFormatterTests.cs

@@ -1,11 +1,10 @@
 using System.Text.Json.JsonDiffPatch;
 using System.Text.Json.Nodes;
-using SystemTextJson.JsonDiffPatch.UnitTests.TestData;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests
+namespace SystemTextJson.JsonDiffPatch.UnitTests.NodeTests
 {
-    public class JsonElementDeepEqualsTests
+    public class ElementDeepEqualsTests
     {
         [Fact]
         public void Object_Identical()
@@ -116,21 +115,21 @@ public void Array_ExtraItem()
         }
 
         [Theory]
-        [MemberData(nameof(JsonValueTestData.ElementRawTextEqual), MemberType = typeof(JsonValueTestData))]
+        [MemberData(nameof(NodeTestData.ElementRawTextEqual), MemberType = typeof(NodeTestData))]
         public void Value_RawText(JsonValue json1, JsonValue json2, bool expected)
         {
             Assert.Equal(expected, json1.DeepEquals(json2));
         }
 
         [Theory]
-        [MemberData(nameof(JsonValueTestData.ElementSemanticEqual), MemberType = typeof(JsonValueTestData))]
+        [MemberData(nameof(NodeTestData.ElementSemanticEqual), MemberType = typeof(NodeTestData))]
         public void Value_Semantic(JsonValue json1, JsonValue json2, bool expected)
         {
             Assert.Equal(expected, json1.DeepEquals(json2, JsonElementComparison.Semantic));
         }
 
         [Theory]
-        [MemberData(nameof(JsonValueTestData.ElementObjectSemanticEqual), MemberType = typeof(JsonValueTestData))]
+        [MemberData(nameof(NodeTestData.ElementObjectSemanticEqual), MemberType = typeof(NodeTestData))]
         public void Value_ElementObjectSemanticEqual(JsonValue json1, JsonValue json2, bool expected)
         {
             Assert.Equal(expected, json1.DeepEquals(json2));

test/SystemTextJson.JsonDiffPatch.UnitTests/DiffTests.cs test/SystemTextJson.JsonDiffPatch.UnitTests/NodeTests/DiffTests.cs

@@ -2,7 +2,7 @@
 using System.Text.Json.Nodes;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests
+namespace SystemTextJson.JsonDiffPatch.UnitTests.NodeTests
 {
     public class JsonValueComparerTests
     {
@@ -74,4 +74,4 @@ public void Compare_EqualToZero(string? json1, string? json2)
             Assert.Equal(0, result);
         }
     }
-}
+}

test/SystemTextJson.JsonDiffPatch.UnitTests/JsonElementDeepEqualsTests.cs test/SystemTextJson.JsonDiffPatch.UnitTests/NodeTests/ElementDeepEqualsTests.cs

@@ -1,12 +1,17 @@
 using System.Text.Json.JsonDiffPatch;
 using System.Text.Json.Nodes;
-using SystemTextJson.JsonDiffPatch.UnitTests.TestData;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests
+namespace SystemTextJson.JsonDiffPatch.UnitTests.NodeTests
 {
     public class ObjectDeepEqualsTests
     {
+        [Fact]
+        public void Default()
+        {
+            Assert.True(default(JsonNode).DeepEquals(default));
+        }
+
         [Fact]
         public void Object_Identical()
         {
@@ -136,7 +141,7 @@ public void Array_ExtraItem()
         }
 
         [Theory]
-        [MemberData(nameof(JsonValueTestData.ObjectSemanticEqual), MemberType = typeof(JsonValueTestData))]
+        [MemberData(nameof(NodeTestData.ObjectSemanticEqual), MemberType = typeof(NodeTestData))]
         public void Value_ObjectSemanticEqual(JsonValue json1, JsonValue json2, bool expected)
         {
             Assert.Equal(expected, json1.DeepEquals(json2));

test/SystemTextJson.JsonDiffPatch.UnitTests/JsonValueComparerTests.cs test/SystemTextJson.JsonDiffPatch.UnitTests/NodeTests/JsonValueComparerTests.cs

@@ -3,7 +3,7 @@
 using System.Text.Json.Nodes;
 using Xunit;
 
-namespace SystemTextJson.JsonDiffPatch.UnitTests
+namespace SystemTextJson.JsonDiffPatch.UnitTests.NodeTests
 {
     public class PatchTests
     {