Paper work for 1.2.0 release (#13)

* Improve docs for 1.2.0
* Fix diff docs
* Add code owner file

Author: weichch

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @weichch

README.md

@@ -9,10 +9,10 @@ High-performance, low-allocating JSON objects diff and patch extension for Syste
 - 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 and custom array item matcher
+- 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` that implements semantic comparison of two `JsonValue` objects (including `JsonValue` backed by `JsonElement`)
+- 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`)
 - JSON assert for xUnit, MSTest v2 and NUnit with customizable delta output
 
 ## Install
@@ -25,6 +25,17 @@ High-performance, low-allocating JSON objects diff and patch extension for Syste
 ### Diff
 
 ```csharp
+// Diff JsonNode
+var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
+var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
+JsonNode? diff = node1.Diff(node2);
+// Diff with options
+JsonNode? 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());
 // Diff JSON files
 JsonNode? diff = JsonDiffPatcher.DiffFile(file1, file2);
 // Diff Span<byte>
@@ -35,52 +46,44 @@ JsonNode? diff = JsonDiffPatcher.Diff(stream1, stream2);
 JsonNode? diff = JsonDiffPatcher.Diff(json1, json2);
 // Diff JSON readers
 JsonNode? diff = JsonDiffPatcher.Diff(ref reader1, ref reader2);
-// Diff JsonNode objects
-var node1 = JsonNode.Parse(...);
-var node2 = JsonNode.Parse(...);
-JsonNode? diff = node1.Diff(node2);
-// Diff with options
-JsonNode? diff = node1.Diff(node2, new JsonDiffOptions { ... });
-// Diff and convert delta into RFC 6902 JSON Patch format
-JsonNode? diff = node1.Diff(node2, new JsonPatchDeltaFormatter());
 ```
 
 ### DeepClone
 
 ```csharp
-var node = JsonNode.Parse(...);
+var node = JsonNode.Parse("{\"foo\":\"bar\"}");
 JsonNode? cloned = node.DeepClone();
 ```
 
 ### DeepEquals
 
 ```csharp
-var node1 = JsonNode.Parse(...);
-var node2 = JsonNode.Parse(...);
+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\"]").First().AsValue();
-var node2 = JsonNode.Parse("[\"2019-11-27T00:00:00.000\"]").First().AsValue();
-
+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]").First().AsValue();
-var node4 = JsonNode.Parse("[1.00]").First().AsValue();
-
+var node3 = JsonNode.Parse("1");
+var node4 = JsonNode.Parse("1.00");
 // numCompare is 0
 var numCompare = JsonValueComparer.Compare(node3, node4);
 ```
 
 ### Patch & Unpatch
 
 ```csharp
-var node1 = JsonNode.Parse(...);
-var node2 = JsonNode.Parse(...);
+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);
@@ -92,11 +95,20 @@ JsonDiffPatcher.ReversePatch(ref node1, diff);
 node1.ReversePatchNew(diff);
 ```
 
+### Default Options
+
+```csharp
+JsonDiffPatcher.DefaultOptions = () => new JsonDiffOptions
+{
+    JsonElementComparison = JsonElementComparison.Semantic
+};
+```
+
 ### Assert (Unit Testing)
 
 ```csharp
-var expected = JsonNode.Parse(...);
-var actual = JsonNode.Parse(...);
+var expected = JsonNode.Parse("{\"foo\":\"bar\"}");
+var actual = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar3\"}");
 
 // xUnit
 JsonAssert.Equal(expected, actual);
@@ -122,18 +134,18 @@ Example output _(when output is enabled)_:
 JsonAssert.Equal() failure.
 Expected:
 {
-  "foo": "baz"
+  "foo": "bar"
 }
 Actual:
 {
-  "foo": "bar",
-  "baz": "qux"
+  "baz": "qux",
+  "foo": "bar"
 }
 Delta:
 {
   "foo": [
-    "baz",
-    "bar"
+    "bar",
+    "bar3"
   ],
   "baz": [
     "qux"

src/SystemTextJson.JsonDiffPatch/JsonValueComparisonContext.cs

@@ -405,12 +405,6 @@ public bool DeepEquals(ref JsonValueComparisonContext another, JsonElementCompar
             }
         }
 
-        public static bool IsValueKind(JsonValueKind jsonValueKind)
-        {
-            return jsonValueKind is JsonValueKind.Number or JsonValueKind.String or JsonValueKind.True
-                or JsonValueKind.False or JsonValueKind.Null;
-        }
-
         private static JsonStringValueKind GetStringValueKind(Type? valueType)
         {
             if (valueType == typeof(DateTime) || valueType == typeof(DateTimeOffset))